fix(memory): inject memories into ~/.claude/CLAUDE.md so Claude actually loads them

Stock Claude Code (in the CODA container, version 2.1.19) auto-loads
CLAUDE.md files from cwd-walked-up parents and ~/.claude/CLAUDE.md, but
does NOT auto-load files under ~/.claude/projects/<encoded>/memory/ —
that path is a harness-level convention, not stock behavior.

The injector now splices the rendered memory section into
~/.claude/CLAUDE.md between explicit <!-- BEGIN/END CODA MEMORY -->
markers, so regenerations replace just our section without clobbering
other content. setup_memory.py does a single startup splice with
project_name=None (all memories), and extractor.py does the same after
each Stop hook. Cross-project lessons are visible in every session
since the user might cd anywhere.

Verified end-to-end: a fresh `claude -p` session quoted the
content_hash dedup rule verbatim from ~/.claude/CLAUDE.md, with no
tool calls or file reads.

Co-authored-by: Isaac

Author: dgokeeffe

memory/extractor.py

@@ -229,15 +229,17 @@ def stop_hook_handler() -> None:
         _trace(f"Lakebase write error: {type(e).__name__}: {e}")
         return
 
-    # Regenerate local MEMORY.md so next session sees updated memories
+    # Splice the full memory set into ~/.claude/CLAUDE.md so the next Claude
+    # session sees everything — cross-project lessons too, since the user may
+    # cd anywhere. project_name=None pulls all of this owner's memories.
     try:
         from memory.injector import regenerate_memory_file
 
-        path = regenerate_memory_file(owner_email, project_name)
+        path = regenerate_memory_file(owner_email, None)
         if path:
-            print(f"[coda-memory] memory file updated: {path}", file=sys.stderr)
+            _trace(f"memory file updated: {path}")
     except Exception as e:
-        print(f"[coda-memory] memory file update error: {e}", file=sys.stderr)
+        _trace(f"memory file update error: {e}")
 
 
 if __name__ == "__main__":

memory/injector.py

@@ -1,12 +1,22 @@
-"""Regenerate Claude Code's MEMORY.md from Lakebase-backed memories.
-
-Claude Code auto-loads every file inside ~/.claude/projects/<hash>/memory/
-at session start. By writing coda_memory.md there after each session,
-memories are injected into the next session's context at zero extra cost.
+"""Inject Lakebase-backed memories into Claude Code's auto-loaded CLAUDE.md.
+
+Stock Claude Code (used in CODA) auto-loads `CLAUDE.md` files from:
+  - `./CLAUDE.md` and parents walked up (project-level)
+  - `~/.claude/CLAUDE.md` (user global)
+
+We write the rendered memories into `~/.claude/CLAUDE.md`, between explicit
+markers so we can update just our section on each Stop hook without clobbering
+any user-authored content above or below. The user-global path means memories
+are visible in every Claude session regardless of cwd, which matches the way
+Lakebase already aggregates rows across projects under `owner_email`.
+
+(The `~/.claude/projects/<encoded>/memory/MEMORY.md` path some harnesses use
+for auto-memory is NOT part of stock Claude Code 2.x — verified empirically
+against `claude --version` 2.1.19 in the CODA container, which did not load
+files from that path.)
 """
 from __future__ import annotations
 
-import hashlib
 import os
 from datetime import datetime, timezone
 from pathlib import Path
@@ -21,59 +31,78 @@
 
 _CAP_PER_SECTION = 12
 
+_BEGIN_MARKER = "<!-- BEGIN CODA MEMORY -->"
+_END_MARKER = "<!-- END CODA MEMORY -->"
 
-def _memory_dir(project_name: str | None) -> Path:
-    """Return the Claude Code memory directory for a project (or global)."""
-    home = Path(os.environ.get("HOME", "/app/python/source_code"))
-
-    if project_name:
-        # Claude Code hashes the absolute project path to locate the memory dir
-        project_path = str(home / "projects" / project_name)
-        path_hash = hashlib.md5(project_path.encode()).hexdigest()
-        mem_dir = home / ".claude" / "projects" / path_hash / "memory"
-    else:
-        mem_dir = home / ".claude" / "memory"
-
-    mem_dir.mkdir(parents=True, exist_ok=True)
-    return mem_dir
-
-
-def regenerate_memory_file(owner_email: str, project_name: str | None) -> Path | None:
-    """Write coda_memory.md to Claude Code's memory directory.
 
-    Returns the path written, or None if there were no memories to write.
-    """
-    from memory.store import load_memories
+def _claude_md_path() -> Path:
+    """Return the user-global CLAUDE.md path that Claude Code auto-loads."""
+    home = Path(os.environ.get("HOME", "/app/python/source_code"))
+    path = home / ".claude" / "CLAUDE.md"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
 
-    memories = load_memories(owner_email, project_name, limit=60)
-    if not memories:
-        return None
 
-    # Group by type, project-specific entries first within each type
+def _render_memory_section(memories: list[dict]) -> str:
+    """Render the memories as a CLAUDE.md fragment between markers."""
     by_type: dict[str, list[dict]] = {}
     for mem in memories:
         by_type.setdefault(mem["type"], []).append(mem)
 
     now = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
     lines: list[str] = [
+        _BEGIN_MARKER,
         "# CODA Memory",
         f"_Synced from Lakebase: {now}_",
         "",
         "These memories were extracted from past coding sessions and are stored in",
         "Lakebase for durability across app restarts and CODA instances.",
         "",
     ]
-
     for mem_type, heading in _TYPE_HEADINGS.items():
         items = by_type.get(mem_type, [])
         if not items:
             continue
         lines.append(heading)
         for item in items[:_CAP_PER_SECTION]:
-            project_tag = f" _(project: {item['project_name']})_" if item.get("project_name") else ""
+            project_tag = (
+                f" _(project: {item['project_name']})_"
+                if item.get("project_name")
+                else ""
+            )
             lines.append(f"- {item['content']}{project_tag}")
         lines.append("")
+    lines.append(_END_MARKER)
+    return "\n".join(lines)
+
+
+def _splice_section(existing: str, new_section: str) -> str:
+    """Replace any prior CODA-MEMORY section in `existing`, or append if absent."""
+    if _BEGIN_MARKER in existing and _END_MARKER in existing:
+        before, _, rest = existing.partition(_BEGIN_MARKER)
+        _, _, after = rest.partition(_END_MARKER)
+        return before.rstrip() + "\n\n" + new_section + after.lstrip("\n")
+    sep = "\n\n" if existing and not existing.endswith("\n") else "\n"
+    return existing + sep + new_section + "\n"
+
+
+def regenerate_memory_file(
+    owner_email: str,
+    project_name: str | None,
+    cwd: str | None = None,  # accepted for API compatibility; not used here
+) -> Path | None:
+    """Splice Lakebase-backed memories into `~/.claude/CLAUDE.md`.
+
+    Returns the CLAUDE.md path on success, or None if there were no memories.
+    """
+    from memory.store import load_memories
+
+    memories = load_memories(owner_email, project_name, limit=60)
+    if not memories:
+        return None
 
-    output_path = _memory_dir(project_name) / "coda_memory.md"
-    output_path.write_text("\n".join(lines), encoding="utf-8")
-    return output_path
+    new_section = _render_memory_section(memories)
+    path = _claude_md_path()
+    existing = path.read_text(encoding="utf-8") if path.exists() else ""
+    path.write_text(_splice_section(existing, new_section), encoding="utf-8")
+    return path

setup_memory.py

@@ -46,11 +46,15 @@
 except Exception as e:
     print(f"CODA memory: schema init warning: {e}")
 
+# Splice all of this user's Lakebase memories into ~/.claude/CLAUDE.md so
+# they're available the moment a Claude session starts (Claude Code auto-loads
+# that file). project_name=None means "all projects" — the user might `cd` to
+# any of them, and cross-project lessons should be visible everywhere.
 try:
     from memory.injector import regenerate_memory_file
     path = regenerate_memory_file(app_owner, None)
     if path:
-        print(f"CODA memory: memory file populated → {path}")
+        print(f"CODA memory: spliced into {path}")
     else:
         print("CODA memory: no memories yet (new instance)")
 except Exception as e: