agi-memory 0.7.0__tar.gz → 0.7.2__tar.gz

agi_memory-0.7.2/PKG-INFO

@@ -0,0 +1,110 @@
+Metadata-Version: 2.4
+Name: agi-memory
+Version: 0.7.2
+Summary: Turnkey zero-dependency four-pillar cognitive memory framework (Epistemic, Semantic, Episodic, Structural Code Graph) with MCP server for Claude Code, Cursor, Codex, OpenCode, Antigravity, and more
+Author: Krunal Bhalala
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/kdbhalala/agi-memory
+Project-URL: Repository, https://github.com/kdbhalala/agi-memory
+Project-URL: Issues, https://github.com/kdbhalala/agi-memory/issues
+Keywords: mcp,agi-memory,ai-memory,knowledge-graph,claude-code,cursor,codex,opencode,llm,sqlite
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# agi-memory
+
+[![CI](https://github.com/kdbhalala/agi-memory/actions/workflows/ci.yml/badge.svg)](https://github.com/kdbhalala/agi-memory/actions)
+[![PyPI](https://img.shields.io/pypi/v/agi-memory.svg)](https://pypi.org/project/agi-memory/)
+
+Coding assistants forget everything when a session ends. agi-memory is a small
+local memory they can all read and write, so you don't have to re-explain your
+project every time you open a new session or switch tools.
+
+## A basic example
+
+On Monday you tell Claude Code why webhook retries are capped, and it saves that:
+
+```
+memory_record(
+  title="Webhook retry limit",
+  text="Payment webhooks retry at most 5 times with exponential backoff. "
+       "Do not raise the limit: the provider bans endpoints that retry more.",
+  rationale="Stripe disables endpoints after repeated failed retries",
+)
+```
+
+On Thursday you're in Cursor, in a fresh session, and ask it to make webhooks
+more reliable. Before touching the code it checks memory:
+
+```
+$ agi-memory recall "webhook retries" --project shop
+#1 [shop] Webhook retry limit: Payment webhooks retry at most 5 times with
+exponential backoff. Do not raise the limit: the provider bans endpoints that
+retry more. | Why: Stripe disables endpoints after repeated failed retries
+```
+
+So it doesn't "fix" reliability by raising the retry count. That's the whole
+idea: decisions, bugs you already fixed, and what you tried last time stay
+available across sessions and across tools.
+
+## How it works
+
+- Memories are stored in SQLite on your machine, and also written to plain
+  append-only text files you can read, diff, and keep in git.
+- Each assistant talks to it through a local MCP server. It works in Claude
+  Code, Cursor, Windsurf, Codex, OpenCode, Antigravity, Aider, Goose, Cline,
+  Roo Code, Crush, Pi, and Hermes Agent.
+- Nothing leaves your machine unless you point the memory files at a git
+  remote to sync them between computers.
+- It's pure Python with no dependencies: no vector database, no model
+  download, no background service.
+
+Besides notes and decisions, it also keeps a short history of past sessions and
+an index of your code (functions and who calls them), so an assistant can ask
+"what calls this?" before changing it.
+
+## What it won't do
+
+Search is by keyword, not meaning. If you saved "authentication" and later ask
+about "login", it can miss. It helps to use the words you'd search for when
+saving something. The measured hit rates, including the misses, are in
+[Testing & Evals](docs/testing.md).
+
+## Install
+
+```bash
+pipx install agi-memory            # or: brew tap kdbhalala/agi-memory https://github.com/kdbhalala/agi-memory && brew install agi-memory
+agi-integrate install all          # connect every assistant it finds on your machine
+agi-integrate status               # see what got connected
+```
+
+Other install options, including a one-line script and running from source, are
+in [Installation](docs/installation.md).
+
+## Documentation
+
+| Guide | What's in it |
+|---|---|
+| [Installation](docs/installation.md) | Install options, upgrading, lifecycle hooks |
+| [CLI Usage](docs/cli.md) | Every `agi-memory` and `agi-integrate` command |
+| [Supported Assistants](docs/assistants.md) | Where each assistant's config lives, and the 16 MCP tools |
+| [How memory is organised](docs/pillars.md) | Notes, knowledge graph, session history, code index |
+| [Architecture](docs/architecture.md) | How the pieces fit together |
+| [Vault & Git Sync](docs/sync.md) | The memory files, syncing between machines, compaction |
+| [Python API](docs/python-api.md) | Using it directly from Python |
+| [Testing & Evals](docs/testing.md) | How it's tested, and where it falls short |
+| [Benchmarks](docs/benchmarks.md) | Speed and memory measurements |
+| [Integrations](INTEGRATIONS.md) | Manual setup snippets for each assistant |
+
+## License
+
+MIT

agi_memory-0.7.2/README.md

@@ -0,0 +1,88 @@
+# agi-memory
+
+[![CI](https://github.com/kdbhalala/agi-memory/actions/workflows/ci.yml/badge.svg)](https://github.com/kdbhalala/agi-memory/actions)
+[![PyPI](https://img.shields.io/pypi/v/agi-memory.svg)](https://pypi.org/project/agi-memory/)
+
+Coding assistants forget everything when a session ends. agi-memory is a small
+local memory they can all read and write, so you don't have to re-explain your
+project every time you open a new session or switch tools.
+
+## A basic example
+
+On Monday you tell Claude Code why webhook retries are capped, and it saves that:
+
+```
+memory_record(
+  title="Webhook retry limit",
+  text="Payment webhooks retry at most 5 times with exponential backoff. "
+       "Do not raise the limit: the provider bans endpoints that retry more.",
+  rationale="Stripe disables endpoints after repeated failed retries",
+)
+```
+
+On Thursday you're in Cursor, in a fresh session, and ask it to make webhooks
+more reliable. Before touching the code it checks memory:
+
+```
+$ agi-memory recall "webhook retries" --project shop
+#1 [shop] Webhook retry limit: Payment webhooks retry at most 5 times with
+exponential backoff. Do not raise the limit: the provider bans endpoints that
+retry more. | Why: Stripe disables endpoints after repeated failed retries
+```
+
+So it doesn't "fix" reliability by raising the retry count. That's the whole
+idea: decisions, bugs you already fixed, and what you tried last time stay
+available across sessions and across tools.
+
+## How it works
+
+- Memories are stored in SQLite on your machine, and also written to plain
+  append-only text files you can read, diff, and keep in git.
+- Each assistant talks to it through a local MCP server. It works in Claude
+  Code, Cursor, Windsurf, Codex, OpenCode, Antigravity, Aider, Goose, Cline,
+  Roo Code, Crush, Pi, and Hermes Agent.
+- Nothing leaves your machine unless you point the memory files at a git
+  remote to sync them between computers.
+- It's pure Python with no dependencies: no vector database, no model
+  download, no background service.
+
+Besides notes and decisions, it also keeps a short history of past sessions and
+an index of your code (functions and who calls them), so an assistant can ask
+"what calls this?" before changing it.
+
+## What it won't do
+
+Search is by keyword, not meaning. If you saved "authentication" and later ask
+about "login", it can miss. It helps to use the words you'd search for when
+saving something. The measured hit rates, including the misses, are in
+[Testing & Evals](docs/testing.md).
+
+## Install
+
+```bash
+pipx install agi-memory            # or: brew tap kdbhalala/agi-memory https://github.com/kdbhalala/agi-memory && brew install agi-memory
+agi-integrate install all          # connect every assistant it finds on your machine
+agi-integrate status               # see what got connected
+```
+
+Other install options, including a one-line script and running from source, are
+in [Installation](docs/installation.md).
+
+## Documentation
+
+| Guide | What's in it |
+|---|---|
+| [Installation](docs/installation.md) | Install options, upgrading, lifecycle hooks |
+| [CLI Usage](docs/cli.md) | Every `agi-memory` and `agi-integrate` command |
+| [Supported Assistants](docs/assistants.md) | Where each assistant's config lives, and the 16 MCP tools |
+| [How memory is organised](docs/pillars.md) | Notes, knowledge graph, session history, code index |
+| [Architecture](docs/architecture.md) | How the pieces fit together |
+| [Vault & Git Sync](docs/sync.md) | The memory files, syncing between machines, compaction |
+| [Python API](docs/python-api.md) | Using it directly from Python |
+| [Testing & Evals](docs/testing.md) | How it's tested, and where it falls short |
+| [Benchmarks](docs/benchmarks.md) | Speed and memory measurements |
+| [Integrations](INTEGRATIONS.md) | Manual setup snippets for each assistant |
+
+## License
+
+MIT

{agi_memory-0.7.0 → agi_memory-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agi-memory"
-version = "0.7.0"
+version = "0.7.2"
 description = "Turnkey zero-dependency four-pillar cognitive memory framework (Epistemic, Semantic, Episodic, Structural Code Graph) with MCP server for Claude Code, Cursor, Codex, OpenCode, Antigravity, and more"
 readme = "README.md"
 requires-python = ">=3.10"

{agi_memory-0.7.0 → agi_memory-0.7.2}/src/agi_memory/hooks.py

@@ -180,6 +180,76 @@ def hook_session_start(project: Optional[str] = None) -> None:
     print("\n".join(output))
 
 
+_PROMPT_RECALL_LIMIT = 3
+_HARNESS_TURN = re.compile(r"\s*<(task-notification|system-reminder|local-command|command-name|command-message)\b")
+# Conversational words that match thousands of memories and mean nothing here:
+# "can you explain how this works" pulled in two unrelated commits without this.
+_PROMPT_FILLER = frozenset(
+    "explain works work this that what make does help please want need like thing things "
+    "code file files just able could would should tell show look check about into with from "
+    "have your there here them they then than when".split())
+
+
+def prompt_recall(prompt: str, project: Optional[str] = None, db_path: Optional[Path] = None) -> str:
+    """Memories that match a user's prompt closely enough to show unasked.
+
+    Agents almost never call memory_recall themselves: 0 calls in the 146
+    Claude Code sessions that had the tool, which is deferred there and so
+    costs a lookup before it can even be called. Hook-capable assistants get
+    the matches pushed when the prompt arrives instead. The search ORs terms,
+    so on a large store nearly any prompt matches something; a hit is shown
+    only when it shares several of the prompt's words.
+    """
+    try:
+        from agi_memory.layers.session_layer import SessionLayer, STOPWORDS
+    except ImportError:
+        from layers.session_layer import SessionLayer, STOPWORDS
+    text = prompt or ""
+    # ponytail: 5-char prefixes stand in for stemming; FTS already stems the search itself.
+    terms = {t[:5] for t in re.findall(r"[a-z0-9]+", text.lower())
+             if len(t) > 3 and t not in STOPWORDS and t not in _PROMPT_FILLER}
+    # Harness-generated turns (a background task finishing, a local command's
+    # output) arrive through the same prompt event; matching them injected
+    # unrelated memories into a turn nobody typed.
+    if len(terms) < 2 or text.lstrip().startswith("/") or _HARNESS_TURN.match(text):
+        return ""
+    need = min(4, max(2, -(-len(terms) // 4)))
+    proj = project or detect_project()
+    try:
+        hits = SessionLayer(db_path=db_path, project=proj).search(text, limit=10)
+    except Exception:
+        return ""
+    shown: List[str] = []
+    for h in hits:
+        if h.text.startswith("[approximate") or "[SUPERSEDED" in h.text:
+            continue
+        if len(terms & {w[:5] for w in re.findall(r"[a-z0-9]+", h.text.lower())}) >= need:
+            shown.append(f"- {_clip(h.text, 300)}")
+        if len(shown) == _PROMPT_RECALL_LIMIT:
+            break
+    if not shown:
+        return ""
+    return "\n".join([
+        "<!-- AGENT_MEMORY_PROMPT_RECALL -->",
+        f"Memories from agent-memory ({proj}) that match this prompt. "
+        "Check them before acting; call memory_recall for more.",
+        *shown,
+    ])
+
+
+def hook_user_prompt_submit(project: Optional[str] = None) -> None:
+    """UserPromptSubmit: push memories matching the prompt into context."""
+    sys.path.insert(0, str(REPO_DIR))
+    raw = "" if sys.stdin.isatty() else sys.stdin.read()
+    try:
+        prompt = json.loads(raw).get("prompt") or ""
+    except (json.JSONDecodeError, AttributeError):
+        prompt = raw  # a harness that pipes the prompt text itself
+    out = prompt_recall(prompt, project)
+    if out:
+        print(out)
+
+
 def hook_pre_compact(project: Optional[str] = None) -> None:
     """PreCompact: Curate high-signal working memory into L2 knowledge graph before context loss."""
     proj = project or detect_project()
@@ -269,8 +339,6 @@ def hook_post_commit(project: Optional[str] = None) -> None:
             return
 
         text = f"Commit {cid}: {subject}"
-        if body:
-            text += f"\n{body}"
 
         category = "decision"
         if re.search(r"\b(fix|bug|resolve|patch)\b", subject, re.I):
@@ -290,7 +358,10 @@ def hook_post_commit(project: Optional[str] = None) -> None:
             from layers.code_layer import CodeLayer
 
         l1 = SessionLayer(project=proj)
-        l1.record(text=text, title=f"Git commit: {subject[:50]}", project=proj, category=category)
+        # The commit body is where a change's reason is written, so it is the
+        # rationale rather than more text.
+        l1.record(text=text, title=f"Git commit: {subject[:50]}", project=proj, category=category,
+                  rationale=body or None)
 
         # Record into episodic history
         try:
@@ -320,6 +391,9 @@ def hook_post_commit(project: Optional[str] = None) -> None:
                     f_path = Path(df.strip())
                     if f_path.is_file():
                         cl.index_file(f_path, project=proj)
+                    else:
+                        # Deleted or moved away: keep its symbols out of results.
+                        cl.remove_file(f_path.as_posix(), project=proj)
         except Exception:
             pass
 
@@ -387,6 +461,7 @@ def install_claude_hooks(scope: str = "user", py_path: str = None) -> Tuple[bool
     cmd_start = f'"{py}" "{hooks_py}" session-start'
     cmd_compact = f'"{py}" "{hooks_py}" pre-compact'
     cmd_end = f'"{py}" "{hooks_py}" session-end'
+    cmd_prompt = f'"{py}" "{hooks_py}" user-prompt-submit'
 
     def _is_memory_hook(entry: Dict[str, Any]) -> bool:
         return any(
@@ -398,7 +473,7 @@ def install_claude_hooks(scope: str = "user", py_path: str = None) -> Tuple[bool
         )
 
     # Purge any previous or stale memory hooks to eliminate duplicates or broken paths
-    for ev in ("SessionStart", "PreCompact", "SessionEnd"):
+    for ev in ("SessionStart", "PreCompact", "SessionEnd", "UserPromptSubmit"):
         if ev in hooks:
             hooks[ev] = [e for e in hooks[ev] if not _is_memory_hook(e)]
 
@@ -419,6 +494,7 @@ def install_claude_hooks(scope: str = "user", py_path: str = None) -> Tuple[bool
     _ensure_hook("SessionStart", cmd_start, matcher="startup|resume|clear|compact")
     _ensure_hook("PreCompact", cmd_compact)
     _ensure_hook("SessionEnd", cmd_end)
+    _ensure_hook("UserPromptSubmit", cmd_prompt)
 
     # Sanitize and ensure Claude Code permission format (mcp__<server>__*)
     perms = data.get("permissions", {})
@@ -530,9 +606,11 @@ OPENCODE_PLUGIN_TEMPLATE = """\
 // Zero npm dependencies: shells out to the stdlib-only hooks CLI.
 //
 // Mapping:
-//   session-start -> experimental.chat.system.transform (once per session)
-//   pre-compact   -> experimental.session.compacting (output.context)
-//   session-end   -> event session.idle (fire-and-forget; sync is idempotent)
+//   session-start      -> experimental.chat.system.transform (once per session)
+//   user-prompt-submit -> chat.message reads the typed text; the matches are
+//                         pushed through system.transform for that turn
+//   pre-compact        -> experimental.session.compacting (output.context)
+//   session-end        -> event session.idle (fire-and-forget; sync is idempotent)
 //
 // Known gaps: --continue/--resume fires no bus event, so a resumed session
 // keeps whatever context it already has. session.idle fires per turn; the
@@ -541,24 +619,43 @@ export const AgentMemoryPlugin = async ({ $ }) => {
   const PY = "@@PY@@";
   const HOOKS_PY = "@@HOOKS_PY@@";
   const seen = new Set();
+  const recalled = new Map();
 
-  const run = async (verb) => {
+  const run = async (verb, stdin) => {
     try {
-      return (await $`${PY} ${HOOKS_PY} ${verb}`.text()).trim();
+      const cmd = stdin === undefined
+        ? $`${PY} ${HOOKS_PY} ${verb}`
+        : $`${PY} ${HOOKS_PY} ${verb} < ${new Response(stdin)}`;
+      return (await cmd.text()).trim();
     } catch {
       return "";
     }
   };
 
   return {
+    // Read-only here: the parts are persisted after this hook, so the matches
+    // travel through the system prompt instead of as synthetic message parts.
+    "chat.message": async (input, output) => {
+      const id = (input && input.sessionID) || "default";
+      const text = ((output && output.parts) || [])
+        .filter((p) => p && p.type === "text" && !p.synthetic)
+        .map((p) => p.text)
+        .join("\\n");
+      const ctx = text ? await run("user-prompt-submit", JSON.stringify({ prompt: text })) : "";
+      if (ctx) recalled.set(id, ctx);
+      else recalled.delete(id);
+    },
     // Mutate output.system IN PLACE (push/splice); reassigning the array is
     // a silent no-op on the OpenCode side.
     "experimental.chat.system.transform": async (input, output) => {
       const id = (input && input.sessionID) || "default";
-      if (seen.has(id)) return;
-      seen.add(id);
-      const ctx = await run("session-start");
-      if (ctx) output.system.push(ctx);
+      if (!seen.has(id)) {
+        seen.add(id);
+        const ctx = await run("session-start");
+        if (ctx) output.system.push(ctx);
+      }
+      const recall = recalled.get(id);
+      if (recall) output.system.push(recall);
     },
     "experimental.session.compacting": async (input, output) => {
       const msg = await run("pre-compact");
@@ -721,6 +818,9 @@ def main() -> None:
     p_start = subparsers.add_parser("session-start", help="Inject active context and precedents")
     p_start.add_argument("--project", "-p", help="Project name override")
 
+    p_prompt = subparsers.add_parser("user-prompt-submit", help="Inject memories matching the prompt (JSON or text on stdin)")
+    p_prompt.add_argument("--project", "-p", help="Project name override")
+
     p_compact = subparsers.add_parser("pre-compact", help="Promote high-signal L1 memories before compaction")
     p_compact.add_argument("--project", "-p", help="Project name override")
 
@@ -746,6 +846,8 @@ def main() -> None:
 
     if args.action == "session-start":
         hook_session_start(getattr(args, "project", None))
+    elif args.action == "user-prompt-submit":
+        hook_user_prompt_submit(getattr(args, "project", None))
     elif args.action == "pre-compact":
         hook_pre_compact(getattr(args, "project", None))
     elif args.action == "session-end":

{agi_memory-0.7.0 → agi_memory-0.7.2}/src/agi_memory/layers/code_layer.py

@@ -655,6 +655,9 @@ def _dedupe_paths(rows: list) -> list:
     return out
 
 
+_STALE_NOTE = " [STALE: file no longer exists, re-run code_index]"
+
+
 class CodeLayer(MemoryLayer):
     """Native SQLite Structural Code Graph layer."""
     name = "code"
@@ -696,6 +699,10 @@ class CodeLayer(MemoryLayer):
                 UNIQUE(project, file_path)
             )
         """)
+        # Where each file was indexed from. Paths are stored relative to that
+        # directory, so without it a result cannot be checked against the disk.
+        if "root_dir" not in {r[1] for r in cur.execute("PRAGMA table_info(code_files)")}:
+            cur.execute("ALTER TABLE code_files ADD COLUMN root_dir TEXT")
 
         cur.execute("""
             CREATE TABLE IF NOT EXISTS code_symbols (
@@ -826,9 +833,9 @@ class CodeLayer(MemoryLayer):
             cur.execute("DELETE FROM code_files WHERE id = ?", (f_row[0],))
 
         cur.execute("""
-            INSERT INTO code_files (project, file_path, language, content_hash, symbol_count, lines_of_code)
-            VALUES (?, ?, ?, ?, ?, ?)
-        """, (proj, rel_path, lang, chash, len(symbols), loc))
+            INSERT INTO code_files (project, file_path, language, content_hash, symbol_count, lines_of_code, root_dir)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+        """, (proj, rel_path, lang, chash, len(symbols), loc, str(root.resolve())))
         file_id = cur.lastrowid
 
         for sym in symbols:
@@ -909,6 +916,51 @@ class CodeLayer(MemoryLayer):
             "elapsed_ms": round(elapsed_ms, 2)
         }
 
+    def remove_file(self, rel_path: str, project: Optional[str] = None) -> None:
+        """Drop a file's symbols and edges, e.g. after a commit deleted it."""
+        proj = project or self.project or "global"
+        con = self._get_con(mode="rw")
+        try:
+            for table in ("code_symbols", "code_edges", "code_files"):
+                con.execute(f"DELETE FROM {table} WHERE project = ? AND file_path = ?", (proj, rel_path))
+            con.commit()
+        finally:
+            con.close()
+
+    def missing_paths(self, paths, project: Optional[str] = None) -> Set[str]:
+        """Indexed paths whose file no longer exists where it was indexed from.
+
+        Checked at query time: an agent acting on a dead path is worse off than
+        one told the index is out of date. Files indexed before root_dir was
+        recorded cannot be checked, so they are never reported.
+        """
+        wanted = {p for p in paths if p}
+        if not wanted:
+            return set()
+        proj = project or self.project
+        sql = "SELECT file_path, root_dir FROM code_files WHERE root_dir IS NOT NULL"
+        args: list = []
+        if proj:
+            sql += " AND project = ?"
+            args.append(proj)
+        con = self._get_con(mode="ro")
+        try:
+            rows = con.execute(sql, args).fetchall()
+        finally:
+            con.close()
+        checked, present = set(), set()
+        for fp, root in rows:
+            if fp in wanted:
+                checked.add(fp)
+                if (Path(root) / fp).exists():
+                    present.add(fp)
+        return checked - present
+
+    def mark_stale(self, rows: List[Dict[str, Any]], project: Optional[str] = None) -> List[Dict[str, Any]]:
+        """Copy result rows with `stale` set where the file is gone."""
+        gone = self.missing_paths({r.get("file_path") for r in rows}, project)
+        return [{**r, "stale": r.get("file_path") in gone} for r in rows]
+
     def search_symbols(self, query: str, project: Optional[str] = None, limit: int = 10) -> List[Dict[str, Any]]:
         """Microsecond symbol search via SQLite FTS5 with fallback to prefix match."""
         proj = project or self.project
@@ -1248,12 +1300,14 @@ class CodeLayer(MemoryLayer):
 
     def search(self, query: str, limit: int = 5) -> List[Hit]:
         """Search code symbols and return as standard MemoryLayer Hits."""
-        syms = self.search_symbols(query, limit=limit)
+        syms = self.mark_stale(self.search_symbols(query, limit=limit))
         hits = []
         for s in syms:
             txt = f"{s['kind'].upper()} {s['qualified_name']} ({s['file_path']}:{s['start_line']}-{s['end_line']})"
             if s.get("signature"):
                 txt += f" :: {s['signature']}"
+            if s["stale"]:
+                txt += _STALE_NOTE
             hits.append(Hit(text=txt, source=self.name, ref=s["file_path"], score=1.0))
         return hits
 
@@ -1269,7 +1323,7 @@ class CodeLayer(MemoryLayer):
 
         lines = []
         for fp, sym_list in by_file.items():
-            lines.append(f"### `{fp}` ({len(sym_list)} symbols)")
+            lines.append(f"### `{fp}` ({len(sym_list)} symbols)" + (_STALE_NOTE if sym_list[0].get("stale") else ""))
             for s in sym_list:
                 prefix = "  - " if s.get("parent_symbol") else "- "
                 sig = f"`{s['signature']}`" if s.get("signature") else f"`{s['qualified_name']}`"
@@ -1307,7 +1361,8 @@ class CodeLayer(MemoryLayer):
         lines = [f"### Callers & Inbound References for `{symbol}` ({len(callers)} found"
                  + (f", showing first {limit} by depth)" if len(callers) > limit else ")")]
         for c in callers[:limit]:
-            lines.append(f"- **{c['caller']}** [{c['relation']}] (L{c['line_number']} in `{c['file_path']}`) [depth {c['depth']}]")
+            lines.append(f"- **{c['caller']}** [{c['relation']}] (L{c['line_number']} in `{c['file_path']}`) [depth {c['depth']}]"
+                         + (_STALE_NOTE if c.get("stale") else ""))
             lines.append(f"  *Chain*: {c['call_chain']}")
         lines += CodeLayer._render_tail(callers, limit, "callers")
         return "\n".join(lines)
@@ -1322,7 +1377,8 @@ class CodeLayer(MemoryLayer):
         lines = [f"### Outbound Dependencies & Calls for `{symbol}` ({len(deps)} found"
                  + (f", showing first {limit} by depth)" if len(deps) > limit else ")")]
         for d in deps[:limit]:
-            lines.append(f"- **{d['target']}** [{d['relation']}] (L{d['line_number']} in `{d['file_path']}`) [depth {d['depth']}]")
+            lines.append(f"- **{d['target']}** [{d['relation']}] (L{d['line_number']} in `{d['file_path']}`) [depth {d['depth']}]"
+                         + (_STALE_NOTE if d.get("stale") else ""))
             lines.append(f"  *Chain*: {d['dependency_chain']}")
         lines += CodeLayer._render_tail(deps, limit, "dependencies")
         return "\n".join(lines)
@@ -1338,6 +1394,8 @@ class CodeLayer(MemoryLayer):
         ]
         if impact.get("impacted_files"):
             lines.append(f"- **Files Affected**: {', '.join(impact['impacted_files'][:10])}")
+        if impact.get("stale_files"):
+            lines.append(f"- **Stale (file no longer exists, re-run code_index)**: {', '.join(impact['stale_files'][:10])}")
         if impact.get("impacted_symbols"):
             lines.append(f"- **Symbols Affected**: {', '.join(impact['impacted_symbols'][:15])}")
         if impact.get("dependency_chains"):

{agi_memory-0.7.0 → agi_memory-0.7.2}/src/agi_memory/layers/session_layer.py

@@ -17,11 +17,14 @@ from .base import Hit, MemoryLayer, open_db
 
 try:
     from agi_memory.config import DEFAULT_DB, get_default_db
+    from agi_memory.redact import redact
 except ImportError:
     try:
         from ..config import DEFAULT_DB, get_default_db
+        from ..redact import redact
     except (ImportError, ValueError):
         from config import DEFAULT_DB, get_default_db
+        from redact import redact
 
 DB = get_default_db()
 
@@ -553,6 +556,8 @@ class SessionLayer(MemoryLayer):
                category: str = "decision", supersedes: str | None = None,
                rationale: str | None = None, origin: str | None = None) -> dict:
         """Record an observation/decision into L1 memory via direct SQLite FTS5 insertion."""
+        # Before anything is hashed, inserted or mirrored to the vault's git remote.
+        text, title, rationale = redact(text), redact(title), redact(rationale)
         proj = project or self.project or "global"
         tit = title or (text[:60].strip() + ("..." if len(text) > 60 else ""))
         cat = (category or "decision").strip().lower()