Skip to content

Self-improving AI Employees for everyone

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.py
index 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: E402
from 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"] = composed
if 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 context
workspace_dir = ctx.raw.get("workspace_dir") or params.working_directory
if 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.py
index 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) -> Dic
Business 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_state
session_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.py
index 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)
+
@staticmethod
async def _resolve_repo_root(
*,
diff --git a/server/services/cli_agent/session.py b/server/services/cli_agent/session.py
index 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__.py
new file mode 100644
index 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.py
new file mode 100644
index 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, removed
diff --git a/server/services/memory/markdown.py b/server/services/memory/markdown.py
new file mode 100644
index 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_texts
diff --git a/server/services/memory/state.py b/server/services/memory/state.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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 entry
diff --git a/server/tests/services/memory/__init__.py b/server/tests/services/memory/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/server/tests/services/memory/test_jsonl.py b/server/tests/services/memory/test_jsonl.py
new file mode 100644
index 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