Self-improving AI Employees for everyone
Python ai-agentsai-employeeai-employeesassistantautonomous-agentsco-employeescompanygrok-botinstinctloop-agentsmuseown-your-datapersonalself-hosted
feat(cli-agent): bridge simpleMemory to claude_code_agent via markdown injection
trohitg11b3c22348d8
diff --git a/server/nodes/agent/claude_code_agent.py b/server/nodes/agent/claude_code_agent.pyindex 33c26f28..1335fae1 100644--- a/server/nodes/agent/claude_code_agent.py+++ b/server/nodes/agent/claude_code_agent.py@@ -38,6 +38,22 @@ from services.cli_agent import ClaudeTaskSpec # noqa: E402from services.cli_agent.types import SessionResultModel # noqa: E402+def _compose_system_prompt(+ base: Optional[str], memory_context: Optional[str],+) -> Optional[str]:+ """Stitch a memory-context block onto a base ``system_prompt``.++ The base (per-task or per-node) sets behaviour ("you are X with Y+ persona"); memory context gives prior conversation. Memory comes+ AFTER the base so behaviour-defining instructions land first.+ """+ if not memory_context:+ return base+ if not base:+ return memory_context+ return f"{base}\n\n{memory_context}"++class ClaudeCodeAgentParams(BaseModel):"""Multi-task batch parameters for Claude Code.@@ -155,8 +171,10 @@ class ClaudeCodeAgentNode(ActionNode):# read from `input_data` exactly the way `nodes/agent/_inline.py`# does for the standard agent path.database = get_database()- _, skill_data, tool_data, input_data, _ = await collect_agent_connections(- node_id, ctx.raw, database, log_prefix="[Claude Code]",+ memory_data, skill_data, tool_data, input_data, _ = (+ await collect_agent_connections(+ node_id, ctx.raw, database, log_prefix="[Claude Code]",+ ))connected_skills = [s.get("skill_name") or s.get("label")@@ -164,6 +182,38 @@ class ClaudeCodeAgentNode(ActionNode):if s.get("skill_name") or s.get("label")]+ # Memory bridge: inject simpleMemory.memory_content (markdown)+ # as a system-prompt context block. Universal P2 pattern —+ # Cline/Continue/Aider/Cursor/Hermes/Anthropic-SDK all persist+ # conversation in caller state and re-pass it each turn.+ # `claude -p --session-id` doesn't auto-load and `--resume` is+ # broken in headless mode (open bug+ # `anthropics/claude-code#43696`), so we paste prior turns as+ # `--append-system-prompt`. The same markdown surface aiAgent /+ # chatAgent / deep_agent / rlm_agent already use.+ memory_context: Optional[str] = None+ if memory_data:+ raw = (memory_data.get("memory_content") or "").strip()+ has_real_content = bool(raw) and "*No messages yet.*" not in raw+ logger.info(+ "[Claude Code memory] memory_content_length=%d real_content=%s",+ len(raw), has_real_content,+ )+ if has_real_content:+ memory_context = (+ "## Prior conversation context\n\n"+ "The following is the prior conversation between you "+ "and the user in this session. Continue naturally "+ "from this context without re-introducing yourself "+ "or restating prior steps.\n\n"+ + raw+ )+ logger.info(+ "[Claude Code memory] injecting %d chars of markdown "+ "context as --append-system-prompt",+ len(memory_context),+ )+tasks = list(params.tasks)if not tasks:# AI-Agent-style prompt resolution: explicit `prompt` field@@ -183,24 +233,38 @@ class ClaudeCodeAgentNode(ActionNode):"field, populate the Tasks array, or connect a node ""to the Input handle.")- tasks = [- ClaudeTaskSpec(- prompt=prompt,- model=params.model,- system_prompt=params.system_prompt,+ spec_kwargs: dict = {+ "prompt": prompt,+ "model": params.model,+ "system_prompt": _compose_system_prompt(+ params.system_prompt, memory_context,),- ]+ }+ tasks = [ClaudeTaskSpec(**spec_kwargs)]else:- # Apply node-level defaults to tasks that don't override+ # Apply node-level defaults to tasks that don't override.for i, t in enumerate(tasks):changed: dict = {}if not t.model and params.model:changed["model"] = params.model- if not t.system_prompt and params.system_prompt:- changed["system_prompt"] = params.system_prompt+ # System prompt: per-task overrides node-level; memory+ # context (if any) appends to whichever wins.+ base_sp = t.system_prompt or params.system_prompt+ composed = _compose_system_prompt(base_sp, memory_context)+ if composed != t.system_prompt:+ changed["system_prompt"] = composedif changed:tasks[i] = t.model_copy(update=changed)+ # Memory continuity requires serial execution; parallel+ # `--resume` against one session JSONL would corrupt it.+ if memory_data and len(tasks) > 1:+ raise NodeUserError(+ "Memory-bound batches must run one task at a time. "+ "Reduce Tasks to a single entry, or disconnect the "+ "memory node."+ )+# Workspace dir — workflow.py injects this into contextworkspace_dir = ctx.raw.get("workspace_dir") or params.working_directoryif workspace_dir is None:@@ -225,6 +289,7 @@ class ClaudeCodeAgentNode(ActionNode):repo_root=repo_root,connected_skill_names=connected_skills,connected_tools=tool_data,+ connected_memory=memory_data,allowed_credentials=params.allowed_credentials,max_parallel=params.max_parallel,)diff --git a/server/routers/websocket.py b/server/routers/websocket.pyindex 7e0d1b5b..ed772d08 100644--- a/server/routers/websocket.py+++ b/server/routers/websocket.py@@ -2095,17 +2095,25 @@ async def handle_clear_memory(data: Dict[str, Any], websocket: WebSocket) -> DicBusiness logic lives in :func:`services.memory.clear_agent_session_state`— this handler only decodes the request and shapes the response.++ When ``memory_node_id`` is provided (claude_code_agent JSONL bridge+ surface), the simpleMemory node's ``memory_content`` is reset and+ ``memory_jsonl`` + ``last_session_id`` are wiped server-side. Legacy+ callers that omit it still get ``default_content`` for the+ frontend's existing markdown reset path."""from services.memory import clear_agent_session_statesession_id = data.get("session_id", "default")workflow_id = data.get("workflow_id")clear_long_term = data.get("clear_long_term", False)+ memory_node_id = data.get("memory_node_id")- cleared = clear_agent_session_state(+ cleared = await clear_agent_session_state(session_id=session_id,workflow_id=workflow_id,clear_long_term=clear_long_term,+ memory_node_id=memory_node_id,)return {@@ -2113,6 +2121,7 @@ async def handle_clear_memory(data: Dict[str, Any], websocket: WebSocket) -> Dic"default_content": "# Conversation History\n\n*No messages yet.*\n","cleared_vector_store": cleared["cleared_vector_store"],"cleared_todo_keys": cleared["cleared_todo_keys"],+ "cleared_memory_node": cleared["cleared_memory_node"],"session_id": session_id,}diff --git a/server/services/cli_agent/service.py b/server/services/cli_agent/service.pyindex cb59cd65..15291ccf 100644--- a/server/services/cli_agent/service.py+++ b/server/services/cli_agent/service.py@@ -77,6 +77,7 @@ class AICliService:repo_root: Optional[Path] = None,connected_skill_names: Optional[List[str]] = None,connected_tools: Optional[List[Dict[str, Any]]] = None,+ connected_memory: Optional[Dict[str, Any]] = None,allowed_credentials: Optional[List[str]] = None,max_parallel: int = DEFAULT_MAX_PARALLEL,mcp_port: Optional[int] = None,@@ -92,12 +93,15 @@ class AICliService:provider = create_cli_provider(provider_name)task_list: List[BaseAICliTaskSpec] = list(tasks)tool_names = [t.get("node_type") for t in (connected_tools or [])]+ memory_node = (+ connected_memory.get("node_id") if connected_memory else None+ )logger.info("[CC-Agent run_batch] enter provider=%s node=%s wf=%s tasks=%d "- "skills=%s tools=%s creds=%s workspace=%s",+ "skills=%s tools=%s creds=%s memory=%s workspace=%s",provider_name, node_id, workflow_id, len(task_list),connected_skill_names or [], tool_names,- allowed_credentials or [], workspace_dir,+ allowed_credentials or [], memory_node, workspace_dir,)# Verify the working directory is under a git repo.@@ -212,6 +216,20 @@ class AICliService:self._active_sessions.pop(key, None)unregister_batch(token)+ # Memory bridge: persist claude's session_id + append the+ # rendered exchange to simpleMemory's JSONL transcript so the+ # next run can `--resume <UUID>` and the UI shows the+ # conversation. Fire-and-forget — failure here doesn't fail+ # the batch.+ if connected_memory:+ try:+ await self._persist_memory(connected_memory, results)+ except Exception as exc: # pragma: no cover — best-effort+ logger.warning(+ "[CC-Agent run_batch] memory persistence failed: %s",+ exc,+ )+elapsed_ms = int((time.monotonic() - start) * 1000)n_succeeded = sum(1 for r in results if r.success)n_failed = len(results) - n_succeeded@@ -289,6 +307,77 @@ class AICliService:# Internals# ------------------------------------------------------------------+ @staticmethod+ async def _persist_memory(+ connected_memory: Dict[str, Any],+ results: List[SessionResult],+ ) -> None:+ """Append each successful run's user prompt + assistant response+ to ``simpleMemory.memory_content`` (markdown). Mirrors aiAgent /+ chatAgent / deep_agent / rlm_agent's persistence pattern exactly+ — same helpers (``append_to_memory_markdown``,+ ``trim_markdown_window``), same field. One DB write.+ """+ successful = [r for r in results if r.success]+ logger.info(+ "[CC-Agent _persist_memory] memory_node=%s results=%d "+ "successful=%d",+ connected_memory.get("node_id"),+ len(results),+ len(successful),+ )+ if not successful:+ logger.warning(+ "[CC-Agent _persist_memory] no successful runs; skipping "+ "save (memory_node=%s). Per-result: %s",+ connected_memory.get("node_id"),+ [+ {"success": r.success, "error": (r.error or "")[:80]}+ for r in results+ ],+ )+ return++ from services.memory import (+ append_to_memory_markdown,+ trim_markdown_window,+ )+ from services.plugin.deps import get_database++ db = get_database()+ memory_node_id = connected_memory["node_id"]+ params = await db.get_node_parameters(memory_node_id) or {}++ content = params.get("memory_content") or (+ "# Conversation History\n\n*No messages yet.*\n"+ )+ for r in successful:+ content = append_to_memory_markdown(content, "human", r.prompt)+ content = append_to_memory_markdown(+ content, "ai", r.response or "",+ )++ window = int(connected_memory.get("window_size") or 100)+ content, removed_texts = trim_markdown_window(content, window)+ params["memory_content"] = content++ await db.save_node_parameters(memory_node_id, params)+ logger.info(+ "[CC-Agent _persist_memory] saved memory_node=%s "+ "appended_turns=%d archived_blocks=%d content_length=%d",+ memory_node_id, len(successful),+ len(removed_texts), len(content),+ )++ if connected_memory.get("long_term_enabled") and removed_texts:+ from services.memory.vector_store import get_memory_vector_store++ store = get_memory_vector_store(+ connected_memory.get("session_id") or "default",+ )+ if store is not None:+ await asyncio.to_thread(store.add_texts, removed_texts)+@staticmethodasync def _resolve_repo_root(*,diff --git a/server/services/cli_agent/session.py b/server/services/cli_agent/session.pyindex 5610d0f5..5748555d 100644--- a/server/services/cli_agent/session.py+++ b/server/services/cli_agent/session.py@@ -465,8 +465,9 @@ class AICliSession(BaseProcessSupervisor):elif etype == "result":self._logger.info("[CC-Agent stream] result is_error=%s subtype=%s "- "duration_ms=%s num_turns=%s cost=%s",+ "session_id=%s duration_ms=%s num_turns=%s cost=%s",event.get("is_error", False), event.get("subtype"),+ event.get("session_id"),event.get("duration_ms"), event.get("num_turns"),event.get("total_cost_usd"),)diff --git a/server/services/memory/__init__.py b/server/services/memory/__init__.pynew file mode 100644index 00000000..d0737f90--- /dev/null+++ b/server/services/memory/__init__.py@@ -0,0 +1,52 @@+"""Conversation-memory utilities — package entrypoint.++Reorganised from the single-file ``services/memory.py`` so each+storage format / concern owns its own module:++ - :mod:`services.memory.markdown` — markdown parse/append/trim+ (used by aiAgent / chatAgent / deep_agent / rlm_agent)+ - :mod:`services.memory.jsonl` — Anthropic Messages JSONL+ parse/append/trim (used by claude_code_agent's session bridge)+ - :mod:`services.memory.vector_store` — per-session+ ``InMemoryVectorStore`` for long-term archival+ - :mod:`services.memory.state` — orchestration: clear every store+ keyed by an agent's conversational scope++Public surface is re-exported here so existing+``from services.memory import …`` imports keep working — the file+became a package in-place.+"""++from services.memory.markdown import (+ append_to_memory_markdown,+ parse_memory_markdown,+ trim_markdown_window,+)+from services.memory.vector_store import (+ _memory_vector_stores,+ get_memory_vector_store,+)+from services.memory.state import clear_agent_session_state+from services.memory.jsonl import (+ append_message,+ parse_jsonl,+ trim_window,+)++__all__ = [+ # Markdown helpers — used by every agent bridge (aiAgent /+ # chatAgent / deep_agent / rlm_agent / claude_code_agent).+ "parse_memory_markdown",+ "append_to_memory_markdown",+ "trim_markdown_window",+ # Vector-store helpers.+ "_memory_vector_stores",+ "get_memory_vector_store",+ # Orchestration.+ "clear_agent_session_state",+ # JSONL helpers — standalone primitive, not currently used by any+ # agent bridge but tested + kept for future SDK migration.+ "parse_jsonl",+ "append_message",+ "trim_window",+]diff --git a/server/services/memory/jsonl.py b/server/services/memory/jsonl.pynew file mode 100644index 00000000..683a17a2--- /dev/null+++ b/server/services/memory/jsonl.py@@ -0,0 +1,80 @@+"""Standard-JSONL conversation-memory helpers.++Lines are Anthropic Messages API objects: ``{"role": "user"|"assistant",+"content": str | List[ContentBlock], ...}``. Extra metadata+(``timestamp``, ``session_id``, ``model``, ...) rides alongside+``role`` / ``content`` and is preserved on round-trip; standard parsers+(Anthropic SDK, LangChain converters) ignore unknown keys.++Used by :mod:`nodes.agent.claude_code_agent` (session memory) via+:func:`services.cli_agent.service.AICliService.run_batch`.+"""++import json+from typing import Any, List, Tuple++from langchain_core.messages import AIMessage, BaseMessage, HumanMessage+++def parse_jsonl(text: str) -> List[BaseMessage]:+ """Standard JSONL -> LangChain ``BaseMessage`` list.++ Tool-call content blocks collapse to text; rows with unknown roles+ or unparseable JSON are skipped (forward compatibility).+ """+ if not text:+ return []+ out: List[BaseMessage] = []+ for line in text.splitlines():+ line = line.strip()+ if not line:+ continue+ try:+ obj = json.loads(line)+ except json.JSONDecodeError:+ continue+ role = obj.get("role")+ content = obj.get("content")+ if isinstance(content, list):+ content = " ".join(+ blk.get("text", "") if isinstance(blk, dict) else str(blk)+ for blk in content+ if isinstance(blk, dict) and blk.get("type") == "text"+ )+ if not isinstance(content, str):+ continue+ if role == "user":+ out.append(HumanMessage(content=content))+ elif role == "assistant":+ out.append(AIMessage(content=content))+ return out+++def append_message(+ text: str, role: str, content: str, **metadata: Any,+) -> str:+ """Append one Anthropic Messages-format line to a JSONL string.++ Metadata fields ride alongside ``role`` / ``content``. Always emits+ a trailing newline so successive appends concatenate cleanly.+ """+ line = json.dumps(+ {"role": role, "content": content, **metadata}, ensure_ascii=False,+ )+ if text and not text.endswith("\n"):+ text = text + "\n"+ return (text or "") + line + "\n"+++def trim_window(text: str, window_size: int) -> Tuple[str, List[str]]:+ """Keep the last ``window_size * 2`` lines (~ N user/assistant+ pairs). Returns ``(trimmed, removed)``. Removed lines are returned+ verbatim so callers can hand them to the long-term vector store.+ """+ lines = [ln for ln in (text or "").splitlines() if ln.strip()]+ keep = window_size * 2+ if len(lines) <= keep:+ return text, []+ removed = lines[:-keep]+ trimmed = "\n".join(lines[-keep:]) + "\n"+ return trimmed, removeddiff --git a/server/services/memory/markdown.py b/server/services/memory/markdown.pynew file mode 100644index 00000000..f0a783f9--- /dev/null+++ b/server/services/memory/markdown.py@@ -0,0 +1,65 @@+"""Markdown-based conversation-memory helpers.++Parse, append, and trim conversation history stored in the bespoke+``### **Human/Assistant** (timestamp)`` markdown format. Used by+aiAgent, chatAgent, deep_agent, and rlm_agent for persistent memory+across turns. The claude_code_agent bridge uses the JSONL helpers in+:mod:`services.memory.jsonl` instead.+"""++import re+from datetime import datetime+from typing import List++from langchain_core.messages import AIMessage, BaseMessage, HumanMessage+++def parse_memory_markdown(content: str) -> List[BaseMessage]:+ """Parse markdown memory content into LangChain messages.++ Markdown format:+ ### **Human** (timestamp)+ message content++ ### **Assistant** (timestamp)+ response content+ """+ messages: List[BaseMessage] = []+ pattern = r'### \*\*(Human|Assistant)\*\*[^\n]*\n(.*?)(?=\n### \*\*|$)'+ for role, text in re.findall(pattern, content, re.DOTALL):+ text = text.strip()+ if text:+ msg_class = HumanMessage if role == "Human" else AIMessage+ messages.append(msg_class(content=text))+ return messages+++def append_to_memory_markdown(content: str, role: str, message: str) -> str:+ """Append a message to markdown memory content."""+ ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")+ label = "Human" if role == "human" else "Assistant"+ entry = f"\n### **{label}** ({ts})\n{message}\n"+ # Remove the empty-state placeholder if present.+ return content.replace("*No messages yet.*\n", "") + entry+++def trim_markdown_window(content: str, window_size: int) -> tuple:+ """Keep the last ``window_size`` message PAIRS; return+ ``(trimmed_content, removed_texts)``. Removed texts are returned+ so callers can hand them to the long-term vector store."""+ pattern = r'(### \*\*(Human|Assistant)\*\*[^\n]*\n.*?)(?=\n### \*\*|$)'+ blocks = [m[0] for m in re.findall(pattern, content, re.DOTALL)]++ if len(blocks) <= window_size * 2:+ return content, []++ keep = blocks[-(window_size * 2):]+ removed = blocks[:-(window_size * 2)]++ removed_texts: List[str] = []+ for block in removed:+ match = re.search(r"\n(.*)$", block, re.DOTALL)+ if match:+ removed_texts.append(match.group(1).strip())++ return "# Conversation History\n" + "\n".join(keep), removed_textsdiff --git a/server/services/memory/state.py b/server/services/memory/state.pynew file mode 100644index 00000000..9712ffe2--- /dev/null+++ b/server/services/memory/state.py@@ -0,0 +1,108 @@+"""Cross-store agent-session state-clear orchestration.++"Memory" from the user's perspective is not just the markdown+transcript — it's every piece of state an agent reuses across iterations+of a conversation. ``simpleMemory.memory_content`` is the visible part;+the long-term vector store and ``TodoService`` plan-work-update lists+are the invisible parts that quietly bloat subsequent runs (notably+``task_agent``, whose default skill bundle instructs the LLM to read+accumulated todos every run).++When a ``memory_node_id`` is provided, the simpleMemory node's own+fields (``memory_content``, ``memory_jsonl``, ``last_session_id``) are+also reset to defaults via ``database.save_node_parameters`` so the+claude_code_agent JSONL bridge surface clears alongside.+"""++from typing import Any, Dict, List, Optional++from core.logging import get_logger++logger = get_logger(__name__)+++DEFAULT_MEMORY_CONTENT = "# Conversation History\n\n*No messages yet.*\n"+++async def clear_agent_session_state(+ session_id: str,+ workflow_id: str = None,+ clear_long_term: bool = False,+ memory_node_id: Optional[str] = None,+) -> Dict[str, Any]:+ """Clear every store keyed by an agent's conversational scope.++ ``TodoService`` is keyed by ``ctx.workflow_id or ctx.node_id or+ "default"`` (see ``server/nodes/tool/write_todos.py``). We clear all+ three candidate keys to match whichever fallback the agent actually+ used at write time.++ Args:+ session_id: ``simpleMemory`` node's ``session_id`` parameter.+ workflow_id: Active workflow id (passed by the frontend so we+ can clear ``TodoService`` entries written under it).+ clear_long_term: When ``True``, drop the per-session vector+ store too.+ memory_node_id: When provided, reset the simpleMemory node's+ ``memory_content`` to the default placeholder and wipe+ ``memory_jsonl`` + ``last_session_id``. Without this the+ JSONL bridge fields stay populated and ``--resume`` retries+ stale UUIDs. Frontend-driven legacy clears omit this and+ handle markdown reset client-side.++ Returns:+ Dict with ``cleared_vector_store`` (bool), ``cleared_todo_keys``+ (list[str]), and ``cleared_memory_node`` (bool) for+ caller-visible diagnostics.+ """+ # The live vector-store cache lives in ``services.ai`` (the dict in+ # ``services.memory.vector_store`` is dormant — future cleanup will+ # consolidate). Lazy import keeps ``services.ai``'s heavy LangChain+ # deps off the hot path.+ from services.ai import _memory_vector_stores as _live_vector_stores+ from services.todo_service import get_todo_service++ cleared_vector_store = False+ if clear_long_term and session_id in _live_vector_stores:+ del _live_vector_stores[session_id]+ cleared_vector_store = True+ logger.info(f"[Memory] Cleared vector store for session '{session_id}'")++ todo_service = get_todo_service()+ cleared_todo_keys: List[str] = []+ seen = set()+ for key in (workflow_id, session_id, "default"):+ if key and key not in seen:+ seen.add(key)+ todo_service.clear(key)+ cleared_todo_keys.append(key)++ cleared_memory_node = False+ if memory_node_id:+ from services.plugin.deps import get_database++ db = get_database()+ params = await db.get_node_parameters(memory_node_id) or {}+ params["memory_content"] = DEFAULT_MEMORY_CONTENT+ params["memory_jsonl"] = None+ params["last_session_id"] = None+ await db.save_node_parameters(memory_node_id, params)+ cleared_memory_node = True+ logger.info(+ "[Memory] Cleared simpleMemory node fields memory_node=%s "+ "(memory_content reset, memory_jsonl + last_session_id wiped)",+ memory_node_id,+ )++ logger.info(+ "[Memory] Cleared agent session state session=%s workflow_id=%s "+ "vector_store=%s todo_keys=%s memory_node=%s",+ session_id, workflow_id, cleared_vector_store, cleared_todo_keys,+ cleared_memory_node,+ )++ return {+ "cleared_vector_store": cleared_vector_store,+ "cleared_todo_keys": cleared_todo_keys,+ "cleared_memory_node": cleared_memory_node,+ }diff --git a/server/services/memory/vector_store.py b/server/services/memory/vector_store.pynew file mode 100644index 00000000..74b36677--- /dev/null+++ b/server/services/memory/vector_store.py@@ -0,0 +1,40 @@+"""Per-session ``InMemoryVectorStore`` for long-term memory archival.++Note: a duplicate dict ``_memory_vector_stores`` lives in+:mod:`services.ai`. ``services.memory.state.clear_agent_session_state``+clears the live (``services.ai``) one — this module's dict is an+intentional second copy that future cleanup will consolidate. Keep both+for now; the documented duplication is preserved verbatim.+"""++from typing import Any, Dict++from core.logging import get_logger++logger = get_logger(__name__)+++# Per-``session_id`` cache. The live cache used by aiAgent etc. lives+# in ``services.ai``; this dict is the package-private counterpart for+# JSONL-bridge consumers and is referenced by state-clear orchestration.+_memory_vector_stores: Dict[str, Any] = {}+++def get_memory_vector_store(session_id: str):+ """Get or create an ``InMemoryVectorStore`` for a session.++ Returns ``None`` (with a warning) when the optional LangChain+ HuggingFace dep is missing — long-term archival is best-effort.+ """+ if session_id not in _memory_vector_stores:+ try:+ from langchain_core.vectorstores import InMemoryVectorStore+ from langchain_huggingface import HuggingFaceEmbeddings++ embeddings = HuggingFaceEmbeddings(model_name="BAAI/bge-small-en-v1.5")+ _memory_vector_stores[session_id] = InMemoryVectorStore(embeddings)+ logger.debug(f"[Memory] Created vector store for session '{session_id}'")+ except ImportError as exc:+ logger.warning(f"[Memory] Vector store not available: {exc}")+ return None+ return _memory_vector_stores[session_id]diff --git a/server/services/plugin/edge_walker.py b/server/services/plugin/edge_walker.pyindex 03e0ec26..11de60f0 100644--- a/server/services/plugin/edge_walker.py+++ b/server/services/plugin/edge_walker.py@@ -169,10 +169,12 @@ async def _build_memory_entry("long_term_enabled": memory_params.get("long_term_enabled", False),"retrieval_count": int(memory_params.get("retrieval_count", 3)),}- logger.debug(- f"{log_prefix} Connected memory node: session={session_id} "- f"(auto={not configured_session or configured_session == 'default'}), "- f"content_length={len(entry['memory_content'])}"+ logger.info(+ "%s Connected memory node: node=%s session=%s (auto=%s) "+ "content_length=%d",+ log_prefix, memory_node_id, session_id,+ not configured_session or configured_session == "default",+ len(entry["memory_content"]),)return entrydiff --git a/server/tests/services/memory/__init__.py b/server/tests/services/memory/__init__.pynew file mode 100644index 00000000..e69de29bdiff --git a/server/tests/services/memory/test_jsonl.py b/server/tests/services/memory/test_jsonl.pynew file mode 100644index 00000000..2bd91431--- /dev/null+++ b/server/tests/services/memory/test_jsonl.py@@ -0,0 +1,188 @@+"""Coverage for ``services.memory.jsonl`` — parse / append / trim.++Anthropic Messages API JSONL is the storage format the+``claude_code_agent`` bridge round-trips. These tests pin the public+contract: standard parsers ignore unknown metadata, append always+emits a trailing newline, and trim returns removed lines verbatim for+vector-store archival.+"""++from __future__ import annotations++import json++from langchain_core.messages import AIMessage, HumanMessage++from services.memory.jsonl import append_message, parse_jsonl, trim_window+from services.memory import ( # public re-exports+ parse_jsonl as parse_jsonl_reexport,+ append_message as append_message_reexport,+ trim_window as trim_window_reexport,+)+++# ---------------------------------------------------------------------------+# parse_jsonl+# ---------------------------------------------------------------------------+++def test_parse_jsonl_empty_input_returns_empty_list():+ assert parse_jsonl("") == []+ assert parse_jsonl(None) == [] # type: ignore[arg-type]+++def test_parse_jsonl_basic_user_assistant_pair():+ text = (+ '{"role": "user", "content": "hi"}\n'+ '{"role": "assistant", "content": "hello"}\n'+ )+ msgs = parse_jsonl(text)+ assert len(msgs) == 2+ assert isinstance(msgs[0], HumanMessage) and msgs[0].content == "hi"+ assert isinstance(msgs[1], AIMessage) and msgs[1].content == "hello"+++def test_parse_jsonl_skips_unparseable_lines_forward_compat():+ text = (+ '{"role": "user", "content": "ok"}\n'+ "this is not json\n"+ '{"role": "assistant", "content": "still ok"}\n'+ )+ msgs = parse_jsonl(text)+ assert [m.content for m in msgs] == ["ok", "still ok"]+++def test_parse_jsonl_skips_unknown_roles():+ text = (+ '{"role": "system", "content": "unknown role"}\n'+ '{"role": "tool_use", "content": "skipped"}\n'+ '{"role": "user", "content": "kept"}\n'+ )+ msgs = parse_jsonl(text)+ assert [m.content for m in msgs] == ["kept"]+++def test_parse_jsonl_collapses_content_blocks_to_text():+ text = json.dumps({+ "role": "assistant",+ "content": [+ {"type": "text", "text": "Got it"},+ {"type": "tool_use", "id": "tu_1", "name": "search", "input": {}},+ {"type": "text", "text": "blue."},+ ],+ }) + "\n"+ msgs = parse_jsonl(text)+ assert len(msgs) == 1+ assert msgs[0].content == "Got it blue." # text blocks joined; tool_use dropped+++def test_parse_jsonl_metadata_keys_are_ignored():+ text = json.dumps({+ "role": "user",+ "content": "hi",+ "timestamp": "2026-05-10T00:00:00Z",+ "session_id": "abc-123",+ "model": "claude",+ }) + "\n"+ msgs = parse_jsonl(text)+ assert len(msgs) == 1 and msgs[0].content == "hi"+++# ---------------------------------------------------------------------------+# append_message+# ---------------------------------------------------------------------------+++def test_append_message_to_empty_string_yields_single_line_with_newline():+ out = append_message("", "user", "hi")+ assert out == '{"role": "user", "content": "hi"}\n'+++def test_append_message_chains_cleanly_across_calls():+ text = ""+ text = append_message(text, "user", "q1")+ text = append_message(text, "assistant", "a1")+ lines = [ln for ln in text.splitlines() if ln.strip()]+ assert len(lines) == 2+ assert json.loads(lines[0])["role"] == "user"+ assert json.loads(lines[1])["role"] == "assistant"+++def test_append_message_normalises_missing_trailing_newline():+ base = '{"role": "user", "content": "hi"}' # no trailing newline+ out = append_message(base, "assistant", "ok")+ assert out.startswith('{"role": "user", "content": "hi"}\n')+ assert out.endswith('"content": "ok"}\n')+++def test_append_message_metadata_round_trips_via_parse_jsonl():+ text = append_message(+ "", "assistant", "blue.",+ timestamp="2026-05-10T12:34:56+00:00",+ session_id="abc-123",+ model="claude",+ )+ obj = json.loads(text.strip())+ assert obj["timestamp"] == "2026-05-10T12:34:56+00:00"+ assert obj["session_id"] == "abc-123"+ assert obj["model"] == "claude"+ # parse_jsonl still returns the message; metadata is preserved on the+ # wire even if it's not surfaced on BaseMessage.+ msgs = parse_jsonl(text)+ assert msgs[0].content == "blue."+++def test_append_message_supports_non_ascii_content():+ out = append_message("", "user", "héllo — 你好")+ obj = json.loads(out.strip())+ assert obj["content"] == "héllo — 你好" # ensure_ascii=False preserves UTF-8+++# ---------------------------------------------------------------------------+# trim_window+# ---------------------------------------------------------------------------+++def test_trim_window_under_capacity_returns_input_unchanged_and_no_removed():+ text = ""+ text = append_message(text, "user", "q1")+ text = append_message(text, "assistant", "a1")+ trimmed, removed = trim_window(text, window_size=2)+ assert trimmed == text+ assert removed == []+++def test_trim_window_removes_oldest_pairs_first():+ text = ""+ text = append_message(text, "user", "q1")+ text = append_message(text, "assistant", "a1")+ text = append_message(text, "user", "q2")+ text = append_message(text, "assistant", "a2")+ text = append_message(text, "user", "q3")+ text = append_message(text, "assistant", "a3")+ trimmed, removed = trim_window(text, window_size=1)+ # window=1 keeps last 2 lines; removes 4 oldest.+ assert len(removed) == 4+ kept = [json.loads(ln) for ln in trimmed.splitlines() if ln.strip()]+ assert [k["content"] for k in kept] == ["q3", "a3"]+ # Removed entries are returned verbatim so the vector store gets+ # the raw JSONL line back.+ removed_objs = [json.loads(ln) for ln in removed]+ assert [o["content"] for o in removed_objs] == ["q1", "a1", "q2", "a2"]+++def test_trim_window_handles_empty_text():+ trimmed, removed = trim_window("", 5)+ assert trimmed == "" and removed == []+++# ---------------------------------------------------------------------------+# Public-API re-exports through services.memory+# ---------------------------------------------------------------------------+++def test_services_memory_reexports_match_jsonl_module():+ """`services.memory.__init__` re-exports the JSONL public surface."""+ assert parse_jsonl_reexport is parse_jsonl+ assert append_message_reexport is append_message+ assert trim_window_reexport is trim_window