nexusmem 0.10.4 → 0.11.0

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { Command, Option } from "commander";
-import pc22 from "picocolors";
+import pc24 from "picocolors";
 
 // src/config/workspace.ts
 import { existsSync } from "fs";
@@ -10,6 +10,17 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { z } from "zod";
 
+// src/core/text.ts
+function truncate(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max - 1).trimEnd()}\u2026`;
+}
+function stripBom(text) {
+  return text.charCodeAt(0) === 65279 ? text.slice(1) : text;
+}
+function approxTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+
 // src/slm/provider.ts
 var DEFAULT_BASE_URL = "http://127.0.0.1:11434";
 var DEFAULT_SLM_MODEL = "qwen2.5:3b";
@@ -92,6 +103,17 @@ var ConfigSchema = z.object({
       /** Lines kept from scrape-based (no-hook) history files each sync. */
       tailLines: z.number().int().positive().default(300)
     }).default({ enabled: true, tailLines: 300 }),
+    /**
+     * Commands a coding agent ran and files it edited, captured by the
+     * agent hook (`nexusmem agent install`).
+     *
+     * On by default, like git/shell, because it reads only what NexusMem's
+     * own hook wrote: with no hook installed there is nothing to read.
+     * Installing that hook is the deliberate step.
+     */
+    agent: z.object({
+      enabled: z.boolean().default(true)
+    }).default({ enabled: true }),
     /**
      * Opt-in, unlike git/shell: conversation transcripts are the source
      * most likely to contain something sensitive (a pasted credential,
@@ -178,6 +200,7 @@ var ConfigSchema = z.object({
   }).default({
     git: { enabled: true, since: null, includeMerges: true },
     shell: { enabled: true, tailLines: 300 },
+    agent: { enabled: true },
     conversation: { enabled: false },
     session: {
       enabled: false,
@@ -227,7 +250,7 @@ async function readConfig(ws) {
   }
   let parsed;
   try {
-    parsed = JSON.parse(raw);
+    parsed = JSON.parse(stripBom(raw));
   } catch (err) {
     throw new ConfigError(`${ws.configPath} is not valid JSON: ${err.message}`);
   }
@@ -514,16 +537,27 @@ function resolveZshProfilePath() {
   return join3(homedir2(), ".zshrc");
 }
 
+// src/hooks/recorder-command.ts
+import { fileURLToPath as fileURLToPath2 } from "url";
+function defaultRecorderCommand() {
+  return { node: process.execPath, script: fileURLToPath2(new URL("../../dist/cli/recorder.js", import.meta.url)) };
+}
+function forPosixShell(path) {
+  return /^[A-Za-z]:\\/.test(path) ? path.replace(/\\/g, "/") : path;
+}
+
 // src/hooks/bash.ts
 var MARK_START = "# >>> nexusmem shell hook >>>";
 var MARK_END = "# <<< nexusmem shell hook <<<";
 function toBashLiteral(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function renderHookSnippet(logPath) {
+function renderHookSnippet(logPath, recorder = defaultRecorderCommand()) {
   return [
     MARK_START,
     `__nxm_log_path=${toBashLiteral(logPath)}`,
+    `__nxm_node=${toBashLiteral(forPosixShell(recorder.node))}`,
+    `__nxm_recorder=${toBashLiteral(forPosixShell(recorder.script))}`,
     '__nxm_cmd_start=""',
     '__nxm_last_cmd=""',
     '__nxm_debug_trap_owned=""',
@@ -534,6 +568,7 @@ function renderHookSnippet(logPath) {
     '  s=${s//\\"/\\\\\\"}',
     "  s=${s//$'\\n'/\\\\n}",
     "  s=${s//$'\\t'/\\\\t}",
+    "  s=${s//$'\\r'/\\\\r}",
     `  printf '%s' "$s"`,
     "}",
     "",
@@ -569,12 +604,12 @@ function renderHookSnippet(logPath) {
     "    __nxm_dur=$(( __nxm_ms - __nxm_cmd_start ))",
     "  fi",
     "",
-    "  local __nxm_dir",
-    '  __nxm_dir=$(dirname -- "$__nxm_log_path" 2>/dev/null)',
-    '  [ -d "$__nxm_dir" ] || mkdir -p "$__nxm_dir" 2>/dev/null',
-    `  printf '{"ts":"%s","cwd":"%s","exitCode":%s,"durationMs":%s,"command":"%s","shell":"bash-hook"}\\n' \\`,
+    "  local __nxm_event",
+    `  __nxm_event=$(printf '{"ts":"%s","cwd":"%s","exitCode":%s,"durationMs":%s,"command":"%s"}' \\`,
     '    "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" "$(__nxm_json_escape "$PWD")" "$__nxm_exit" "$__nxm_dur" \\',
-    '    "$(__nxm_json_escape "$__nxm_last_cmd")" >> "$__nxm_log_path" 2>/dev/null',
+    '    "$(__nxm_json_escape "$__nxm_last_cmd")")',
+    // Only the recorder's stdin (a pipe, never a file) sees the raw command; it hashes, redacts, then appends.
+    `  ( printf '%s' "$__nxm_event" | "$__nxm_node" "$__nxm_recorder" --log "$__nxm_log_path" --shell bash-hook >/dev/null 2>&1 & )`,
     "",
     '  __nxm_cmd_start=""',
     '  __nxm_last_cmd=""',
@@ -612,12 +647,12 @@ function stripHookSnippet(profileContent) {
   const afterBlock = profileContent.slice(endIdx + MARK_END.length).replace(/^\r?\n/, "");
   return profileContent.slice(0, startIdx) + afterBlock;
 }
-function upsertHookSnippet(profileContent, logPath) {
+function upsertHookSnippet(profileContent, logPath, recorder) {
   const stripped = stripHookSnippet(profileContent).replace(/\s+$/, "");
   const prefix = stripped.length > 0 ? `${stripped}
 
 ` : "";
-  return `${prefix}${renderHookSnippet(logPath)}`;
+  return `${prefix}${renderHookSnippet(logPath, recorder)}`;
 }
 
 // src/hooks/powershell.ts
@@ -626,12 +661,14 @@ var MARK_END2 = "# <<< nexusmem shell hook <<<";
 function toPowerShellLiteral(s) {
   return `'${s.replace(/'/g, "''")}'`;
 }
-function renderHookSnippet2(logPath) {
+function renderHookSnippet2(logPath, recorder = defaultRecorderCommand()) {
   return [
     MARK_START2,
     "if (Test-Path Function:\\prompt) { $function:__ssd_original_prompt = $function:prompt }",
     "$global:__ssd_last_history_id = -1",
     `$global:__ssd_log_path = ${toPowerShellLiteral(logPath)}`,
+    `$global:__ssd_node = ${toPowerShellLiteral(recorder.node)}`,
+    `$global:__ssd_recorder = ${toPowerShellLiteral(recorder.script)}`,
     "function global:prompt {",
     // Must be first: Get-History (or anything else) below would overwrite $?.
     "  $__ssd_ok = $?",
@@ -648,9 +685,19 @@ function renderHookSnippet2(logPath) {
     "        durationMs = [int](($__ssd_h.EndExecutionTime - $__ssd_h.StartExecutionTime).TotalMilliseconds)",
     "        command = $__ssd_h.CommandLine",
     "      }",
-    "      $__ssd_dir = Split-Path -Parent $global:__ssd_log_path",
-    "      if (-not (Test-Path $__ssd_dir)) { New-Item -ItemType Directory -Force -Path $__ssd_dir | Out-Null }",
-    "      Add-Content -LiteralPath $global:__ssd_log_path -Value ($__ssd_entry | ConvertTo-Json -Compress) -Encoding utf8",
+    // The raw command only ever reaches the recorder's stdin (a pipe, never a file); it hashes and redacts before writing.
+    "      $__ssd_psi = New-Object System.Diagnostics.ProcessStartInfo",
+    "      $__ssd_psi.FileName = $global:__ssd_node",
+    `      $__ssd_psi.Arguments = '"{0}" --log "{1}" --shell pwsh-hook' -f $global:__ssd_recorder, $global:__ssd_log_path`,
+    "      $__ssd_psi.UseShellExecute = $false",
+    "      $__ssd_psi.CreateNoWindow = $true",
+    "      $__ssd_psi.RedirectStandardInput = $true",
+    "      $__ssd_p = [System.Diagnostics.Process]::Start($__ssd_psi)",
+    // Bytes, not StandardInput.Write: Windows PowerShell would encode text in the console code page.
+    "      $__ssd_bytes = [System.Text.Encoding]::UTF8.GetBytes(($__ssd_entry | ConvertTo-Json -Compress))",
+    "      $__ssd_p.StandardInput.BaseStream.Write($__ssd_bytes, 0, $__ssd_bytes.Length)",
+    "      $__ssd_p.StandardInput.Close()",
+    "      $__ssd_p.Dispose()",
     "    } catch {}",
     "  }",
     "  if (Test-Path Function:\\__ssd_original_prompt) { & $function:__ssd_original_prompt }",
@@ -670,12 +717,12 @@ function stripHookSnippet2(profileContent) {
   const afterBlock = profileContent.slice(endIdx + MARK_END2.length).replace(/^\r?\n/, "");
   return profileContent.slice(0, startIdx) + afterBlock;
 }
-function upsertHookSnippet2(profileContent, logPath) {
+function upsertHookSnippet2(profileContent, logPath, recorder) {
   const stripped = stripHookSnippet2(profileContent).replace(/\s+$/, "");
   const prefix = stripped.length > 0 ? `${stripped}
 
 ` : "";
-  return `${prefix}${renderHookSnippet2(logPath)}`;
+  return `${prefix}${renderHookSnippet2(logPath, recorder)}`;
 }
 
 // src/hooks/zsh.ts
@@ -684,10 +731,12 @@ var MARK_END3 = "# <<< nexusmem shell hook <<<";
 function toZshLiteral(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function renderHookSnippet3(logPath) {
+function renderHookSnippet3(logPath, recorder = defaultRecorderCommand()) {
   return [
     MARK_START3,
     `__nxm_log_path=${toZshLiteral(logPath)}`,
+    `__nxm_node=${toZshLiteral(forPosixShell(recorder.node))}`,
+    `__nxm_recorder=${toZshLiteral(forPosixShell(recorder.script))}`,
     '__nxm_cmd_start=""',
     '__nxm_last_cmd=""',
     "zmodload zsh/datetime 2>/dev/null",
@@ -698,6 +747,7 @@ function renderHookSnippet3(logPath) {
     '  s=${s//\\"/\\\\\\"}',
     "  s=${s//$'\\n'/\\\\n}",
     "  s=${s//$'\\t'/\\\\t}",
+    "  s=${s//$'\\r'/\\\\r}",
     `  printf '%s' "$s"`,
     "}",
     "",
@@ -726,12 +776,12 @@ function renderHookSnippet3(logPath) {
     "    __nxm_dur=$(( __nxm_now - __nxm_cmd_start ))",
     "  fi",
     "",
-    "  local __nxm_dir",
-    '  __nxm_dir=$(dirname -- "$__nxm_log_path" 2>/dev/null)',
-    '  [ -d "$__nxm_dir" ] || mkdir -p "$__nxm_dir" 2>/dev/null',
-    `  printf '{"ts":"%s","cwd":"%s","exitCode":%s,"durationMs":%s,"command":"%s","shell":"zsh-hook"}\\n' \\`,
+    "  local __nxm_event",
+    `  __nxm_event=$(printf '{"ts":"%s","cwd":"%s","exitCode":%s,"durationMs":%s,"command":"%s"}' \\`,
     '    "$(date -u +%Y-%m-%dT%H:%M:%S.000Z)" "$(__nxm_json_escape "$PWD")" "$__nxm_exit" "$__nxm_dur" \\',
-    '    "$(__nxm_json_escape "$__nxm_last_cmd")" >> "$__nxm_log_path" 2>/dev/null',
+    '    "$(__nxm_json_escape "$__nxm_last_cmd")")',
+    // Only the recorder's stdin (a pipe, never a file) sees the raw command; it hashes, redacts, then appends.
+    `  ( printf '%s' "$__nxm_event" | "$__nxm_node" "$__nxm_recorder" --log "$__nxm_log_path" --shell zsh-hook >/dev/null 2>&1 & )`,
     "",
     '  __nxm_cmd_start=""',
     '  __nxm_last_cmd=""',
@@ -755,29 +805,32 @@ function stripHookSnippet3(profileContent) {
   const afterBlock = profileContent.slice(endIdx + MARK_END3.length).replace(/^\r?\n/, "");
   return profileContent.slice(0, startIdx) + afterBlock;
 }
-function upsertHookSnippet3(profileContent, logPath) {
+function upsertHookSnippet3(profileContent, logPath, recorder) {
   const stripped = stripHookSnippet3(profileContent).replace(/\s+$/, "");
   const prefix = stripped.length > 0 ? `${stripped}
 
 ` : "";
-  return `${prefix}${renderHookSnippet3(logPath)}`;
+  return `${prefix}${renderHookSnippet3(logPath, recorder)}`;
 }
 
 // src/hooks/install.ts
 var SHELL_MODULES = {
   pwsh: {
+    renderHookSnippet: (logPath) => renderHookSnippet2(logPath),
     isHookInstalled: isHookInstalled2,
     stripHookSnippet: stripHookSnippet2,
     upsertHookSnippet: upsertHookSnippet2,
     resolveProfilePath: async (override) => override ?? await resolvePowerShellProfilePath()
   },
   bash: {
+    renderHookSnippet: (logPath) => renderHookSnippet(logPath),
     isHookInstalled,
     stripHookSnippet,
     upsertHookSnippet,
     resolveProfilePath: async (override) => override ?? resolveBashProfilePath()
   },
   zsh: {
+    renderHookSnippet: (logPath) => renderHookSnippet3(logPath),
     isHookInstalled: isHookInstalled3,
     stripHookSnippet: stripHookSnippet3,
     upsertHookSnippet: upsertHookSnippet3,
@@ -830,8 +883,14 @@ async function removeHook(target) {
 }
 async function hookStatus(target) {
   const mod = SHELL_MODULES[target.shell];
-  const current = await readProfile(target.profilePath);
-  return { installed: mod.isHookInstalled(current) };
+  const current = (await readProfile(target.profilePath)).replace(/\r\n/g, "\n");
+  const installed = mod.isHookInstalled(current);
+  const expected = mod.renderHookSnippet(target.logPath).trimEnd();
+  const endMarker = expected.slice(expected.lastIndexOf("\n") + 1);
+  const start = current.indexOf(expected.slice(0, expected.indexOf("\n")));
+  const end = current.indexOf(endMarker, start);
+  const upToDate = installed && start !== -1 && end !== -1 && current.slice(start, end + endMarker.length) === expected;
+  return { installed, upToDate };
 }
 
 // src/hooks/install-git-precommit.ts
@@ -1904,8 +1963,8 @@ function replaceFileEdges(db, projectId, edges) {
 }
 function fileEdgeStats(db, projectId) {
   const edges = db.prepare("SELECT COUNT(*) AS c FROM file_edges WHERE project_id = ?").get(projectId).c;
-  const files = db.prepare("SELECT COUNT(DISTINCT from_path) AS c FROM file_edges WHERE project_id = ?").get(projectId).c;
-  return { edges, files };
+  const files2 = db.prepare("SELECT COUNT(DISTINCT from_path) AS c FROM file_edges WHERE project_id = ?").get(projectId).c;
+  return { edges, files: files2 };
 }
 
 // src/store/embeddings.ts
@@ -1990,7 +2049,7 @@ function search(db, projectId, query, limit = 20, opts = {}) {
 function stats(db, projectId) {
   const kinds = db.prepare("SELECT kind, COUNT(*) AS n FROM nodes WHERE project_id = ? GROUP BY kind").all(projectId);
   const range = db.prepare("SELECT MIN(ts) AS oldest, MAX(ts) AS newest FROM nodes WHERE project_id = ?").get(projectId);
-  const files = db.prepare(
+  const files2 = db.prepare(
     `SELECT COUNT(DISTINCT f.path) AS n
        FROM node_files f JOIN nodes n ON n.id = f.node_id
        WHERE n.project_id = ?`
@@ -2000,7 +2059,7 @@ function stats(db, projectId) {
     byKind: Object.fromEntries(kinds.map((k) => [k.kind, k.n])),
     oldest: range.oldest,
     newest: range.newest,
-    distinctFiles: files.n
+    distinctFiles: files2.n
   };
 }
 
@@ -2095,7 +2154,6 @@ var MemoryStore = class _MemoryStore {
   listOtherProjectIds(currentProjectId) {
     return listOtherProjectIds(this.db, currentProjectId);
   }
-  /** Total nodes held under the given project identities. */
   countProjectNodes(projectIds) {
     return countProjectNodes(this.db, projectIds);
   }
@@ -2142,12 +2200,7 @@ var MemoryStore = class _MemoryStore {
    * Hydrate full content for a set of node ids, e.g. to pack a linked
    * resolution alongside the failure node that points at it. Order is not
    * guaranteed to match `ids`; ids with no matching row are silently omitted
-   * rather than erroring. `node_links` has `ON DELETE CASCADE` on both
-   * columns, so an individual node delete (e.g. `reconcile.ts` migrating a
-   * node to a freshly-computed id) removes any link pointing at the old id
-   * along with it -- correct as a safety default, though note that reconcile
-   * does not currently re-create the link under the migrated node's new id;
-   * that gap is not addressed here.
+   * rather than erroring.
    */
   getNodesByIds(ids) {
     return getNodesByIds(this.db, ids);
@@ -2626,7 +2679,7 @@ async function runHookStatus(opts) {
       `${pc3.dim("shell  ")} ${target.shell}`,
       `${pc3.dim("profile")} ${target.profilePath}`,
       `${pc3.dim("log    ")} ${target.logPath}`,
-      `${pc3.dim("status ")} ${result.installed ? pc3.green("installed") : pc3.yellow("not installed")}`,
+      `${pc3.dim("status ")} ${!result.installed ? pc3.yellow("not installed") : result.upToDate ? pc3.green("installed") : pc3.yellow("installed, OUTDATED -- run `nexusmem hook install` again (hooks before 0.10.5 write commands to disk unredacted)")}`,
       ""
     ].join("\n")
   );
@@ -2869,14 +2922,6 @@ import { z as z4 } from "zod";
 // src/mcp/tools.ts
 import { basename as basename3 } from "path";
 
-// src/core/text.ts
-function truncate(s, max) {
-  return s.length <= max ? s : `${s.slice(0, max - 1).trimEnd()}\u2026`;
-}
-function approxTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-
 // src/retrieval/pack.ts
 var DEFAULT_SUMMARY_CHARS = 320;
 var NODE_OVERHEAD_TOKENS = 8;
@@ -3061,11 +3106,167 @@ function renderContextBlock(query, result) {
   return lines.join("\n");
 }
 
+// src/conversation/redact.ts
+var REDACTION_MARK = "[redacted]";
+var MARK = REDACTION_MARK;
+var NOT_MARK = String.raw`(?!\[redacted\])`;
+var keepPrefix = (groups) => `${groups[0]}${MARK}`;
+var SECRET_KEYWORD = String.raw`(?:(?:pass(?:word|wd|phrase)|secret|credential|api[_-]?key|(?:access|private|secret|client|signing|encryption|master)[_-]?key)s?|token)`;
+var SECRET_KEY = String.raw`(?:[A-Za-z0-9_.-]{0,100}?${SECRET_KEYWORD}|(?:-{1,2}|(?:[A-Za-z0-9]{1,40}[_.-]){1,8})pass)(?:[_.-][A-Za-z0-9]{1,40}){0,8}`;
+var TYPE_WORD = String.raw`(?:string|number|boolean|bool|int|str|null|undefined|none|nil|true|false|any|unknown|object)(?=[\s;,)|\]}>]|$)`;
+var SECRET_VALUE = String.raw`(?:"(?:\\.|[^"\\\r\n]){1,500}"|'(?:\\.|[^'\\\r\n]){1,500}'|\x60(?:\\.|[^\x60\\\r\n]){1,500}\x60|"(?!")[^\r\n]+|'(?!')[^\r\n]+|\x60(?!\x60)[^\r\n]+|[^\s'"\x60]+)`;
+var SAME_COMMAND = String.raw`[^\n|;&]{0,500}?`;
+var NOT_FLAG_OR_REDIRECT = String.raw`(?![-<>|&;])`;
+var AUTH_SCHEME = String.raw`(?:bearer|basic|token|digest|negotiate|ntlm)`;
+var CURL_USER = String.raw`\bcurl(?=[ \t])${SAME_COMMAND}[ \t](?:-u|--user)(?:[ \t]+|=)?`;
+var RULES = [
+  {
+    name: "private-key-block",
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    highConfidence: true
+  },
+  { name: "aws-access-key", pattern: /\bAKIA[0-9A-Z]{16}\b/g, highConfidence: true },
+  { name: "github-token", pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g, highConfidence: true },
+  { name: "slack-token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, highConfidence: true },
+  {
+    name: "jwt",
+    pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
+    highConfidence: true
+  },
+  // scheme://user:password@host -- the password may itself contain `@`, so the host starts after the last one.
+  {
+    name: "uri-credentials",
+    pattern: new RegExp(
+      String.raw`(\b[a-z][a-z0-9+.-]{1,30}://[^\s/?#'"@:]*:)${NOT_MARK}[^\s/?#'"]+(?=@[^\s/?#'"@]*(?:[/?#\s'"]|$))`,
+      "gi"
+    ),
+    highConfidence: true,
+    render: keepPrefix
+  },
+  // An option whose name ends in `bearer` (`--oauth2-bearer x`) always takes a credential, whatever
+  // the token looks like. The prose-shaped rule below cannot cover it: it needs a digit, so an
+  // all-alphabetic token would survive.
+  {
+    name: "bearer-option-arg",
+    pattern: new RegExp(
+      String.raw`(?<=^|[\s'"(])(-{1,2}[A-Za-z0-9_.-]{0,40}bearer[ \t]+)${NOT_FLAG_OR_REDIRECT}${NOT_MARK}${SECRET_VALUE}`,
+      "gi"
+    ),
+    highConfidence: true,
+    render: keepPrefix
+  },
+  // A bearer token outside a header (`Bearer x`); it must contain a digit so "bearer authentication" is left alone.
+  {
+    name: "bearer-token",
+    pattern: new RegExp(String.raw`(\bbearer[ \t]+)${NOT_MARK}(?=[A-Za-z0-9._~+/-]*\d)[A-Za-z0-9._~+/-]{16,}=*`, "gi"),
+    highConfidence: true,
+    render: keepPrefix
+  },
+  // Tool-anchored password arguments: `-p` means port or parents almost everywhere else. Case-sensitive (`-P` is mysql's port).
+  // mysql takes only the compact `-psecret` form; `-p secret` means "prompt, then use database secret".
+  {
+    name: "mysql-password-arg",
+    pattern: new RegExp(
+      String.raw`(\b(?:mysql|mysqldump|mysqladmin|mysqlimport|mysqlsh|mariadb|mariadb-dump)(?=[ \t])${SAME_COMMAND}[ \t]-p)${NOT_MARK}(?=\S)${SECRET_VALUE}`,
+      "g"
+    ),
+    highConfidence: true,
+    render: keepPrefix
+  },
+  // Only sshpass's own options may precede -p, so a wrapped `ssh -p 22` is never read as the password.
+  {
+    name: "sshpass-password-arg",
+    pattern: new RegExp(String.raw`(\bsshpass(?:[ \t]+-[^p\s]\S*)*[ \t]+-p[ \t]*)${NOT_MARK}(?=\S)${SECRET_VALUE}`, "g"),
+    highConfidence: true,
+    render: keepPrefix
+  },
+  {
+    name: "mongo-password-arg",
+    pattern: new RegExp(
+      String.raw`(\bmongo(?:sh|dump|restore|export|import|stat|top|files)?(?=[ \t])${SAME_COMMAND}[ \t]-p[ \t]+)${NOT_FLAG_OR_REDIRECT}${NOT_MARK}${SECRET_VALUE}`,
+      "g"
+    ),
+    highConfidence: true,
+    render: keepPrefix
+  },
+  {
+    name: "redis-cli-password-arg",
+    pattern: new RegExp(
+      String.raw`(\bredis-cli(?=[ \t])${SAME_COMMAND}[ \t]-a[ \t]+)${NOT_FLAG_OR_REDIRECT}${NOT_MARK}${SECRET_VALUE}`,
+      "g"
+    ),
+    highConfidence: true,
+    render: keepPrefix
+  },
+  // Quoted credentials get their own branches: `curl -u "user:pass word"` holds a space, which
+  // the unquoted branch would stop at, leaving the rest of the password in the text. Like
+  // SECRET_VALUE, they step over escaped characters so `"alice:pa\"ss"` is not cut at `\"`. Inside
+  // quotes the user name may hold a space too (`"alice smith:pw"`); only the quote ends it.
+  {
+    name: "curl-user-password",
+    pattern: new RegExp(
+      String.raw`(${CURL_USER}"(?:\\.|[^:"\\\r\n])*:)${NOT_MARK}(?:\\.|[^"\\\r\n])*|(${CURL_USER}'(?:\\.|[^:'\\\r\n])*:)${NOT_MARK}(?:\\.|[^'\\\r\n])*|(${CURL_USER}[^\s:'"]*:)${NOT_MARK}[^\s'"]+`,
+      "g"
+    ),
+    highConfidence: true,
+    render: (groups) => `${groups.find((g) => g.length > 0) ?? ""}${MARK}`
+  },
+  // Authorization: Bearer x / Basic x / token x. The scheme word is kept; it must not be mistaken for the value.
+  {
+    name: "authorization-header",
+    pattern: new RegExp(
+      String.raw`(\b(?:proxy-)?authorization["']?[ \t]*[:=][ \t]*["'\x60]?(?:${AUTH_SCHEME}[ \t]+)?)(?!${AUTH_SCHEME}[ \t])${NOT_MARK}[^\s'"\x60]+`,
+      "gi"
+    ),
+    highConfidence: false,
+    render: keepPrefix
+  },
+  // `--password secret`: a secret-named option whose value is the next argument. The flag must start a
+  // command-line word, so prose like "the `id`-token heuristic" is not read as a `-token` option.
+  {
+    name: "secret-option-arg",
+    pattern: new RegExp(
+      String.raw`(?<=^|[\s'"(])(-{1,2}${SECRET_KEY}[ \t]+)${NOT_FLAG_OR_REDIRECT}${NOT_MARK}${SECRET_VALUE}`,
+      "gi"
+    ),
+    highConfidence: false,
+    render: keepPrefix
+  },
+  // key/token/secret/password = "value" or : value, in code, JSON, env-file, shell or prose form.
+  // The key start is an explicit non-identifier lookbehind, not `\b`: `_` is a word character, so
+  // `\b` never fired inside DB_PASSWORD and the value leaked. Found live via `scan-shell`.
+  {
+    name: "key-value-secret",
+    pattern: new RegExp(
+      String.raw`(?<![A-Za-z0-9_.-])(${SECRET_KEY})["']?[ \t]*[:=](?![=>])[ \t]*(?!${TYPE_WORD})${NOT_MARK}${SECRET_VALUE}`,
+      "gi"
+    ),
+    highConfidence: false,
+    // Keep the key name so the redaction is legible ("apiKey: [redacted]").
+    render: (groups) => `${groups[0]}: ${MARK}`
+  }
+];
+function redact(text, profile = "all") {
+  let redactedCount = 0;
+  let out = text;
+  for (const rule of RULES) {
+    if (profile === "high-confidence" && !rule.highConfidence) continue;
+    out = out.replace(rule.pattern, (...args) => {
+      redactedCount += 1;
+      const end = args.findIndex((arg, i) => i > 0 && typeof arg === "number");
+      const groups = args.slice(1, end).map((g) => typeof g === "string" ? g : "");
+      return rule.render ? rule.render(groups) : MARK;
+    });
+  }
+  return { text: out, redactedCount };
+}
+
 // src/correlate/failure-fix.ts
 var DEFAULT_RETRY_WINDOW_MS = 24 * 60 * 60 * 1e3;
 var DEFAULT_DISCUSSION_WINDOW_MS = 24 * 60 * 60 * 1e3;
 var RESOLVED_BY_RETRY = "resolved_by:retry";
 var RESOLVED_BY_DISCUSSION = "resolved_by:discussion";
+var isAgentSource = (source) => source?.startsWith("agent:") === true;
 function normalizeCommand(command) {
   return command.trim().replace(/\s+/g, " ").toLowerCase();
 }
@@ -3091,7 +3292,9 @@ function correlateFailures(store, projectId, opts = {}) {
   const discussionWindowMs = opts.discussionWindowMs ?? DEFAULT_DISCUSSION_WINDOW_MS;
   const db = store.raw;
   const failures = db.prepare(
-    `SELECT id, ts_epoch, json_extract(meta, '$.command') AS command, json_extract(meta, '$.cwd') AS cwd
+    `SELECT id, ts_epoch, source, json_extract(meta, '$.command') AS command,
+              json_extract(meta, '$.commandHash') AS command_hash, json_extract(meta, '$.execHash') AS exec_hash,
+              json_extract(meta, '$.cwd') AS cwd
        FROM nodes
        WHERE project_id = ? AND kind = 'shell_command'
          AND source_ts IS NOT NULL
@@ -3100,15 +3303,22 @@ function correlateFailures(store, projectId, opts = {}) {
          AND json_extract(meta, '$.cwd') IS NOT NULL`
   ).all(projectId);
   const findRetry = db.prepare(
-    `SELECT id FROM nodes
-     WHERE project_id = ? AND kind = 'shell_command'
-       AND source_ts IS NOT NULL
-       AND json_extract(meta, '$.exitCode') = 0
-       AND json_extract(meta, '$.cwd') IS NOT NULL
-       AND ts_epoch > ? AND ts_epoch <= ?
-       AND lower(trim(json_extract(meta, '$.command'))) = ?
-       AND (json_extract(meta, '$.cwd') IS ? OR json_extract(meta, '$.cwd') = ?)
-     ORDER BY ts_epoch ASC LIMIT 1`
+    `SELECT n.id, n.source,
+            (SELECT COUNT(*) FROM node_files f WHERE f.node_id = n.id) AS file_count
+     FROM nodes n
+     WHERE n.project_id = ? AND n.kind = 'shell_command'
+       AND n.source_ts IS NOT NULL
+       AND json_extract(n.meta, '$.exitCode') = 0
+       AND json_extract(n.meta, '$.cwd') IS NOT NULL
+       AND n.ts_epoch > ? AND n.ts_epoch <= ?
+       AND (json_extract(n.meta, '$.cwd') IS ? OR json_extract(n.meta, '$.cwd') = ?)
+       AND CASE
+         WHEN ? IS NOT NULL AND json_extract(n.meta, '$.execHash') IS NOT NULL
+           THEN json_extract(n.meta, '$.execHash') = ?
+         ELSE lower(trim(json_extract(n.meta, '$.command'))) = ?
+           AND (? IS NULL OR json_extract(n.meta, '$.commandHash') = ?)
+       END
+     ORDER BY n.ts_epoch ASC LIMIT 1`
   );
   const findDiscussion = db.prepare(
     `SELECT n.id FROM nodes_fts
@@ -3120,19 +3330,31 @@ function correlateFailures(store, projectId, opts = {}) {
   );
   let linkedByRetry = 0;
   let linkedByDiscussion = 0;
+  let unexplainedRetries = 0;
   for (const failure of failures) {
     if (!failure.command) continue;
-    const retry = findRetry.get(
+    const redacted = failure.command.includes(REDACTION_MARK);
+    const requiredHash = redacted ? failure.command_hash ?? "" : null;
+    const retry = redacted && !failure.command_hash && !failure.exec_hash ? void 0 : findRetry.get(
       projectId,
       failure.ts_epoch,
       failure.ts_epoch + retryWindowMs,
-      normalizeCommand(failure.command),
       failure.cwd,
-      failure.cwd
+      failure.cwd,
+      failure.exec_hash,
+      failure.exec_hash,
+      normalizeCommand(failure.command),
+      requiredHash,
+      requiredHash
     );
     if (retry) {
-      store.linkNodes(failure.id, retry.id, RESOLVED_BY_RETRY);
-      linkedByRetry += 1;
+      const bothAgentRecorded = isAgentSource(failure.source) && isAgentSource(retry.source);
+      if (bothAgentRecorded && retry.file_count === 0) {
+        unexplainedRetries += 1;
+      } else {
+        store.linkNodes(failure.id, retry.id, RESOLVED_BY_RETRY);
+        linkedByRetry += 1;
+      }
     }
     const tokens = filterBoilerplateTokens(db, projectId, significantTokens(failure.command));
     const match = tokens.length > 0 ? tokens.map((t) => `"${t}"*`).join(" AND ") : null;
@@ -3144,7 +3366,7 @@ function correlateFailures(store, projectId, opts = {}) {
       }
     }
   }
-  return { failuresExamined: failures.length, linkedByRetry, linkedByDiscussion };
+  return { failuresExamined: failures.length, linkedByRetry, linkedByDiscussion, unexplainedRetries };
 }
 function getChainStats(store, projectId) {
   const db = store.raw;
@@ -3467,6 +3689,7 @@ var OllamaEmbeddingProvider = class {
 };
 
 // src/cli/commands/sync.ts
+import { existsSync as existsSync5 } from "fs";
 import pc7 from "picocolors";
 
 // src/conversation/chunk.ts
@@ -3505,42 +3728,6 @@ function chunkAssistantText(text, maxChars) {
   return chunks;
 }
 
-// src/conversation/redact.ts
-var RULES = [
-  {
-    name: "private-key-block",
-    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
-    highConfidence: true
-  },
-  { name: "aws-access-key", pattern: /\bAKIA[0-9A-Z]{16}\b/g, highConfidence: true },
-  { name: "github-token", pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g, highConfidence: true },
-  { name: "slack-token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, highConfidence: true },
-  {
-    name: "jwt",
-    pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g,
-    highConfidence: true
-  },
-  // key/token/secret/password = "value" or : value, in code, JSON, env-file or prose form.
-  {
-    name: "key-value-secret",
-    pattern: /\b((?:api[_-]?key|secret|password|passwd|token|access[_-]?key)s?)\s*[:=]\s*['"]?[A-Za-z0-9_\-./+=]{8,}['"]?/gi,
-    highConfidence: false
-  }
-];
-function redact(text, profile = "all") {
-  let redactedCount = 0;
-  let out = text;
-  for (const rule of RULES) {
-    if (profile === "high-confidence" && !rule.highConfidence) continue;
-    out = out.replace(rule.pattern, (_match, ...rest) => {
-      redactedCount += 1;
-      const key = typeof rest[0] === "string" ? rest[0] : null;
-      return key ? `${key}: [redacted]` : "[redacted]";
-    });
-  }
-  return { text: out, redactedCount };
-}
-
 // src/collectors/conversation.ts
 var DEFAULT_MAX_BODY_CHARS = 2500;
 var DEFAULT_MAX_CHUNK_CHARS = 900;
@@ -3562,15 +3749,15 @@ ${replyText}`;
 var FILE_PATH = /\b(?:[\w.-]+\/)*[\w-]+\.(?:ts|tsx|js|jsx|json|md|py|rs|go|java|c|cpp|h|hpp|css|html|ya?ml|toml|sql|sh|ps1)\b/g;
 function extractMentionedFiles(text) {
   const seen = /* @__PURE__ */ new Set();
-  const files = [];
+  const files2 = [];
   for (const match of text.matchAll(FILE_PATH)) {
     const path = match[0];
     if (seen.has(path)) continue;
     seen.add(path);
-    files.push({ path, insertions: null, deletions: null, binary: false });
-    if (files.length >= MAX_FILES_PER_NODE) break;
+    files2.push({ path, insertions: null, deletions: null, binary: false });
+    if (files2.length >= MAX_FILES_PER_NODE) break;
   }
-  return files;
+  return files2;
 }
 function withSuffix(base, suffix) {
   const budget = Math.max(20, MAX_TITLE_CHARS - suffix.length);
@@ -3667,7 +3854,7 @@ function stripSubject(message, subject) {
 }
 var NUMSTAT_LINE = /^(\d+|-)\t(\d+|-)\t(.*)$/;
 function parseNumstat(block) {
-  const files = [];
+  const files2 = [];
   for (const line of block.split("\n")) {
     const m = NUMSTAT_LINE.exec(line.trimEnd());
     if (!m) continue;
@@ -3681,9 +3868,9 @@ function parseNumstat(block) {
       binary
     };
     if (previousPath) touch.previousPath = previousPath;
-    files.push(touch);
+    files2.push(touch);
   }
-  return files;
+  return files2;
 }
 function resolveRenamePath(raw) {
   const braced = /^(.*)\{(.*?) => (.*?)\}(.*)$/.exec(raw);
@@ -3803,12 +3990,12 @@ function parseCommitDiffRecord(record) {
 var FILE_HEADER = "diff --git ";
 var HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/;
 function parseFileDiffs(block) {
-  const files = [];
+  const files2 = [];
   let section = null;
   const flush = () => {
     if (!section) return;
     const parsed = parseFileSection(section);
-    if (parsed) files.push(parsed);
+    if (parsed) files2.push(parsed);
     section = null;
   };
   for (const raw of block.split("\n")) {
@@ -3821,7 +4008,7 @@ function parseFileDiffs(block) {
     }
   }
   flush();
-  return files;
+  return files2;
 }
 function parseFileSection(lines) {
   let status = "modified";
@@ -4070,8 +4257,8 @@ function scoreFileDiff(subject, file) {
 function byChurnDesc2(a, b) {
   return b.insertions + b.deletions - (a.insertions + a.deletions);
 }
-function indexableFiles(files) {
-  return files.filter((f) => !f.binary && f.hunkCount > 0 && !isGeneratedPath(f.path));
+function indexableFiles(files2) {
+  return files2.filter((f) => !f.binary && f.hunkCount > 0 && !isGeneratedPath(f.path));
 }
 var STATUS_LABEL = {
   added: "added",
@@ -4189,8 +4376,8 @@ function toMemoryNodes3(file, projectId, opts = {}) {
     };
   });
 }
-function collectDocFiles(files, projectId, opts = {}) {
-  return files.flatMap((file) => toMemoryNodes3(file, projectId, opts));
+function collectDocFiles(files2, projectId, opts = {}) {
+  return files2.flatMap((file) => toMemoryNodes3(file, projectId, opts));
 }
 
 // src/collectors/github.ts
@@ -4512,7 +4699,8 @@ function toMemoryNode3(entry, projectId, opts = {}) {
     signal: scoreShellCommand(entry),
     provenance: "observed",
     meta: {
-      command: entry.command,
+      command: redactedCommand,
+      commandHash: entry.commandHash ?? sha256Hex(entry.command).slice(0, 12),
       cwd: entry.cwd,
       exitCode: entry.exitCode,
       durationMs: entry.durationMs,
@@ -4627,9 +4815,9 @@ function parseClaudeCodeTranscript(raw, opts = {}) {
   return turns;
 }
 async function collectClaudeCodeTranscripts(repoRoot) {
-  const files = await listTranscriptFiles(repoRoot);
+  const files2 = await listTranscriptFiles(repoRoot);
   const turns = [];
-  for (const file of files) {
+  for (const file of files2) {
     const raw = await readFile6(file, "utf8");
     turns.push(...parseClaudeCodeTranscript(raw, { sessionId: basename2(file, ".jsonl") }));
   }
@@ -4647,7 +4835,7 @@ async function listDocFiles(repoRoot, opts = {}) {
 }
 async function readDocFiles(repoRoot, opts = {}) {
   const paths = await listDocFiles(repoRoot, opts);
-  const files = [];
+  const files2 = [];
   const unreadable = [];
   for (const relPath of paths) {
     const path = relPath.replace(/\\/g, "/");
@@ -4660,9 +4848,9 @@ async function readDocFiles(repoRoot, opts = {}) {
       unreadable.push(path);
       continue;
     }
-    files.push({ path, content, ts: mtime.toISOString() });
+    files2.push({ path, content, ts: mtime.toISOString() });
   }
-  return { files, unreadable };
+  return { files: files2, unreadable };
 }
 
 // src/github/read.ts
@@ -4864,10 +5052,11 @@ ${full.body}`);
 
 // src/shell/detect.ts
 import { existsSync as existsSync4 } from "fs";
-import { readFile as readFile9, stat as stat2 } from "fs/promises";
+import { readFile as readFile9, stat as stat3 } from "fs/promises";
+import { posix, win32 } from "path";
 
 // src/shell/hook-log.ts
-import { appendFile, mkdir as mkdir5, readFile as readFile8 } from "fs/promises";
+import { appendFile, mkdir as mkdir5, open, readFile as readFile8, rename as rename2, stat as stat2, unlink as unlink2, writeFile as writeFile6 } from "fs/promises";
 import { dirname as dirname4 } from "path";
 var HOOK_SHELL_KINDS = /* @__PURE__ */ new Set(["pwsh-hook", "bash-hook", "zsh-hook"]);
 function parseHookLogLine(line) {
@@ -4882,7 +5071,9 @@ function parseHookLogLine(line) {
   if (typeof obj !== "object" || obj === null) return null;
   const o = obj;
   if (typeof o.ts !== "string" || typeof o.cwd !== "string" || typeof o.command !== "string") return null;
+  const commandHash = typeof o.commandHash === "string" && /^[0-9a-f]{12}$/.test(o.commandHash) ? o.commandHash : void 0;
   return {
+    ...commandHash ? { commandHash } : {},
     ts: o.ts,
     cwd: o.cwd,
     exitCode: typeof o.exitCode === "number" ? o.exitCode : null,
@@ -4906,6 +5097,87 @@ async function readHookLog(path, fromLine) {
   const entries = allParsed.slice(sliceStart).filter((e) => e !== null);
   return { entries, totalLines: lines.length, shellsSeen };
 }
+function sanitizeLine(line) {
+  if (line.trim().length === 0) return { line, legacy: false };
+  let obj;
+  try {
+    obj = JSON.parse(line);
+  } catch {
+    return { line: redact(line).text, legacy: false };
+  }
+  const o = obj;
+  if (typeof o !== "object" || o === null || typeof o.command !== "string") return { line: redact(line).text, legacy: false };
+  const legacy = typeof o.commandHash !== "string";
+  const raw = o.command;
+  const { text } = redact(raw);
+  if (!legacy && text === raw) return { line, legacy };
+  const commandHash = legacy ? sha256Hex(raw).slice(0, 12) : o.commandHash;
+  return { line: JSON.stringify({ ...o, command: text, commandHash }), legacy };
+}
+function sanitizeText(raw) {
+  const parts = raw.split(/(\r?\n)/);
+  let changed = 0;
+  let legacy = 0;
+  for (let i = 0; i < parts.length; i += 2) {
+    const next = sanitizeLine(parts[i]);
+    if (next.legacy) legacy += 1;
+    if (next.line !== parts[i]) {
+      parts[i] = next.line;
+      changed += 1;
+    }
+  }
+  return { text: parts.join(""), changed, legacy };
+}
+async function readRange(path, start, end) {
+  const fh = await open(path, "r");
+  try {
+    const buf = Buffer.alloc(end - start);
+    await fh.read(buf, 0, buf.length, start);
+    return buf;
+  } finally {
+    await fh.close();
+  }
+}
+var RENAME_BUSY = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
+async function sanitizeHookLog(path, opts = {}) {
+  let raw;
+  try {
+    raw = await readFile8(path);
+  } catch {
+    return { linesChanged: 0, legacyLines: 0 };
+  }
+  const first = sanitizeText(raw.toString("utf8"));
+  if (first.changed === 0 || opts.dryRun) return { linesChanged: first.changed, legacyLines: first.legacy };
+  const tmp = `${path}.${process.pid}.scrub.tmp`;
+  let linesChanged = first.changed;
+  let legacyLines = first.legacy;
+  try {
+    await writeFile6(tmp, first.text, { encoding: "utf8", mode: 384 });
+    let consumed = raw.length;
+    for (let attempt = 0; ; attempt += 1) {
+      const size = (await stat2(path)).size;
+      if (size > consumed) {
+        const extra = sanitizeText((await readRange(path, consumed, size)).toString("utf8"));
+        await appendFile(tmp, extra.text, "utf8");
+        linesChanged += extra.changed;
+        legacyLines += extra.legacy;
+        consumed = size;
+      }
+      try {
+        await rename2(tmp, path);
+        break;
+      } catch (err) {
+        if (attempt >= 20 || !RENAME_BUSY.has(err.code ?? "")) throw err;
+        await new Promise((r) => setTimeout(r, 50));
+      }
+    }
+  } catch (err) {
+    await unlink2(tmp).catch(() => {
+    });
+    throw err;
+  }
+  return { linesChanged, legacyLines };
+}
 
 // src/shell/parse-bash.ts
 var EPOCH_COMMENT = /^#(\d{9,10})$/;
@@ -5008,16 +5280,25 @@ ${rawLines[i]}`;
 }
 
 // src/shell/detect.ts
-function isUnderRoot(cwd, root) {
-  const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
-  const c = norm(cwd);
-  const r = norm(root);
-  return c === r || c.startsWith(`${r}/`);
+function forAdmission(path, platform) {
+  const impl = platform === "win32" ? win32 : posix;
+  let text = impl.normalize(path);
+  const root = impl.parse(text).root;
+  if (text.length > root.length) text = text.replace(platform === "win32" ? /[\\/]+$/ : /\/+$/, "");
+  return { text: platform === "win32" ? text.toLowerCase() : text, sep: impl.sep };
+}
+function isUnderRoot(cwd, root, platform = process.platform) {
+  const c = forAdmission(cwd, platform);
+  const r = forAdmission(root, platform);
+  if (c.text === r.text) return true;
+  return c.text.startsWith(r.text.endsWith(r.sep) ? r.text : r.text + r.sep);
 }
 function hookEntryToRaw(e) {
   const shell = e.shell ?? "pwsh-hook";
+  const commandHash = e.commandHash ?? sha256Hex(e.command).slice(0, 12);
   return {
-    naturalKey: `${shell}:${e.ts}:${sha256Hex(e.command).slice(0, 12)}`,
+    naturalKey: `${shell}:${e.ts}:${commandHash}`,
+    commandHash,
     command: e.command,
     ts: e.ts,
     tsApprox: false,
@@ -5029,7 +5310,7 @@ function hookEntryToRaw(e) {
 }
 async function tryReadScrapeSource(path, parse, tailLines) {
   if (!existsSync4(path)) return null;
-  const [raw, stats2] = await Promise.all([readFile9(path, "utf8"), stat2(path)]);
+  const [raw, stats2] = await Promise.all([readFile9(path, "utf8"), stat3(path)]);
   return parse(raw, stats2.mtimeMs, { tailLines });
 }
 async function collectAvailableShellHistory(opts = {}) {
@@ -5043,7 +5324,7 @@ async function collectAvailableShellHistory(opts = {}) {
     const fromLine = Number(opts.hookCursor ?? "0") || 0;
     const { entries, totalLines, shellsSeen: seen } = await readHookLog(hookPath, fromLine);
     shellsSeen = seen;
-    const scoped = opts.repoRoot ? entries.filter((e) => isUnderRoot(e.cwd, opts.repoRoot)) : entries;
+    const scoped = opts.repoRoot ? entries.filter((e) => isUnderRoot(e.cwd, opts.repoRoot, opts.platform)) : entries;
     results.push({ name: "pwsh-hook", entries: scoped.map(hookEntryToRaw), cursorAfter: String(totalLines) });
   }
   const skipPwshScrape = preferHook && shellsSeen.has("pwsh-hook");
@@ -5065,7 +5346,7 @@ async function collectAvailableShellHistory(opts = {}) {
 }
 
 // src/store/reconcile.ts
-function recomputeByNaturalKey(db, oldProjectId, newProjectId, kind, source, computeNaturalKey, denyEntries) {
+function recomputeByNaturalKey(db, oldProjectId, newProjectId, kind, source, computeNaturalKey, denyEntries, movedIds) {
   const rows = source ? db.prepare("SELECT * FROM nodes WHERE project_id = ? AND kind = ? AND source = ?").all(oldProjectId, kind, source) : db.prepare("SELECT * FROM nodes WHERE project_id = ? AND kind = ?").all(oldProjectId, kind);
   const nodeExists = db.prepare("SELECT 1 FROM nodes WHERE id = ?");
   const insertNode = db.prepare(
@@ -5103,6 +5384,7 @@ function recomputeByNaturalKey(db, oldProjectId, newProjectId, kind, source, com
       continue;
     }
     const newId = makeNodeId(newProjectId, kind, naturalKey);
+    movedIds.set(row.id, newId);
     if (nodeExists.get(newId)) {
       deduped += 1;
     } else {
@@ -5138,69 +5420,101 @@ function recomputeByNaturalKey(db, oldProjectId, newProjectId, kind, source, com
   }
   return { migrated, deduped, skipped, denied };
 }
-function reconcileProjectId(db, oldProjectId, newProjectId) {
-  return db.transaction(() => {
-    const denyEntries = listDenyListEntries(db, newProjectId);
-    const sessions = recomputeByNaturalKey(
+function snapshotLinks(db, projectIds) {
+  const scope = "SELECT id FROM nodes WHERE project_id IN (SELECT value FROM json_each(?))";
+  return db.prepare(
+    `SELECT from_node_id, to_node_id, relation, created_at FROM node_links
+       WHERE from_node_id IN (${scope}) OR to_node_id IN (${scope})`
+  ).all(JSON.stringify(projectIds), JSON.stringify(projectIds));
+}
+function restoreLinks(db, links, movedIds, newProjectId) {
+  const inNewProject = db.prepare("SELECT 1 FROM nodes WHERE id = ? AND project_id = ?");
+  const insertLink = db.prepare(
+    "INSERT OR IGNORE INTO node_links (from_node_id, to_node_id, relation, created_at) VALUES (?, ?, ?, ?)"
+  );
+  for (const link of links) {
+    const from = movedIds.get(link.from_node_id) ?? link.from_node_id;
+    const to = movedIds.get(link.to_node_id) ?? link.to_node_id;
+    if (inNewProject.get(from, newProjectId) && inNewProject.get(to, newProjectId)) {
+      insertLink.run(from, to, link.relation, link.created_at);
+    }
+  }
+}
+function reconcileOne(db, oldProjectId, newProjectId, movedIds) {
+  const denyEntries = listDenyListEntries(db, newProjectId);
+  const sessions = recomputeByNaturalKey(
+    db,
+    oldProjectId,
+    newProjectId,
+    "session_summary",
+    null,
+    (_row, meta) => typeof meta.sessionKey === "string" ? meta.sessionKey : null,
+    denyEntries,
+    movedIds
+  );
+  const HOOK_SHELL_SOURCES = [
+    { source: "shell:pwsh-hook", prefix: "pwsh-hook" },
+    { source: "shell:bash-hook", prefix: "bash-hook" },
+    { source: "shell:zsh-hook", prefix: "zsh-hook" }
+  ];
+  const hookShell = { migrated: 0, deduped: 0, skipped: 0, denied: 0 };
+  for (const { source, prefix } of HOOK_SHELL_SOURCES) {
+    const r = recomputeByNaturalKey(
       db,
       oldProjectId,
       newProjectId,
-      "session_summary",
-      null,
-      (_row, meta) => typeof meta.sessionKey === "string" ? meta.sessionKey : null,
-      denyEntries
+      "shell_command",
+      source,
+      (row, meta) => {
+        const hash = typeof meta.commandHash === "string" ? meta.commandHash : typeof meta.command === "string" ? sha256Hex(meta.command).slice(0, 12) : null;
+        return hash ? `${prefix}:${row.ts}:${hash}` : null;
+      },
+      denyEntries,
+      movedIds
     );
-    const HOOK_SHELL_SOURCES = [
-      { source: "shell:pwsh-hook", prefix: "pwsh-hook" },
-      { source: "shell:bash-hook", prefix: "bash-hook" },
-      { source: "shell:zsh-hook", prefix: "zsh-hook" }
-    ];
-    const hookShell = { migrated: 0, deduped: 0, skipped: 0, denied: 0 };
-    for (const { source, prefix } of HOOK_SHELL_SOURCES) {
-      const r = recomputeByNaturalKey(
-        db,
-        oldProjectId,
-        newProjectId,
-        "shell_command",
-        source,
-        (row, meta) => typeof meta.command === "string" ? `${prefix}:${row.ts}:${sha256Hex(meta.command).slice(0, 12)}` : null,
-        denyEntries
-      );
-      hookShell.migrated += r.migrated;
-      hookShell.deduped += r.deduped;
-      hookShell.skipped += r.skipped;
-      hookShell.denied += r.denied;
-    }
-    let deniedConversationTurns = 0;
-    if (denyEntries.length > 0) {
-      const conversationTurns = db.prepare(`SELECT id, title, body, meta FROM nodes WHERE project_id = ? AND kind = 'conversation_turn'`).all(oldProjectId);
-      if (conversationTurns.length > 0) {
-        const dropEmbedding = db.prepare("DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)");
-        const deleteNode = db.prepare("DELETE FROM nodes WHERE id = ?");
-        for (const row of conversationTurns) {
-          let meta;
-          try {
-            meta = JSON.parse(row.meta);
-          } catch {
-            meta = {};
-          }
-          if (firstMatchingEntry(denyEntries, { title: row.title, body: row.body, meta })) {
-            dropEmbedding.run(row.id);
-            deleteNode.run(row.id);
-            deniedConversationTurns += 1;
-          }
+    hookShell.migrated += r.migrated;
+    hookShell.deduped += r.deduped;
+    hookShell.skipped += r.skipped;
+    hookShell.denied += r.denied;
+  }
+  let deniedConversationTurns = 0;
+  if (denyEntries.length > 0) {
+    const conversationTurns = db.prepare(`SELECT id, title, body, meta FROM nodes WHERE project_id = ? AND kind = 'conversation_turn'`).all(oldProjectId);
+    if (conversationTurns.length > 0) {
+      const dropEmbedding = db.prepare("DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)");
+      const deleteNode = db.prepare("DELETE FROM nodes WHERE id = ?");
+      for (const row of conversationTurns) {
+        let meta;
+        try {
+          meta = JSON.parse(row.meta);
+        } catch {
+          meta = {};
+        }
+        if (firstMatchingEntry(denyEntries, { title: row.title, body: row.body, meta })) {
+          dropEmbedding.run(row.id);
+          deleteNode.run(row.id);
+          deniedConversationTurns += 1;
         }
       }
     }
-    const reassigned = db.prepare(`UPDATE nodes SET project_id = ? WHERE project_id = ? AND kind = 'conversation_turn'`).run(newProjectId, oldProjectId).changes;
-    return {
-      oldProjectId,
-      migrated: sessions.migrated + hookShell.migrated,
-      reassigned,
-      deduped: sessions.deduped + hookShell.deduped,
-      skipped: sessions.skipped + hookShell.skipped,
-      denied: sessions.denied + hookShell.denied + deniedConversationTurns
-    };
+  }
+  const reassigned = db.prepare(`UPDATE nodes SET project_id = ? WHERE project_id = ? AND kind = 'conversation_turn'`).run(newProjectId, oldProjectId).changes;
+  return {
+    oldProjectId,
+    migrated: sessions.migrated + hookShell.migrated,
+    reassigned,
+    deduped: sessions.deduped + hookShell.deduped,
+    skipped: sessions.skipped + hookShell.skipped,
+    denied: sessions.denied + hookShell.denied + deniedConversationTurns
+  };
+}
+function reconcileProjectIds(db, oldProjectIds, newProjectId) {
+  return db.transaction(() => {
+    const links = snapshotLinks(db, oldProjectIds);
+    const movedIds = /* @__PURE__ */ new Map();
+    const results = oldProjectIds.map((oldProjectId) => reconcileOne(db, oldProjectId, newProjectId, movedIds));
+    restoreLinks(db, links, movedIds, newProjectId);
+    return results;
   })();
 }
 
@@ -5329,7 +5643,7 @@ function extractRustModSpecifiers(source) {
 }
 
 // src/structure/resolve.ts
-import { posix } from "path";
+import { posix as posix2 } from "path";
 var REWRITE_EXTENSIONS = {
   ".js": [".ts", ".tsx", ".js"],
   ".jsx": [".tsx", ".jsx"],
@@ -5339,10 +5653,10 @@ var REWRITE_EXTENSIONS = {
 var APPEND_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".d.ts", ".json"];
 var INDEX_FILES = ["index.ts", "index.tsx", "index.js", "index.jsx"];
 function resolveSpecifier(fromPath, specifier, trackedPaths) {
-  const fromDir = posix.dirname(fromPath);
-  const joined = posix.normalize(posix.join(fromDir, specifier));
+  const fromDir = posix2.dirname(fromPath);
+  const joined = posix2.normalize(posix2.join(fromDir, specifier));
   if (trackedPaths.has(joined)) return joined;
-  const ext = posix.extname(joined);
+  const ext = posix2.extname(joined);
   const rewrites = REWRITE_EXTENSIONS[ext];
   if (rewrites) {
     const base = joined.slice(0, -ext.length);
@@ -5358,14 +5672,14 @@ function resolveSpecifier(fromPath, specifier, trackedPaths) {
     if (trackedPaths.has(candidate)) return candidate;
   }
   for (const indexFile of INDEX_FILES) {
-    const candidate = posix.join(joined, indexFile);
+    const candidate = posix2.join(joined, indexFile);
     if (trackedPaths.has(candidate)) return candidate;
   }
   return null;
 }
 
 // src/structure/resolve-go.ts
-import { posix as posix2 } from "path";
+import { posix as posix3 } from "path";
 function parseGoModulePath(goModContent) {
   const match = goModContent.match(/^module\s+(\S+)/m);
   return match ? match[1] : null;
@@ -5379,11 +5693,11 @@ function resolveGoSpecifier(modulePath, importPath, trackedPaths) {
   } else {
     return [];
   }
-  return [...trackedPaths].filter((p) => p.endsWith(".go") && !p.endsWith("_test.go") && posix2.dirname(p) === relDir).sort();
+  return [...trackedPaths].filter((p) => p.endsWith(".go") && !p.endsWith("_test.go") && posix3.dirname(p) === relDir).sort();
 }
 
 // src/structure/resolve-java.ts
-import { posix as posix3 } from "path";
+import { posix as posix4 } from "path";
 function endsAtSegmentBoundary(path, suffix) {
   return path === suffix || path.endsWith(`/${suffix}`);
 }
@@ -5393,8 +5707,8 @@ function resolveJavaSpecifier(specifier, trackedPaths) {
   if (segments.length === 0) return [];
   if (isWildcard) {
     const dirSuffix = segments.join("/");
-    const matches2 = [...trackedPaths].filter((p) => p.endsWith(".java") && endsAtSegmentBoundary(posix3.dirname(p), dirSuffix));
-    const dirs = new Set(matches2.map((p) => posix3.dirname(p)));
+    const matches2 = [...trackedPaths].filter((p) => p.endsWith(".java") && endsAtSegmentBoundary(posix4.dirname(p), dirSuffix));
+    const dirs = new Set(matches2.map((p) => posix4.dirname(p)));
     return dirs.size === 1 ? matches2.sort() : [];
   }
   const fileSuffix = `${segments.join("/")}.java`;
@@ -5403,11 +5717,11 @@ function resolveJavaSpecifier(specifier, trackedPaths) {
 }
 
 // src/structure/resolve-php.ts
-import { posix as posix4 } from "path";
+import { posix as posix5 } from "path";
 function resolvePhpSpecifier(fromPath, specifier, trackedPaths) {
-  const fromDir = posix4.dirname(fromPath);
-  const relative2 = specifier.startsWith("/") ? specifier.slice(1) : specifier;
-  const joined = posix4.normalize(posix4.join(fromDir, relative2));
+  const fromDir = posix5.dirname(fromPath);
+  const relative3 = specifier.startsWith("/") ? specifier.slice(1) : specifier;
+  const joined = posix5.normalize(posix5.join(fromDir, relative3));
   if (trackedPaths.has(joined)) return joined;
   const withExt = joined.endsWith(".php") ? joined : `${joined}.php`;
   if (trackedPaths.has(withExt)) return withExt;
@@ -5415,7 +5729,7 @@ function resolvePhpSpecifier(fromPath, specifier, trackedPaths) {
 }
 
 // src/structure/resolve-python.ts
-import { posix as posix5 } from "path";
+import { posix as posix6 } from "path";
 var STDLIB_MODULES = /* @__PURE__ */ new Set([
   "__future__",
   "abc",
@@ -5593,27 +5907,27 @@ function resolvePythonSpecifier(fromPath, specifier, trackedPaths) {
   if (level === 0 && STDLIB_MODULES.has(specifier)) return null;
   const segments = (level === 0 ? specifier : specifier.slice(level)).split(".").filter(Boolean);
   if (segments.length === 0) return null;
-  let dir = posix5.dirname(fromPath);
+  let dir = posix6.dirname(fromPath);
   for (let i = 1; i < level; i++) {
-    dir = posix5.dirname(dir);
+    dir = posix6.dirname(dir);
   }
-  const joined = posix5.join(dir, ...segments);
+  const joined = posix6.join(dir, ...segments);
   const moduleFile = `${joined}.py`;
   if (trackedPaths.has(moduleFile)) return moduleFile;
-  const packageInit = posix5.join(joined, "__init__.py");
+  const packageInit = posix6.join(joined, "__init__.py");
   if (trackedPaths.has(packageInit)) return packageInit;
   return null;
 }
 
 // src/structure/resolve-rust.ts
-import { posix as posix6 } from "path";
+import { posix as posix7 } from "path";
 function resolveRustModSpecifier(fromPath, name, trackedPaths) {
-  const dir = posix6.dirname(fromPath);
-  const base = posix6.basename(fromPath, ".rs");
-  const moduleDir = base === "mod" || base === "lib" || base === "main" ? dir : posix6.join(dir, base);
-  const sibling = posix6.join(moduleDir, `${name}.rs`);
+  const dir = posix7.dirname(fromPath);
+  const base = posix7.basename(fromPath, ".rs");
+  const moduleDir = base === "mod" || base === "lib" || base === "main" ? dir : posix7.join(dir, base);
+  const sibling = posix7.join(moduleDir, `${name}.rs`);
   if (trackedPaths.has(sibling)) return sibling;
-  const nested = posix6.join(moduleDir, name, "mod.rs");
+  const nested = posix7.join(moduleDir, name, "mod.rs");
   if (trackedPaths.has(nested)) return nested;
   return null;
 }
@@ -5744,11 +6058,231 @@ ${node.body}`)
   };
 }
 
+// src/agent/paths.ts
+import { join as join11 } from "path";
+function agentEventLogPath() {
+  return join11(globalWorkspaceDir(), "agent-events.jsonl");
+}
+
+// src/agent/record.ts
+import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile11 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+var KINDS = /* @__PURE__ */ new Set(["command", "edit"]);
+var OUTCOMES = /* @__PURE__ */ new Set(["ok", "fail", "interrupted", "unknown"]);
+function parseAgentEventLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const e = parsed;
+  if (typeof e.agent !== "string" || typeof e.sessionId !== "string" || typeof e.eventId !== "string") return null;
+  if (typeof e.ts !== "string" || typeof e.kind !== "string" || !KINDS.has(e.kind)) return null;
+  if (typeof e.outcome !== "string" || !OUTCOMES.has(e.outcome)) return null;
+  return parsed;
+}
+async function readAgentEvents(logPath, fromLine) {
+  let raw;
+  try {
+    raw = await readFile11(logPath, "utf8");
+  } catch {
+    return { events: [], totalLines: fromLine };
+  }
+  const lines = raw.split(/\r?\n/).filter((l) => l.length > 0);
+  const start = fromLine > 0 && fromLine <= lines.length ? fromLine : 0;
+  const events = lines.slice(start).map(parseAgentEventLine).filter((e) => e !== null);
+  return { events, totalLines: lines.length };
+}
+
+// src/collectors/agent-events.ts
+import { relative as relative2 } from "path";
+
+// src/agent/event.ts
+var OBSERVATION_COMMANDS = /* @__PURE__ */ new Set(["ls", "pwd", "echo", "cat"]);
+var OBSERVATION_GIT_SUBCOMMANDS = /* @__PURE__ */ new Set(["status", "log", "diff", "show"]);
+var UNSAFE_SEGMENT = /[|&<>`(){}]|\$\(/;
+function splitSegments(command) {
+  const segments = [];
+  let current = "";
+  let quote2 = null;
+  for (let i = 0; i < command.length; i += 1) {
+    const ch = command[i];
+    if (quote2) {
+      current += ch;
+      if (ch === quote2) quote2 = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote2 = ch;
+      current += ch;
+      continue;
+    }
+    if (ch === ";") {
+      segments.push(current);
+      current = "";
+      continue;
+    }
+    if (ch === "&" && command[i + 1] === "&") {
+      segments.push(current);
+      current = "";
+      i += 1;
+      continue;
+    }
+    current += ch;
+  }
+  if (quote2) return null;
+  segments.push(current);
+  return segments.map((s) => s.trim()).filter((s) => s.length > 0);
+}
+var CD_SEGMENT = /^cd\s+(?:"([^"]*)"|'([^']*)'|(\S+))$/;
+var DRIVE_SPELLING = /^\/(?:mnt\/)?([a-zA-Z])(?:\/|$)/;
+var WINDOWS_DRIVE = /^[a-zA-Z]:(?:\/|$)/;
+var WINDOWS_UNC = /^\/\/[^/]+\/[^/]+/;
+function directoryForCompare(path, platform) {
+  if (platform !== "win32") return { text: path.replace(/\/+$/, ""), foldsCase: false };
+  const slashed = path.replace(/\\/g, "/");
+  const drive = DRIVE_SPELLING.exec(slashed);
+  const native = drive ? `${drive[1]}:/${slashed.slice(drive[0].length)}` : slashed;
+  return { text: native.replace(/\/+$/, ""), foldsCase: WINDOWS_DRIVE.test(native) || WINDOWS_UNC.test(native) };
+}
+function sameDirectory(a, b, platform = process.platform) {
+  const x = directoryForCompare(a, platform);
+  const y = directoryForCompare(b, platform);
+  return x.foldsCase && y.foldsCase ? x.text.toLowerCase() === y.text.toLowerCase() : x.text === y.text;
+}
+function classify(segment, cwd, platform) {
+  if (UNSAFE_SEGMENT.test(segment)) return "target";
+  const cd = CD_SEGMENT.exec(segment);
+  if (cd) {
+    if (!cwd) return "target";
+    const to = cd[1] ?? cd[2] ?? cd[3] ?? "";
+    if (to === ".") return "navigation";
+    return sameDirectory(to, cwd, platform) ? "navigation" : "target";
+  }
+  const [head, next] = segment.split(/\s+/);
+  if (!head) return "target";
+  if (OBSERVATION_COMMANDS.has(head)) return "observation";
+  if (head === "git" && next !== void 0 && OBSERVATION_GIT_SUBCOMMANDS.has(next)) return "observation";
+  return "target";
+}
+function canonicalizeCommand(command, cwd, platform = process.platform) {
+  const segments = splitSegments(command);
+  if (!segments) return command;
+  const targets = segments.filter((s) => classify(s, cwd, platform) === "target");
+  return targets.length === 1 ? targets[0] : command;
+}
+var MAX_ERROR_SIGNATURE_CHARS = 200;
+function agentEventNaturalKey(event) {
+  return `agent:${event.agent}:${event.sessionId}:${event.eventId}`;
+}
+function redactAgentEvent(raw) {
+  const { command, errorSignature, ...rest } = raw;
+  return {
+    ...rest,
+    ...command === void 0 ? {} : {
+      command: redact(command).text,
+      commandHash: sha256Hex(command).slice(0, 12),
+      execHash: sha256Hex(canonicalizeCommand(command, raw.cwd)).slice(0, 12)
+    },
+    ...errorSignature === void 0 ? {} : { errorSignature: redact(errorSignature).text.slice(0, MAX_ERROR_SIGNATURE_CHARS) }
+  };
+}
+
+// src/collectors/agent-events.ts
+var MAX_TITLE_CHARS8 = 200;
+var DEFAULT_MAX_BODY_CHARS6 = 1e3;
+function toFileTouch(path, repoRoot) {
+  const rel = relative2(repoRoot, path).replace(/\\/g, "/");
+  return { path: rel, insertions: null, deletions: null, binary: false };
+}
+function renderBody3(event, files2, maxChars) {
+  const parts = [`$ ${event.command ?? ""}`];
+  const meta = [];
+  if (event.cwd) meta.push(`cwd: ${event.cwd}`);
+  if (event.exitCode !== null) meta.push(`exit: ${event.exitCode}`);
+  else if (event.outcome === "interrupted") meta.push("interrupted");
+  if (event.durationMs !== null) meta.push(`duration: ${event.durationMs}ms`);
+  meta.push(`agent: ${event.agent}`);
+  parts.push("", meta.join("  "));
+  if (event.errorSignature) parts.push(`error: ${event.errorSignature}`);
+  if (files2.length > 0) parts.push(`changed before this ran: ${files2.map((f) => f.path).join(", ")}`);
+  return truncate(parts.join("\n"), maxChars);
+}
+function toAgentMemoryNode(event, files2, projectId, opts) {
+  const command = event.command ?? "";
+  return {
+    id: makeNodeId(projectId, "shell_command", agentEventNaturalKey(event)),
+    kind: "shell_command",
+    projectId,
+    ts: event.ts,
+    sourceTs: event.ts,
+    source: `agent:${event.agent}`,
+    title: truncate(command.split(/\r?\n/)[0] ?? command, MAX_TITLE_CHARS8),
+    body: renderBody3(event, files2, opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS6),
+    files: [...files2],
+    // The command text is already redacted; scoring only reads its shape and the exit code.
+    signal: scoreShellCommand({
+      naturalKey: agentEventNaturalKey(event),
+      command,
+      ts: event.ts,
+      tsApprox: false,
+      exitCode: event.exitCode,
+      cwd: event.cwd,
+      durationMs: event.durationMs,
+      shell: event.agent
+    }),
+    provenance: "observed",
+    meta: {
+      // These keys match the shell collector's, so failure-fix and precheck read agent nodes unchanged.
+      command,
+      commandHash: event.commandHash,
+      // Agent-only: the shell collector has no `cd`-prefix habit to normalize.
+      execHash: event.execHash,
+      cwd: event.cwd,
+      exitCode: event.exitCode,
+      durationMs: event.durationMs,
+      tsApprox: false,
+      sourceTimestamp: event.ts,
+      shell: event.agent,
+      agent: event.agent,
+      agentSessionId: event.sessionId,
+      toolUseId: event.eventId,
+      outcome: event.outcome,
+      captureVia: "hook",
+      ...event.errorSignature ? { errorSignature: event.errorSignature } : {},
+      ...event.agentId ? { agentId: event.agentId } : {}
+    }
+  };
+}
+function collectAgentEvents(events, projectId, opts) {
+  const pendingEdits = /* @__PURE__ */ new Map();
+  const nodes = [];
+  for (const event of events) {
+    if (event.kind === "edit") {
+      if (!event.filePath || !isUnderRoot(event.filePath, opts.repoRoot, opts.platform)) continue;
+      const pending = pendingEdits.get(event.sessionId) ?? [];
+      const touch = toFileTouch(event.filePath, opts.repoRoot);
+      if (!pending.some((f) => f.path === touch.path)) pending.push(touch);
+      pendingEdits.set(event.sessionId, pending);
+      continue;
+    }
+    if (!event.command || !event.cwd || !isUnderRoot(event.cwd, opts.repoRoot, opts.platform)) continue;
+    const files2 = pendingEdits.get(event.sessionId) ?? [];
+    nodes.push(toAgentMemoryNode(event, files2, projectId, opts));
+    pendingEdits.delete(event.sessionId);
+  }
+  return nodes;
+}
+
 // src/cli/sync-lock.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 function lockPath(wsDir) {
-  return join11(wsDir, "sync.lock");
+  return join12(wsDir, "sync.lock");
 }
 function readOwner(path) {
   try {
@@ -5900,6 +6434,19 @@ async function syncShell(store, projectId, opts, repoRoot, config, log) {
     repoRoot,
     hookCursor: store.getSyncCursor(projectId, "shell:pwsh-hook")
   });
+  if (existsSync5(hookLogPath())) {
+    try {
+      const { linesChanged, legacyLines } = await sanitizeHookLog(hookLogPath());
+      if (linesChanged > 0) log(`  ${pc7.dim(`shell hook log: redacted ${linesChanged} line(s)`)}`);
+      if (legacyLines > 0) {
+        log(
+          `${pc7.yellow("shell")} ${legacyLines} hook-log line(s) were written by an outdated NexusMem shell hook that stores commands unredacted until a sync -- run \`nexusmem hook install\` again in each shell`
+        );
+      }
+    } catch (err) {
+      log(`${pc7.yellow("shell")} could not redact the hook log (${err.message}) -- run \`nexusmem scrub-secrets --yes\``);
+    }
+  }
   if (results.length === 0) {
     log(`${pc7.dim("shell")} no history source found on this machine`);
     return { totals, seen: 0 };
@@ -5917,6 +6464,25 @@ async function syncShell(store, projectId, opts, repoRoot, config, log) {
   }
   return { totals, seen };
 }
+var AGENT_SOURCE = "agent";
+async function syncAgent(store, projectId, repoRoot, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0, denied: 0 };
+  if (!config.sources.agent.enabled) {
+    log(`${pc7.dim("agent")} disabled in config`);
+    return { totals, seen: 0 };
+  }
+  const logPath = agentEventLogPath();
+  if (!existsSync5(logPath)) return { totals, seen: 0 };
+  const fromLine = Number(store.getSyncCursor(projectId, AGENT_SOURCE) ?? "0") || 0;
+  const { events, totalLines } = await readAgentEvents(logPath, fromLine);
+  const nodes = collectAgentEvents(events, projectId, { repoRoot, maxBodyChars: config.limits.maxBodyChars });
+  if (nodes.length > 0) {
+    addStats(totals, store.upsertNodes(nodes));
+    log(`  ${pc7.dim(`${AGENT_SOURCE}: ${nodes.length} agent action(s) read`)}`);
+  }
+  store.setSyncCursor(projectId, AGENT_SOURCE, String(totalLines));
+  return { totals, seen: nodes.length };
+}
 var CONVERSATION_SOURCE = "conversation:claude-code";
 function syncConversation(store, projectId, turns, config, log, forceEnabled) {
   const totals = { inserted: 0, updated: 0, unchanged: 0, denied: 0 };
@@ -5977,8 +6543,8 @@ async function syncDocs(store, projectId, repoRoot, config, log) {
     log(`${pc7.dim("docs")} disabled in config`);
     return { totals, seen: 0 };
   }
-  const { files, unreadable } = await readDocFiles(repoRoot, { include: config.sources.docs.include });
-  const nodes = collectDocFiles(files, projectId, { maxBodyChars: config.limits.maxBodyChars });
+  const { files: files2, unreadable } = await readDocFiles(repoRoot, { include: config.sources.docs.include });
+  const nodes = collectDocFiles(files2, projectId, { maxBodyChars: config.limits.maxBodyChars });
   if (nodes.length > 0) addStats(totals, store.upsertNodes(nodes));
   const pruned = store.pruneSourceNodes(
     projectId,
@@ -5987,12 +6553,12 @@ async function syncDocs(store, projectId, repoRoot, config, log) {
     { keepPaths: unreadable }
   );
   store.setSyncCursor(projectId, DOCS_SOURCE, `scanned:${nodes.length}`);
-  if (files.length === 0 && unreadable.length === 0) {
+  if (files2.length === 0 && unreadable.length === 0) {
     log(`${pc7.dim("docs")} no tracked .md files found`);
   } else {
     const prunedPart = pruned > 0 ? `, ${pc7.yellow(`${pruned} stale removed`)}` : "";
     const skippedPart = unreadable.length > 0 ? `, ${unreadable.length} unreadable (kept)` : "";
-    log(`  ${pc7.dim(`${DOCS_SOURCE}: ${nodes.length} section(s) from ${files.length} file(s)`)}${prunedPart}${pc7.dim(skippedPart)}`);
+    log(`  ${pc7.dim(`${DOCS_SOURCE}: ${nodes.length} section(s) from ${files2.length} file(s)`)}${prunedPart}${pc7.dim(skippedPart)}`);
   }
   return { totals, seen: nodes.length };
 }
@@ -6093,10 +6659,10 @@ async function runAutoContradictionCheck(store, config, projectId, providers) {
     maxJudgments: config.contradictions.maxPerSync,
     model: config.contradictions.model
   });
-  const open = store.countContradictionSuggestions(projectId);
-  if (fresh.length === 0 && open === 0) return "";
+  const open3 = store.countContradictionSuggestions(projectId);
+  if (fresh.length === 0 && open3 === 0) return "";
   const freshPart = fresh.length > 0 ? pc7.yellow(`${fresh.length} new`) : `${fresh.length} new`;
-  return `  ${pc7.dim("contradictions:")} ${freshPart}${pc7.dim(`, ${open} open suggestion(s) -- run`)} ${pc7.bold("nexusmem stale")} ${pc7.dim("for detail")}
+  return `  ${pc7.dim("contradictions:")} ${freshPart}${pc7.dim(`, ${open3} open suggestion(s) -- run`)} ${pc7.bold("nexusmem stale")} ${pc7.dim("for detail")}
 `;
 }
 async function runSync(opts) {
@@ -6124,8 +6690,7 @@ async function runSync(opts) {
       log(`${pc7.dim("rebuild")} dropped ${removed} existing node(s)`);
     }
     const staleProjectIds = store.listOtherProjectIds(projectId);
-    for (const staleId of staleProjectIds) {
-      const result = reconcileProjectId(store.raw, staleId, projectId);
+    for (const result of reconcileProjectIds(store.raw, staleProjectIds, projectId)) {
       const parts = [
         result.migrated > 0 ? `${result.migrated} migrated` : null,
         result.reassigned > 0 ? `${result.reassigned} reassigned` : null,
@@ -6135,7 +6700,7 @@ async function runSync(opts) {
       ].filter((part) => part !== null);
       if (parts.length > 0) {
         log(
-          `${pc7.yellow("reconciled")} previous project identity ${pc7.dim(staleId)} (remote URL likely changed): ${parts.join(", ")}`
+          `${pc7.yellow("reconciled")} previous project identity ${pc7.dim(result.oldProjectId)} (remote URL likely changed): ${parts.join(", ")}`
         );
       }
     }
@@ -6154,6 +6719,7 @@ async function runSync(opts) {
     const git2 = await syncGit(store, projectId, opts, repo, config, log);
     const diffs = await syncDiffs(store, projectId, opts, repo, config, log);
     const shell = await syncShell(store, projectId, opts, repo.root, config, log);
+    const agent = await syncAgent(store, projectId, repo.root, config, log);
     const conversationEnabled = opts.conversationOverride ?? config.sources.conversation.enabled;
     const turns = conversationEnabled || config.sources.session.enabled ? await collectClaudeCodeTranscripts(repo.root) : [];
     const conversation = syncConversation(store, projectId, turns, config, log, opts.conversationOverride);
@@ -6189,9 +6755,10 @@ async function runSync(opts) {
       slm: new OllamaChatProvider({ model: config.contradictions.model })
     }) : "";
     let linkLine = "";
-    if (opts.linkFailures) {
+    if (opts.linkFailures || agent.seen > 0) {
       const linkStats = correlateFailures(store, projectId);
-      linkLine = `  ${pc7.dim(`chains: ${linkStats.failuresExamined} failure(s) examined, ${linkStats.linkedByRetry} linked by retry, ${linkStats.linkedByDiscussion} by discussion`)}
+      const unexplained = linkStats.unexplainedRetries > 0 ? `, ${linkStats.unexplainedRetries} passed again with nothing edited (not linked)` : "";
+      linkLine = `  ${pc7.dim(`chains: ${linkStats.failuresExamined} failure(s) examined, ${linkStats.linkedByRetry} linked by retry, ${linkStats.linkedByDiscussion} by discussion${unexplained}`)}
 `;
     }
     store.markSynced(projectId);
@@ -6199,6 +6766,7 @@ async function runSync(opts) {
     addStats(totals, git2.totals);
     addStats(totals, diffs.totals);
     addStats(totals, shell.totals);
+    addStats(totals, agent.totals);
     addStats(totals, conversation.totals);
     addStats(totals, sessions.totals);
     addStats(totals, docs.totals);
@@ -6212,10 +6780,11 @@ async function runSync(opts) {
     const structurePart = config.sources.structure.enabled ? `, ${structure.edges} import edge(s)` : "";
     const githubEnabled = opts.githubOverride ?? config.sources.github.enabled;
     const githubPart = githubEnabled ? `, ${github.seen} github thread(s)` : "";
+    const agentPart = agent.seen > 0 ? `, ${agent.seen} agent action(s)` : "";
     const deniedPart = totals.denied > 0 ? `  ${pc7.red(`-${totals.denied} denied`)}` : "";
     out(
       [
-        `${pc7.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${sessionPart}${docsPart}${githubPart}${structurePart} in ${elapsed}s`,
+        `${pc7.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${agentPart}${conversationPart}${sessionPart}${docsPart}${githubPart}${structurePart} in ${elapsed}s`,
         `  ${pc7.green(`+${totals.inserted} new`)}  ${pc7.yellow(`~${totals.updated} updated`)}  ${pc7.dim(`=${totals.unchanged} unchanged`)}${deniedPart}`,
         `  ${pc7.dim(`${stats2.total} node(s) total across ${stats2.distinctFiles} file path(s)`)}`,
         ""
@@ -6786,10 +7355,10 @@ ${hottest.join("\n")}` : ""
 async function runScanConversation(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
-  const files = await listTranscriptFiles(repo.root);
+  const files2 = await listTranscriptFiles(repo.root);
   if (!opts.json) {
     process.stderr.write(
-      files.length ? `${pc12.dim("transcripts")} ${files.length} file(s) in ${claudeProjectTranscriptDir(repo.root)}
+      files2.length ? `${pc12.dim("transcripts")} ${files2.length} file(s) in ${claudeProjectTranscriptDir(repo.root)}
 
 ` : `${pc12.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
 `
@@ -6869,10 +7438,10 @@ import pc14 from "picocolors";
 async function runScanDocs(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
-  const { files, unreadable } = await readDocFiles(repo.root);
+  const { files: files2, unreadable } = await readDocFiles(repo.root);
   if (!opts.json) {
     process.stderr.write(
-      files.length ? `${pc14.dim("tracked .md files")} ${files.map((f) => f.path).join(", ")}
+      files2.length ? `${pc14.dim("tracked .md files")} ${files2.map((f) => f.path).join(", ")}
 
 ` : `${pc14.yellow("no tracked .md files found")}
 `
@@ -6883,7 +7452,7 @@ async function runScanDocs(opts) {
 `);
     }
   }
-  const nodes = collectDocFiles(files, projectId).filter((n) => n.signal >= opts.minSignal);
+  const nodes = collectDocFiles(files2, projectId).filter((n) => n.signal >= opts.minSignal);
   if (opts.json) {
     process.stdout.write(`${JSON.stringify(nodes, null, 2)}
 `);
@@ -6894,7 +7463,7 @@ async function runScanDocs(opts) {
   const approxTotal = approxTotalTokens(nodes);
   process.stderr.write(
     `
-${pc14.bold(String(nodes.length))} section(s) from ${files.length} file(s) above threshold  ${pc14.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+${pc14.bold(String(nodes.length))} section(s) from ${files2.length} file(s) above threshold  ${pc14.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
 `
   );
   return 0;
@@ -6944,14 +7513,14 @@ ${summarize2(nodes)}
 function formatNode4(node) {
   const sha = String(node.meta.shortSha ?? "").padEnd(9);
   const date = node.ts.slice(0, 10);
-  const files = Number(node.meta.filesChanged ?? 0);
+  const files2 = Number(node.meta.filesChanged ?? 0);
   const churn = `+${node.meta.insertions ?? 0}/-${node.meta.deletions ?? 0}`;
   return [
     formatSignal(node.signal, GIT_SIGNAL_BANDS),
     pc15.dim(date),
     pc15.magenta(sha),
     node.title,
-    pc15.dim(`(${files} file${files === 1 ? "" : "s"}, ${churn})`)
+    pc15.dim(`(${files2} file${files2 === 1 ? "" : "s"}, ${churn})`)
   ].join(" ");
 }
 
@@ -7154,30 +7723,1050 @@ ${pc19.bold(String(edges.length))} edge(s) from ${filesScanned} tracked ${TRACKE
   return 0;
 }
 
-// src/cli/commands/stale.ts
+// src/cli/commands/agent.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir7, readFile as readFile12, writeFile as writeFile7 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { dirname as dirname7, join as join15 } from "path";
 import pc20 from "picocolors";
-var STALE_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
-async function runStale(opts) {
-  const { projectId, ws } = await loadContext(opts.cwd);
-  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
-  const store = MemoryStore.open(ws.dbPath);
+
+// src/agent/capture-health.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname6, join as join13 } from "path";
+var DROP_REASONS = [
+  "unparsable-json",
+  "unsupported-event",
+  "unsupported-tool",
+  "missing-fields",
+  "write-failed",
+  "payload-too-large"
+];
+var DROP_FAMILIES = ["post-tool-use", "post-tool-use-failure", "session-start", "other"];
+var HEALTHY_WINDOW_MS = 24 * 60 * 60 * 1e3;
+function captureDropStatePath() {
+  return join13(globalWorkspaceDir(), "agent-capture-drops.json");
+}
+var isDropReason = (value) => DROP_REASONS.includes(value);
+var isDropFamily = (value) => DROP_FAMILIES.includes(value);
+function readDropState(path) {
   try {
-    if (opts.dismiss) {
-      const dismissed = store.dismissContradictionSuggestion(projectId, opts.dismiss);
-      out(
-        dismissed > 0 ? `${pc20.green("dismissed")} the contradiction suggestion for ${opts.dismiss} -- it will not resurface
-` : `${pc20.dim("no open contradiction suggestion")} for ${opts.dismiss} -- nothing to dismiss
-`
-      );
-      return 0;
-    }
-    const candidates = store.listStaleCandidates(projectId, { minAgeDays: opts.minAgeDays, limit: opts.limit });
-    if (candidates.length === 0) {
-      out(`${pc20.dim("no stale candidates")} -- no unconfirmed node older than the threshold lacks a successor
-`);
-      return 0;
-    }
-    let suggestions = [];
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function lastEvent(logPath) {
+  let raw;
+  try {
+    raw = readFileSync3(logPath, "utf8");
+  } catch (err) {
+    return err.code === "ENOENT" ? null : "unreadable";
+  }
+  const lines = raw.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    const event = parseAgentEventLine(lines[i]);
+    if (event) return { at: event.ts, kind: event.kind, outcome: event.outcome };
+  }
+  return lines.length > 0 ? "unreadable" : null;
+}
+function readCaptureStatus(opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const event = lastEvent(opts.logPath ?? agentEventLogPath());
+  const drop = readDropState(opts.dropStatePath ?? captureDropStatePath());
+  const lastDropAt = typeof drop.lastDropAt === "string" ? drop.lastDropAt : null;
+  const lastDropReason = isDropReason(drop.lastDropReason) ? drop.lastDropReason : null;
+  const lastDropFamily = isDropFamily(drop.lastDropFamily) ? drop.lastDropFamily : null;
+  const drops = typeof drop.drops === "number" && Number.isFinite(drop.drops) ? drop.drops : 0;
+  const base = { lastDropAt, lastDropReason, lastDropFamily, drops };
+  if (event === "unreadable") {
+    return { ...base, health: "unknown", lastEventAt: null, lastEventKind: null, lastEventOutcome: null };
+  }
+  const droppedRecently = lastDropAt !== null && now.getTime() - Date.parse(lastDropAt) <= HEALTHY_WINDOW_MS;
+  if (event === null) {
+    return {
+      ...base,
+      health: droppedRecently ? "degraded" : "never-observed",
+      lastEventAt: null,
+      lastEventKind: null,
+      lastEventOutcome: null
+    };
+  }
+  const captured = { lastEventAt: event.at, lastEventKind: event.kind, lastEventOutcome: event.outcome };
+  const eventAt = Date.parse(event.at);
+  if (Number.isNaN(eventAt)) return { ...base, ...captured, health: "unknown" };
+  if (droppedRecently && lastDropAt !== null && Date.parse(lastDropAt) > eventAt) {
+    return { ...base, ...captured, health: "degraded" };
+  }
+  return { ...base, ...captured, health: now.getTime() - eventAt <= HEALTHY_WINDOW_MS ? "healthy" : "stale" };
+}
+
+// src/agent/hook-command.ts
+import { fileURLToPath as fileURLToPath3 } from "url";
+var WINDOWS_PATH = /^(?:[A-Za-z]:[\\/]|\\\\)/;
+var quote = (path) => {
+  const p = WINDOWS_PATH.test(path) ? path.replace(/\\/g, "/") : path;
+  return `"${p.replace(/(["$`\\])/g, "\\$1")}"`;
+};
+function hookCommandPaths(command) {
+  return [...command.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => (m[1] ?? "").replace(/\\(.)/g, "$1"));
+}
+function agentHookCommands(node = process.execPath, captureScript = fileURLToPath3(new URL("../../dist/cli/agent-hook.js", import.meta.url)), cliScript = fileURLToPath3(new URL("../../dist/cli/index.js", import.meta.url))) {
+  return {
+    capture: `${quote(node)} ${quote(captureScript)}`,
+    recall: `${quote(node)} ${quote(cliScript)} agent recall --trigger failure`,
+    sessionStart: `${quote(node)} ${quote(cliScript)} agent session-start`
+  };
+}
+
+// src/agent/recall.ts
+var MAX_RECALL_CHARS = 1200;
+var MAX_PAST_FAILURES = 3;
+var SELECT_BY_HASH = `
+  SELECT n.id, n.ts, n.meta,
+         (SELECT group_concat(f.path) FROM node_files f WHERE f.node_id = n.id) AS paths
+  FROM nodes n
+  WHERE n.project_id = ?
+    AND n.kind = 'shell_command'
+    AND json_extract(n.meta, '$.execHash') = ?
+    AND json_extract(n.meta, '$.exitCode') IS NOT NULL
+    AND json_extract(n.meta, '$.exitCode') != 0
+  ORDER BY n.ts DESC
+  LIMIT ?`;
+var SELECT_RECENT_FAILURES = `
+  SELECT n.id, n.ts, n.meta, NULL AS paths
+  FROM nodes n
+  WHERE n.project_id = ?
+    AND n.kind = 'shell_command'
+    AND json_extract(n.meta, '$.exitCode') IS NOT NULL
+    AND json_extract(n.meta, '$.exitCode') != 0
+    AND n.ts >= ?
+  ORDER BY n.ts DESC
+  LIMIT 40`;
+var SELECT_BY_ID = `
+  SELECT n.id, n.ts, n.meta,
+         (SELECT group_concat(f.path) FROM node_files f WHERE f.node_id = n.id) AS paths
+  FROM nodes n WHERE n.id = ?`;
+var lookupNode = (store, id) => store.raw.prepare(SELECT_BY_ID).get(id);
+var REVERT_SUBJECT = /^revert(\([^)]*\))?[:!]|^revert\s+"/i;
+var SELECT_REVERT_OF = `
+  SELECT n.ts, n.title
+  FROM nodes n
+  WHERE n.project_id = ?
+    AND n.kind = 'git_commit'
+    AND n.title LIKE 'revert%'
+    AND n.ts_epoch > (SELECT ts_epoch FROM nodes WHERE id = ?)
+    AND EXISTS (
+      SELECT 1 FROM node_files a
+      JOIN node_files b ON b.path = a.path
+      WHERE a.node_id = n.id AND b.node_id = ?
+    )
+  ORDER BY n.ts_epoch ASC
+  LIMIT 3`;
+function revertOfFix(store, projectId, fixId) {
+  const rows = store.raw.prepare(SELECT_REVERT_OF).all(projectId, fixId, fixId);
+  return rows.find((row) => REVERT_SUBJECT.test(row.title)) ?? null;
+}
+var day = (ts) => ts.slice(0, 10);
+var files = (row) => row.paths ? row.paths.split(",").join(", ") : "";
+var fixFilesOf = (fix) => fix ? files(fix) : "";
+function describeAttempt(row) {
+  const changed = files(row);
+  return changed ? `${day(row.ts)}: failed after editing ${changed}` : `${day(row.ts)}: failed`;
+}
+function recallFailure(store, projectId, execHash) {
+  const db = store.raw;
+  const past = db.prepare(SELECT_BY_HASH).all(projectId, execHash, MAX_PAST_FAILURES);
+  if (past.length === 0) return null;
+  const lines = [];
+  let resolved = false;
+  let superseded = false;
+  let stale = false;
+  for (const row of past) {
+    lines.push(`- ${describeAttempt(row)}`);
+  }
+  const newestFailureTs = past[0].ts;
+  for (const row of past) {
+    const [fixId] = store.getLinkedNodeIds(row.id, RESOLVED_BY_RETRY);
+    if (!fixId) continue;
+    const fix = lookupNode(store, fixId);
+    if (!fix) continue;
+    const changed = files(fix);
+    const what = changed ? `fixed on ${day(fix.ts)} after editing ${changed}` : `fixed on ${day(fix.ts)}`;
+    const revert = revertOfFix(store, projectId, fixId);
+    const failedAgain = !revert && newestFailureTs > fix.ts;
+    if (revert) lines.push(`- ${what}, but that fix was reverted on ${day(revert.ts)} -- it no longer holds`);
+    else if (failedAgain) lines.push(`- ${what}, but it failed again on ${day(newestFailureTs)} -- that fix no longer holds`);
+    else lines.push(`- ${what}`);
+    superseded = Boolean(revert);
+    stale = failedAgain;
+    resolved = !revert && !failedAgain;
+    break;
+  }
+  if (!resolved && !superseded && !stale) lines.push("- no fix for it was ever recorded here");
+  const header = `NexusMem: this exact command has failed in this repository before (${past.length} time(s)).`;
+  let footer = "Previous attempts did not resolve it, so a different approach is likely needed.";
+  if (resolved) footer = "Check what changed in that fix before retrying the same approach.";
+  if (stale) footer = "That fix did not hold, so repeating it is unlikely to be enough -- check what changed since.";
+  if (superseded) footer = "That fix was reverted, so repeating it is unlikely to work -- check why it was backed out.";
+  return {
+    text: [header, ...lines, footer].join("\n").slice(0, MAX_RECALL_CHARS),
+    matched: past.length,
+    resolved,
+    superseded,
+    stale
+  };
+}
+var SELECT_UNCERTAIN_BY_HASH = `
+  SELECT n.id, n.ts, n.meta, NULL AS paths
+  FROM nodes n
+  WHERE n.project_id = ?
+    AND n.kind = 'shell_command'
+    AND json_extract(n.meta, '$.execHash') = ?
+    AND json_extract(n.meta, '$.outcome') = 'unknown'
+  ORDER BY n.ts DESC
+  LIMIT ?`;
+function recallUncertain(store, projectId, execHash) {
+  const past = store.raw.prepare(SELECT_UNCERTAIN_BY_HASH).all(projectId, execHash, MAX_PAST_FAILURES);
+  if (past.length === 0) return null;
+  const lines = past.map((row) => `- ${day(row.ts)}: ran here, but its exit status was hidden behind the filter it was piped into`);
+  const header = `NexusMem: this exact command has an undetermined outcome here before (${past.length} time(s)) -- it is piped into a filter (head/tail/tee) whose own exit status hides whether the command it fed actually passed.`;
+  const footer = "Capture the real status directly (e.g. read $? or PIPESTATUS before piping) if this run needs to be trusted.";
+  return {
+    text: [header, ...lines, footer].join("\n").slice(0, MAX_RECALL_CHARS),
+    matched: past.length
+  };
+}
+var displayCommand = (row) => JSON.parse(row.meta).command?.split(/\r?\n/)[0]?.trim() || void 0;
+function executionKey(row) {
+  const meta = JSON.parse(row.meta);
+  const command = displayCommand(row);
+  if (!command) return null;
+  if (typeof meta.execHash === "string") return `exec:${meta.execHash}`;
+  if (typeof meta.commandHash === "string") return `exec:${meta.commandHash}`;
+  if (meta.command.includes(REDACTION_MARK)) return `row:${row.id}`;
+  return `text:${command}`;
+}
+var MAX_DIGEST_CHARS = 600;
+var DIGEST_WINDOW_DAYS = 14;
+var MAX_DIGEST_COMMANDS = 3;
+var STATE_PRIORITY = { resolved: 0, stale: 1, superseded: 2, uncertain: 3, unresolved: 4 };
+function recallSessionStart(store, projectId, now = /* @__PURE__ */ new Date()) {
+  const since = new Date(now.getTime() - DIGEST_WINDOW_DAYS * 864e5).toISOString();
+  const rows = store.raw.prepare(SELECT_RECENT_FAILURES).all(projectId, since);
+  const byExecution = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const key = executionKey(row);
+    if (!key) continue;
+    const command = displayCommand(row);
+    const group = byExecution.get(key);
+    if (!group) byExecution.set(key, { command, rows: [row] });
+    else {
+      group.rows.push(row);
+      if (command.length < group.command.length) group.command = command;
+    }
+  }
+  if (byExecution.size === 0) return null;
+  const summaries = [];
+  for (const { command, rows: [newest, ...older] } of byExecution.values()) {
+    const [newestFixId] = store.getLinkedNodeIds(newest.id, RESOLVED_BY_RETRY);
+    if (newestFixId) {
+      const fix = lookupNode(store, newestFixId);
+      const revert = revertOfFix(store, projectId, newestFixId);
+      const fixFiles = fixFilesOf(fix);
+      summaries.push(
+        revert ? { command, newestTs: newest.ts, state: "superseded", fixTs: fix?.ts, fixFiles, revertTs: revert.ts } : { command, newestTs: newest.ts, state: "resolved", fixTs: fix?.ts, fixFiles }
+      );
+      continue;
+    }
+    const staleFixId = older.map((row) => store.getLinkedNodeIds(row.id, RESOLVED_BY_RETRY)[0]).find((id) => id !== void 0);
+    if (staleFixId) {
+      const fix = lookupNode(store, staleFixId);
+      summaries.push({ command, newestTs: newest.ts, state: "stale", fixTs: fix?.ts, fixFiles: fixFilesOf(fix) });
+      continue;
+    }
+    const [discussionId] = store.getLinkedNodeIds(newest.id, RESOLVED_BY_DISCUSSION);
+    if (discussionId) {
+      const discussion = lookupNode(store, discussionId);
+      summaries.push({ command, newestTs: newest.ts, state: "uncertain", fixTs: discussion?.ts });
+    } else {
+      summaries.push({ command, newestTs: newest.ts, state: "unresolved" });
+    }
+  }
+  summaries.sort((a, b) => STATE_PRIORITY[a.state] - STATE_PRIORITY[b.state] || (b.newestTs < a.newestTs ? -1 : 1));
+  const listed = summaries.slice(0, MAX_DIGEST_COMMANDS);
+  const lines = listed.map((s) => {
+    const editSuffix = s.fixFiles ? ` after editing ${s.fixFiles}` : "";
+    if (s.state === "resolved") return `- ${s.command} (failed here before, fixed ${day(s.fixTs)}${editSuffix})`;
+    if (s.state === "stale") {
+      return `- ${s.command} (fixed ${day(s.fixTs)}${editSuffix}, but failed again ${day(s.newestTs)} -- that fix no longer holds)`;
+    }
+    if (s.state === "superseded") {
+      return `- ${s.command} (fixed ${day(s.fixTs)}${editSuffix}, but that fix was reverted ${day(s.revertTs)} -- it no longer holds)`;
+    }
+    if (s.state === "uncertain") {
+      return `- ${s.command} failed ${day(s.newestTs)} -- possibly discussed around ${day(s.fixTs)}, not confirmed as a fix`;
+    }
+    return `- ${s.command} failed ${day(s.newestTs)} with no recorded fix`;
+  });
+  const more = summaries.length > listed.length ? ` and ${summaries.length - listed.length} other(s)` : "";
+  const counts = { resolved: 0, stale: 0, superseded: 0, uncertain: 0, unresolved: 0 };
+  for (const s of summaries) counts[s.state] += 1;
+  return {
+    text: [
+      `NexusMem: ${summaries.length} relevant command(s) from the last ${DIGEST_WINDOW_DAYS} days${more}:`,
+      ...lines,
+      "This history is searchable with the nexusmem MCP tools if one of them comes up."
+    ].join("\n").slice(0, MAX_DIGEST_CHARS),
+    ...counts
+  };
+}
+
+// src/agent/recall-state.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync4, rmdirSync, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join14 } from "path";
+var MAX_INJECTIONS_PER_SESSION = 5;
+var MAX_SESSIONS_KEPT = 20;
+function recallStatePath() {
+  return join14(globalWorkspaceDir(), "agent-recall-state.json");
+}
+function read(path) {
+  try {
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function shouldInject(sessionId, key, path = recallStatePath()) {
+  const session = read(path)[sessionId];
+  if (!session) return true;
+  return session.count < MAX_INJECTIONS_PER_SESSION && !session.keys.includes(key);
+}
+var LOCK_STALE_MS = 2e3;
+function acquireLock(path) {
+  const lockPath2 = `${path}.lock`;
+  try {
+    mkdirSync4(lockPath2);
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") return false;
+    try {
+      if (Date.now() - statSync(lockPath2).mtimeMs > LOCK_STALE_MS) {
+        rmdirSync(lockPath2);
+        mkdirSync4(lockPath2);
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseLock(path) {
+  try {
+    rmdirSync(`${path}.lock`);
+  } catch {
+  }
+}
+function claimInjection(sessionId, key, path = recallStatePath(), now = Date.now()) {
+  if (!acquireLock(path)) return false;
+  try {
+    const state = read(path);
+    const session = state[sessionId];
+    if (session && (session.count >= MAX_INJECTIONS_PER_SESSION || session.keys.includes(key))) return false;
+    const next = session ?? { count: 0, keys: [], at: now };
+    next.count += 1;
+    next.at = now;
+    if (!next.keys.includes(key)) next.keys.push(key);
+    state[sessionId] = next;
+    const pruned = Object.entries(state).sort(([, a], [, b]) => b.at - a.at).slice(0, MAX_SESSIONS_KEPT);
+    try {
+      writeFileSync3(path, JSON.stringify(Object.fromEntries(pruned)), { encoding: "utf8", mode: 384 });
+      return true;
+    } catch {
+      return false;
+    }
+  } finally {
+    releaseLock(path);
+  }
+}
+
+// src/adapters/claude-code/install.ts
+var CAPTURE_MATCHER = "Bash|Edit|Write|MultiEdit|NotebookEdit";
+var RECALL_MATCHER = "Bash";
+var RECALL_TIMEOUT_SECONDS = 5;
+function isNexusMemHook(command) {
+  const c = command.toLowerCase();
+  return c.includes("agent-hook.js") || /agent\s+(recall|session-start)/.test(c);
+}
+var HOOK_EVENTS = ["SessionStart", "PostToolUse", "PostToolUseFailure"];
+function matcherFor(commands, event) {
+  if (event === "SessionStart") {
+    return [{ hooks: [{ type: "command", command: commands.sessionStart, timeout: RECALL_TIMEOUT_SECONDS }] }];
+  }
+  const capture = {
+    matcher: CAPTURE_MATCHER,
+    hooks: [{ type: "command", command: commands.capture }]
+  };
+  return [
+    capture,
+    { matcher: RECALL_MATCHER, hooks: [{ type: "command", command: commands.recall, timeout: RECALL_TIMEOUT_SECONDS }] }
+  ];
+}
+function withoutOurs(entries) {
+  return entries.map((entry) => ({ ...entry, hooks: (entry.hooks ?? []).filter((h) => !isNexusMemHook(h.command ?? "")) })).filter((entry) => (entry.hooks?.length ?? 0) > 0);
+}
+function upsertAgentHooks(settings, commands) {
+  const hooks = { ...settings.hooks ?? {} };
+  for (const event of HOOK_EVENTS) {
+    hooks[event] = [...withoutOurs(hooks[event] ?? []), ...matcherFor(commands, event)];
+  }
+  return { ...settings, hooks };
+}
+function removeAgentHooks(settings) {
+  const hooks = { ...settings.hooks ?? {} };
+  let removed = 0;
+  for (const [event, entries] of Object.entries(hooks)) {
+    const before = entries.flatMap((e) => e.hooks ?? []).filter((h) => isNexusMemHook(h.command ?? "")).length;
+    removed += before;
+    const kept = withoutOurs(entries);
+    if (kept.length > 0) hooks[event] = kept;
+    else delete hooks[event];
+  }
+  const next = { ...settings, hooks };
+  if (Object.keys(hooks).length === 0) delete next.hooks;
+  return { settings: next, removed };
+}
+function agentHookStatus(settings, commands) {
+  const present = Object.values(settings.hooks ?? {}).flatMap((entries) => entries.flatMap((e) => e.hooks ?? [])).map((h) => h.command ?? "").filter(isNexusMemHook);
+  if (present.length === 0) return { installed: false, upToDate: false, commands: [] };
+  const expected = [commands.capture, commands.recall, commands.sessionStart];
+  return { installed: true, upToDate: expected.every((cmd) => present.includes(cmd)), commands: [...new Set(present)] };
+}
+
+// src/adapters/claude-code/payload.ts
+var AGENT = "claude-code";
+var EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var EXIT_CODE = /^Exit code (\d+)/;
+var str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
+var num = (v) => typeof v === "number" && Number.isFinite(v) ? v : null;
+var EXIT_ECHO = /^exit\s*[:=]\s*(\d+)\s*$/i;
+var EXIT_WRAPPER = /^([\s\S]*?);\s*echo\s+(?:"exit\s*[:=]\s*\$\?"|exit\s*[:=]\s*\$\?)\s*$/i;
+function echoesOwnExitStatus(command) {
+  const body = EXIT_WRAPPER.exec(command.trim())?.[1];
+  return body !== void 0 && body.trim().length > 0 && !/[|;\r\n]/.test(body);
+}
+var OPAQUE_FILTER_TAIL = /\|\s*(?:head|tail|tee)(?![A-Za-z0-9._-])[^|]*$/i;
+function pipesIntoOpaqueFilter(command) {
+  return OPAQUE_FILTER_TAIL.test(command.trim());
+}
+function classifyBashResult(hookOutcome, failed, error, recovered, command) {
+  if (failed) return { outcome: hookOutcome, exitCode: error?.exitCode ?? null };
+  if (recovered !== null) return { outcome: recovered === 0 ? "ok" : "fail", exitCode: recovered };
+  if (pipesIntoOpaqueFilter(command)) return { outcome: "unknown", exitCode: null };
+  return { outcome: hookOutcome, exitCode: 0 };
+}
+function recoverExitStatusFromOutput(command, stdout) {
+  if (!stdout || !echoesOwnExitStatus(command)) return null;
+  const lines = stdout.split(/\r?\n/).map((l) => l.trim());
+  let last = "";
+  for (let i = lines.length - 1; i >= 0; i -= 1) {
+    if (lines[i]) {
+      last = lines[i];
+      break;
+    }
+  }
+  const match = EXIT_ECHO.exec(last);
+  return match ? Number(match[1]) : null;
+}
+function parseError(error) {
+  const [first = "", ...rest] = error.split(/\r?\n/);
+  const match = EXIT_CODE.exec(first);
+  if (!match) return { exitCode: null, signature: error.trim() };
+  return { exitCode: Number(match[1]), signature: rest.join(" ").trim() };
+}
+function parseSessionStart(rawJson) {
+  let payload;
+  try {
+    payload = JSON.parse(rawJson.trim());
+  } catch {
+    return null;
+  }
+  if (typeof payload !== "object" || payload === null) return null;
+  const p = payload;
+  if (str(p.hook_event_name) !== "SessionStart") return null;
+  const sessionId = str(p.session_id);
+  const cwd = str(p.cwd);
+  if (!sessionId || !cwd) return null;
+  return { sessionId, cwd, source: str(p.source) ?? null };
+}
+var FAMILY_BY_EVENT = {
+  PostToolUse: "post-tool-use",
+  PostToolUseFailure: "post-tool-use-failure",
+  SessionStart: "session-start"
+};
+var familyOf = (event) => event ? FAMILY_BY_EVENT[event] ?? "other" : "other";
+function parseHookPayloadDetailed(rawJson, now) {
+  let payload;
+  try {
+    payload = JSON.parse(rawJson.trim());
+  } catch {
+    return { ok: false, reason: "unparsable-json", family: "other" };
+  }
+  if (typeof payload !== "object" || payload === null) return { ok: false, reason: "unparsable-json", family: "other" };
+  const p = payload;
+  const event = str(p.hook_event_name);
+  const family = familyOf(event);
+  const sessionId = str(p.session_id);
+  const eventId = str(p.tool_use_id);
+  const toolName = str(p.tool_name);
+  if (event !== "PostToolUse" && event !== "PostToolUseFailure") return { ok: false, reason: "unsupported-event", family };
+  if (!sessionId || !eventId || !toolName) return { ok: false, reason: "missing-fields", family };
+  const failed = event === "PostToolUseFailure";
+  const interrupted = failed && p.is_interrupt === true;
+  const outcome = interrupted ? "interrupted" : failed ? "fail" : "ok";
+  const base = {
+    agent: AGENT,
+    sessionId,
+    eventId,
+    ts: now,
+    cwd: str(p.cwd) ?? null,
+    outcome,
+    durationMs: num(p.duration_ms),
+    ...str(p.agent_id) ? { agentId: str(p.agent_id) } : {}
+  };
+  if (toolName === "Bash") {
+    const command = str(p.tool_input?.command);
+    if (!command) return { ok: false, reason: "missing-fields", family };
+    const error = failed ? parseError(str(p.error) ?? "") : null;
+    const recovered = failed ? null : recoverExitStatusFromOutput(command, str(p.tool_response?.stdout));
+    const draft = {
+      ...base,
+      kind: "command",
+      command,
+      ...classifyBashResult(outcome, failed, error, recovered, command),
+      ...error?.signature ? { errorSignature: error.signature } : {}
+    };
+    return { ok: true, event: redactAgentEvent(draft), family };
+  }
+  if (EDIT_TOOLS.has(toolName)) {
+    const filePath = str(p.tool_input?.file_path) ?? str(p.tool_input?.notebook_path);
+    if (!filePath) return { ok: false, reason: "missing-fields", family };
+    return { ok: true, event: redactAgentEvent({ ...base, kind: "edit", filePath, exitCode: null }), family };
+  }
+  return { ok: false, reason: "unsupported-tool", family };
+}
+
+// src/cli/commands/agent.ts
+function settingsPathFor(scope, cwd) {
+  return scope === "project" ? join15(cwd, ".claude", "settings.local.json") : join15(homedir4(), ".claude", "settings.json");
+}
+async function readSettings(path) {
+  let raw;
+  try {
+    raw = await readFile12(path, "utf8");
+  } catch {
+    return existsSync6(path) ? null : {};
+  }
+  try {
+    const parsed = JSON.parse(stripBom(raw));
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function writeSettings(path, settings) {
+  await mkdir7(dirname7(path), { recursive: true });
+  await writeFile7(path, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+}
+async function runAgentInstall(opts) {
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  const scope = opts.scope ?? "user";
+  const path = settingsPathFor(scope, opts.cwd);
+  const settings = await readSettings(path);
+  if (settings === null) {
+    out(`${pc20.red("refused")} ${path} exists but could not be parsed as JSON -- fix or move it first
+`);
+    return 1;
+  }
+  const commands = opts.commands ?? agentHookCommands();
+  await writeSettings(path, upsertAgentHooks(settings, commands));
+  out(
+    [
+      `${pc20.green("installed")} NexusMem agent hooks in ${path}`,
+      `  ${pc20.dim("captures")} commands and edits Claude Code makes, redacted, into this machine's agent log`,
+      `  ${pc20.dim("recalls")}  past failures of the same command, at the moment one fails again`,
+      `  ${pc20.dim("restart Claude Code for the hooks to take effect")}`,
+      // The README leads with `npx nexusmem`, and an install run that way
+      // writes the cache directory into the hook command. It works until npm
+      // clears the cache, after which the hook captures nothing and says
+      // nothing. Verified by clearing it.
+      ...isNpxCacheInstall(commands.capture) ? [
+        `  ${pc20.yellow("warning")}  this copy of NexusMem is npx's temporary cache, and the hooks now point into it`,
+        `  ${pc20.dim("         ")} they stop working when npm clears that cache -- install NexusMem first (npm i -g nexusmem), then run this again`
+      ] : [],
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+var printablePath = (path) => path.replace(/[\x00-\x1f\x7f-\x9f]/g, (c) => `\\x${c.charCodeAt(0).toString(16).padStart(2, "0")}`);
+function isNpxCacheInstall(command) {
+  return hookCommandPaths(command).some((p) => /[\\/]_npx[\\/]/.test(p));
+}
+async function runAgentRemove(opts) {
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  const path = settingsPathFor(opts.scope ?? "user", opts.cwd);
+  const { settings, removed } = removeAgentHooks(await readSettings(path) ?? {});
+  if (removed === 0) {
+    out(`${pc20.dim("nothing to remove")} no NexusMem agent hooks in ${path}
+`);
+    return 0;
+  }
+  await writeSettings(path, settings);
+  out(`${pc20.green("removed")} ${removed} NexusMem hook(s) from ${path}
+`);
+  return 0;
+}
+async function runAgentStatus(opts) {
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  const scope = opts.scope ?? "user";
+  const path = settingsPathFor(scope, opts.cwd);
+  const status = agentHookStatus(await readSettings(path) ?? {}, opts.commands ?? agentHookCommands());
+  const missing = [...new Set(status.commands.flatMap(hookCommandPaths))].filter((p) => !existsSync6(p));
+  const capture = readCaptureStatus();
+  const CAPTURE_LABEL = {
+    healthy: pc20.green("healthy") + pc20.dim(" -- an event was captured in the last 24h"),
+    stale: pc20.yellow("stale") + pc20.dim(" -- nothing captured in the last 24h, which is expected if no agent ran"),
+    degraded: pc20.yellow("degraded") + pc20.dim(" -- recent events were dropped, so some agent activity may be missing"),
+    "never-observed": pc20.yellow("never observed") + pc20.dim(" -- no event has been captured yet"),
+    unknown: pc20.yellow("unknown") + pc20.dim(" -- the event log could not be read")
+  };
+  out(
+    [
+      `${pc20.dim("settings  ")} ${path}`,
+      `${pc20.dim("installed ")} ${!status.installed ? pc20.yellow("no") : status.upToDate ? pc20.green("yes") : pc20.yellow("yes, but pointing at a different NexusMem -- run `nexusmem agent install` again")}`,
+      // Only when a path is genuinely absent: this must not fire on a healthy install.
+      ...missing.length > 0 ? [
+        `${pc20.dim("paths     ")} ${pc20.yellow(`${missing.length} path(s) in the installed hook do not exist here`)}`,
+        ...missing.map((p) => `${pc20.dim("          ")} ${printablePath(p)}`),
+        `${pc20.dim("          ")} ${pc20.dim("reinstall from the environment Claude Code runs in")}`
+      ] : [],
+      `${pc20.dim("capture   ")} ${CAPTURE_LABEL[capture.health]}`,
+      ...capture.lastEventAt ? [`${pc20.dim("last event")} ${capture.lastEventAt} ${pc20.dim(`(${capture.lastEventKind}, ${capture.lastEventOutcome})`)}`] : [],
+      // Only when it happened: a healthy install should print nothing about drops.
+      ...capture.drops > 0 ? [
+        `${pc20.dim("drops     ")} ${capture.drops} ${pc20.dim(
+          `(last: ${capture.lastDropReason ?? "unrecognised"} from ${capture.lastDropFamily ?? "unrecognised"} at ${capture.lastDropAt})`
+        )}`
+      ] : [],
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+function spawnBackgroundSync(repoRoot) {
+  const cli = process.argv[1];
+  if (!cli) return;
+  spawn2(process.execPath, [cli, "sync", "--auto", "--quiet", "-C", repoRoot], {
+    detached: true,
+    stdio: "ignore"
+  }).unref();
+}
+async function runAgentSessionStart(opts = {}) {
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  try {
+    const payload = parseSessionStart(opts.input ?? await readStdin());
+    if (!payload) return 0;
+    const repo = await readRepoInfo(payload.cwd);
+    const ws = resolveWorkspace(repo.root);
+    if (!existsSync6(ws.dbPath) || !existsSync6(ws.configPath)) return 0;
+    (opts.startSync ?? spawnBackgroundSync)(repo.root);
+    const { projectId } = await readConfig(ws);
+    const store = MemoryStore.open(ws.dbPath);
+    let digest;
+    try {
+      digest = recallSessionStart(store, projectId);
+    } finally {
+      store.close();
+    }
+    if (!digest) return 0;
+    out(`${digest.text}
+`);
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk2 of process.stdin) chunks.push(chunk2);
+  return Buffer.concat(chunks).toString("utf8");
+}
+var HOOK_EVENT_BY_FAMILY = {
+  "post-tool-use": "PostToolUse",
+  "post-tool-use-failure": "PostToolUseFailure"
+};
+async function runAgentRecall(opts = {}) {
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  try {
+    const raw = opts.input ?? await readStdin();
+    const parsed = parseHookPayloadDetailed(raw, (/* @__PURE__ */ new Date()).toISOString());
+    if (!parsed.ok) return 0;
+    const event = parsed.event;
+    if (event.kind !== "command" || event.outcome !== "fail" && event.outcome !== "unknown" || !event.execHash || !event.cwd) return 0;
+    const hookEventName = HOOK_EVENT_BY_FAMILY[parsed.family];
+    if (!hookEventName) return 0;
+    if (!shouldInject(event.sessionId, event.execHash)) return 0;
+    const repo = await readRepoInfo(event.cwd);
+    const ws = resolveWorkspace(repo.root);
+    if (!existsSync6(ws.dbPath) || !existsSync6(ws.configPath)) return 0;
+    const { projectId } = await readConfig(ws);
+    const store = MemoryStore.open(ws.dbPath);
+    let recall;
+    try {
+      recall = event.outcome === "fail" ? recallFailure(store, projectId, event.execHash) : recallUncertain(store, projectId, event.execHash);
+    } finally {
+      store.close();
+    }
+    if (!recall) return 0;
+    if (!claimInjection(event.sessionId, event.execHash)) return 0;
+    out(
+      `${JSON.stringify({
+        hookSpecificOutput: { hookEventName, additionalContext: recall.text }
+      })}
+`
+    );
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/cli/commands/scrub-secrets.ts
+import { existsSync as existsSync7 } from "fs";
+import { dirname as dirname9 } from "path";
+import pc21 from "picocolors";
+
+// src/store/scrub.ts
+import { chmod as chmod2, open as open2, readdir as readdir2, rm } from "fs/promises";
+import { basename as basename4, dirname as dirname8, join as join16 } from "path";
+import Database2 from "better-sqlite3";
+var KIND_PROFILES = {
+  shell_command: "all",
+  conversation_turn: "all",
+  session_summary: "all",
+  code_diff: "high-confidence"
+};
+var SCRUB_KINDS = Object.keys(KIND_PROFILES);
+var ScrubRaceError = class extends Error {
+};
+var ScrubBackupError = class extends Error {
+};
+function scrubMeta(kind, raw) {
+  let meta;
+  try {
+    meta = JSON.parse(raw);
+  } catch {
+    return redact(raw, KIND_PROFILES[kind]).text;
+  }
+  if (typeof meta !== "object" || meta === null) return raw;
+  const m = meta;
+  let changed = false;
+  if (kind === "shell_command" && typeof m.command === "string") {
+    const command = redact(m.command).text;
+    if (command !== m.command) {
+      if (typeof m.commandHash !== "string") m.commandHash = sha256Hex(m.command).slice(0, 12);
+      m.command = command;
+      changed = true;
+    }
+  }
+  if (kind === "conversation_turn" && typeof m.heading === "string") {
+    const heading = redact(m.heading).text;
+    if (heading !== m.heading) {
+      m.heading = heading;
+      changed = true;
+    }
+  }
+  return changed ? JSON.stringify(m) : raw;
+}
+function hasTable(db, name) {
+  return db.prepare(`SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name) !== void 0;
+}
+function plan(db) {
+  const byKind = Object.fromEntries(SCRUB_KINDS.map((k) => [k, { scanned: 0, changed: 0 }]));
+  const rows = [];
+  const select = db.prepare(
+    `SELECT rowid, kind, title, body, meta FROM nodes WHERE kind IN (${SCRUB_KINDS.map(() => "?").join(", ")})`
+  );
+  for (const row of select.iterate(...SCRUB_KINDS)) {
+    const profile = KIND_PROFILES[row.kind];
+    const title = redact(row.title, profile).text;
+    const body = redact(row.body, profile).text;
+    const meta = scrubMeta(row.kind, row.meta);
+    byKind[row.kind].scanned += 1;
+    if (title === row.title && body === row.body && meta === row.meta) continue;
+    byKind[row.kind].changed += 1;
+    rows.push({ rowid: row.rowid, title, body, meta, textChanged: title !== row.title || body !== row.body });
+  }
+  const reasons = [];
+  if (hasTable(db, "contradiction_checks")) {
+    const select2 = db.prepare("SELECT rowid, reason FROM contradiction_checks WHERE reason IS NOT NULL");
+    for (const r of select2.iterate()) {
+      const reason = redact(r.reason).text;
+      if (reason !== r.reason) reasons.push({ rowid: r.rowid, reason });
+    }
+  }
+  return { byKind, rows, reasons };
+}
+async function listBackups(dbPath) {
+  const prefix = `${basename4(dbPath)}.backup-`;
+  try {
+    return (await readdir2(dirname8(dbPath))).filter((name) => name.startsWith(prefix)).sort().map((name) => join16(dirname8(dbPath), name));
+  } catch {
+    return [];
+  }
+}
+function purgeRemnants(db) {
+  db.exec(`INSERT INTO nodes_fts (nodes_fts) VALUES ('rebuild')`);
+  try {
+    db.exec("VACUUM");
+  } catch (err) {
+    if (String(err.code ?? "").startsWith("SQLITE_BUSY")) return false;
+    throw err;
+  }
+  const [checkpoint] = db.pragma("wal_checkpoint(TRUNCATE)");
+  return checkpoint?.busy === 0;
+}
+async function scrubDatabase(dbPath, opts) {
+  const existingBackups = await listBackups(dbPath);
+  const base = { dbPath, existingBackups, embeddingsDropped: 0, reembedded: 0, embeddingsPending: 0 };
+  if (!opts.apply) {
+    const db2 = new Database2(dbPath, { readonly: true, fileMustExist: true });
+    try {
+      const p = plan(db2);
+      return {
+        ...base,
+        applied: false,
+        byKind: p.byKind,
+        rowsChanged: p.rows.length,
+        contradictionReasonsChanged: p.reasons.length,
+        backupPath: null,
+        remnantsPurged: null
+      };
+    } finally {
+      db2.close();
+    }
+  }
+  const store = MemoryStore.open(dbPath);
+  const db = store.raw;
+  try {
+    let backupPath = null;
+    const first = plan(db);
+    if (first.rows.length + first.reasons.length > 0) {
+      const stamp = (opts.now ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      backupPath = `${dbPath}.backup-${stamp}-pre-scrub-secrets`;
+      await (await open2(backupPath, "wx", 384)).close();
+      await db.backup(backupPath);
+      try {
+        await (opts.protectBackup ?? ((path) => chmod2(path, 384)))(backupPath);
+      } catch (err) {
+        const protectMessage = err.message;
+        try {
+          await (opts.removeBackup ?? ((path) => rm(path, { force: true })))(backupPath);
+        } catch (cleanupErr) {
+          throw new ScrubBackupError(
+            `could not restrict permissions on the backup (${protectMessage}) nor remove it (${cleanupErr.message}) -- nothing was scrubbed, but ${backupPath} still holds the unredacted data; delete it`
+          );
+        }
+        throw new ScrubBackupError(`could not restrict permissions on the backup (${protectMessage}) -- nothing was scrubbed`);
+      }
+    }
+    const updateNode = db.prepare("UPDATE nodes SET title = ?, body = ?, meta = ? WHERE rowid = ?");
+    const dropVector = db.prepare("DELETE FROM nodes_vec WHERE rowid = ?");
+    const updateReason = db.prepare("UPDATE contradiction_checks SET reason = ? WHERE rowid = ?");
+    const { applied, dropped } = db.transaction(() => {
+      const p = plan(db);
+      if (!backupPath && p.rows.length + p.reasons.length > 0) {
+        throw new ScrubRaceError("the database changed while it was being scrubbed -- nothing was modified; re-run");
+      }
+      let dropped2 = 0;
+      for (const c of p.rows) {
+        updateNode.run(c.title, c.body, c.meta, c.rowid);
+        if (c.textChanged) dropped2 += dropVector.run(BigInt(c.rowid)).changes;
+      }
+      for (const r of p.reasons) updateReason.run(r.reason, r.rowid);
+      return { applied: p, dropped: dropped2 };
+    })();
+    let reembedded = 0;
+    let pending = dropped;
+    if (opts.embeddingProvider && dropped > 0) {
+      const changedRowids = applied.rows.filter((c) => c.textChanged).map((c) => c.rowid);
+      const projects = db.prepare(`SELECT DISTINCT project_id AS p FROM nodes WHERE rowid IN (${changedRowids.map(() => "?").join(", ")})`).all(...changedRowids);
+      pending = 0;
+      try {
+        for (const { p } of projects) {
+          const r = await embedPendingNodes(store, opts.embeddingProvider, p);
+          reembedded += r.embedded;
+          pending += r.remaining;
+        }
+      } catch {
+        pending = projects.reduce((sum, { p }) => sum + store.countNodesNeedingEmbedding(p), 0);
+      }
+    }
+    const remnantsPurged = purgeRemnants(db);
+    return {
+      ...base,
+      applied: true,
+      byKind: applied.byKind,
+      rowsChanged: applied.rows.length,
+      contradictionReasonsChanged: applied.reasons.length,
+      embeddingsDropped: dropped,
+      reembedded,
+      // Reported as measured: clamping this to the rows scrub changed made a project with
+      // an embedding backlog look finished when it was not.
+      embeddingsPending: pending,
+      backupPath,
+      remnantsPurged
+    };
+  } finally {
+    store.close();
+  }
+}
+
+// src/cli/commands/scrub-secrets.ts
+async function runScrubSecrets(opts) {
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  let incomplete = false;
+  const logPath = hookLogPath();
+  out(`${pc21.bold("shell hook log")} ${logPath}
+`);
+  if (!existsSync7(logPath)) {
+    out(`  ${pc21.dim("not present on this machine")}
+`);
+  } else {
+    try {
+      const { linesChanged, legacyLines } = await sanitizeHookLog(logPath, { dryRun: !opts.yes });
+      out(`  ${linesChanged} line(s) ${opts.yes ? "redacted" : "to redact"}
+`);
+      if (legacyLines > 0) {
+        out(
+          `  ${pc21.yellow(`${legacyLines} line(s) came from an outdated shell hook`)} that writes commands unredacted -- run \`nexusmem hook install\` again in each shell (see \`nexusmem hook status\`)
+`
+        );
+      }
+    } catch (err) {
+      incomplete = true;
+      out(`  ${pc21.red("could not redact the hook log")}: ${err.message}
+`);
+    }
+  }
+  const dbPaths = opts.allProjects ? [...new Set((await readLiveRegistry()).entries.map((e) => e.dbPath))] : [resolveWorkspace((await readRepoInfo(opts.cwd)).root).dbPath];
+  for (const dbPath of dbPaths) {
+    out(`
+${pc21.bold(dbPath)}
+`);
+    if (!existsSync7(dbPath)) {
+      out(`  ${pc21.dim("no database -- nothing to scrub")}
+`);
+      continue;
+    }
+    const lock = opts.yes ? acquireSyncLock(dirname9(dbPath)) : null;
+    if (opts.yes && !lock) {
+      incomplete = true;
+      out(`  ${pc21.yellow("a background sync is using this database -- re-run when it finishes")}
+`);
+      continue;
+    }
+    try {
+      const report = await scrubDatabase(dbPath, {
+        apply: opts.yes,
+        embeddingProvider: opts.yes && opts.embed ? new OllamaEmbeddingProvider() : null
+      });
+      printReport(report, out);
+      if (report.remnantsPurged === false) incomplete = true;
+    } catch (err) {
+      incomplete = true;
+      out(`  ${pc21.red("scrub failed")}: ${err.message}
+`);
+    } finally {
+      lock?.release();
+    }
+  }
+  if (!opts.yes) {
+    out(
+      `
+${pc21.bold("Dry run")}: nothing was changed. Re-run with --yes to back up each database, redact it in place, drop and re-embed stale vectors, rebuild the FTS index, VACUUM, and truncate the WAL.
+`
+    );
+  }
+  return incomplete ? 1 : 0;
+}
+function printReport(r, out) {
+  for (const kind of SCRUB_KINDS) {
+    const { scanned, changed } = r.byKind[kind];
+    out(`  ${kind.padEnd(22)} ${String(scanned).padStart(6)} scanned  ${changed} ${r.applied ? "redacted" : "to redact"}
+`);
+  }
+  out(`  ${"contradiction reasons".padEnd(22)} ${" ".repeat(14)}${r.contradictionReasonsChanged} ${r.applied ? "redacted" : "to redact"}
+`);
+  if (r.applied) {
+    if (r.backupPath) {
+      out(`  ${pc21.bold("backup")}  ${r.backupPath}
+`);
+      out(
+        `  ${pc21.yellow("WARNING")} that backup was taken BEFORE redaction and still contains every secret removed here. Verify this database, then delete the backup yourself -- NexusMem never deletes backups.
+`
+      );
+    } else {
+      out(`  ${pc21.dim("no row needed redaction -- no backup taken")}
+`);
+    }
+    if (r.embeddingsDropped > 0) {
+      out(
+        `  dropped ${r.embeddingsDropped} stale embedding(s), re-embedded ${r.reembedded}` + (r.embeddingsPending > 0 ? `; ${r.embeddingsPending} still pending (the next \`nexusmem sync\` embeds them)` : "") + "\n"
+      );
+    }
+    out(
+      r.remnantsPurged ? `  FTS index rebuilt, database VACUUMed, WAL truncated
+` : `  ${pc21.yellow("on-disk remnants NOT purged")}: the rows are redacted, but another process (MCP server, VS Code extension, a running sync) has this database open, which blocks VACUUM / WAL truncation. Close it and re-run \`nexusmem scrub-secrets --yes\`.
+`
+    );
+  }
+  if (r.existingBackups.length > 0) {
+    out(`  ${pc21.yellow("older backups")} (may hold unredacted secrets; NexusMem never deletes them):
+`);
+    for (const path of r.existingBackups) out(`    ${path}
+`);
+  }
+}
+
+// src/cli/commands/stale.ts
+import pc22 from "picocolors";
+var STALE_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
+async function runStale(opts) {
+  const { projectId, ws } = await loadContext(opts.cwd);
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    if (opts.dismiss) {
+      const dismissed = store.dismissContradictionSuggestion(projectId, opts.dismiss);
+      out(
+        dismissed > 0 ? `${pc22.green("dismissed")} the contradiction suggestion for ${opts.dismiss} -- it will not resurface
+` : `${pc22.dim("no open contradiction suggestion")} for ${opts.dismiss} -- nothing to dismiss
+`
+      );
+      return 0;
+    }
+    const candidates = store.listStaleCandidates(projectId, { minAgeDays: opts.minAgeDays, limit: opts.limit });
+    if (candidates.length === 0) {
+      out(`${pc22.dim("no stale candidates")} -- no unconfirmed node older than the threshold lacks a successor
+`);
+      return 0;
+    }
+    let suggestions = [];
     if (opts.checkContradictions) {
       suggestions = await checkContradictions(
         store,
@@ -7195,15 +8784,15 @@ async function runStale(opts) {
     for (const s of suggestions) byCandidateId.set(s.candidateId, s);
     out(
       [
-        `${pc20.bold(String(candidates.length))} stale candidate(s) -- oldest first, none of these were changed:`,
+        `${pc22.bold(String(candidates.length))} stale candidate(s) -- oldest first, none of these were changed:`,
         ...candidates.map((c) => {
-          const line = `  ${pc20.dim(c.id)} ${pc20.yellow(`${c.ageDays}d old`)} [${c.kind}] ${c.title}`;
+          const line = `  ${pc22.dim(c.id)} ${pc22.yellow(`${c.ageDays}d old`)} [${c.kind}] ${c.title}`;
           const hit = byCandidateId.get(c.id);
           return hit ? `${line}
-    ${pc20.red("likely superseded by")} ${pc20.dim(hit.againstId)} ${hit.againstTitle} -- ${hit.reason}` : line;
+    ${pc22.red("likely superseded by")} ${pc22.dim(hit.againstId)} ${hit.againstTitle} -- ${hit.reason}` : line;
         }),
         "",
-        `run ${pc20.bold("nexusmem mark-stale <id> --supersedes <newId>")} on any that are actually wrong`
+        `run ${pc22.bold("nexusmem mark-stale <id> --supersedes <newId>")} on any that are actually wrong`
       ].join("\n").concat("\n")
     );
     return 0;
@@ -7213,10 +8802,10 @@ async function runStale(opts) {
 }
 
 // src/cli/commands/status.ts
-import { basename as basename4, join as join12 } from "path";
-import { statSync } from "fs";
-import { readFile as readFile11 } from "fs/promises";
-import pc21 from "picocolors";
+import { basename as basename5, join as join17 } from "path";
+import { statSync as statSync2 } from "fs";
+import { readFile as readFile13 } from "fs/promises";
+import pc23 from "picocolors";
 function daySpan(oldest, newest) {
   const oldestDay = Date.parse(oldest.slice(0, 10));
   const newestDay = Date.parse(newest.slice(0, 10));
@@ -7234,7 +8823,7 @@ function buildShareText(repo, stats2, chains) {
     (p) => !p.startsWith("0 ")
   );
   const lines = [
-    `NexusMem has been watching ${basename4(repo.root)} for ${days} day(s):`,
+    `NexusMem has been watching ${basename5(repo.root)} for ${days} day(s):`,
     `  ${stats2.total} memories${parts.length ? ` (${parts.join(", ")})` : ""}`
   ];
   if (chains.failuresTotal) {
@@ -7250,7 +8839,7 @@ function humanBytes(bytes) {
 }
 function fileSize(path) {
   try {
-    return statSync(path).size;
+    return statSync2(path).size;
   } catch {
     return 0;
   }
@@ -7275,7 +8864,7 @@ async function getShellHookStatus(injected) {
 }
 async function readLastAutoSync(repoRoot) {
   try {
-    const raw = await readFile11(join12(repoRoot, STATE_PATH), "utf8");
+    const raw = await readFile13(join17(repoRoot, STATE_PATH), "utf8");
     return parsePostCommitSyncState(raw);
   } catch {
     return null;
@@ -7311,46 +8900,46 @@ async function runStatus(opts) {
       postCommitGitHookStatus(postCommitTarget)
     ]);
     const now = (opts.now ?? Date.now)();
-    const hooksPathNote2 = (target) => target.hooksPathConfig ? pc21.dim(` (core.hooksPath=${target.hooksPathConfig})`) : "";
-    const installedLabel = (installed) => installed ? pc21.green("installed") : pc21.yellow("not installed");
-    const lastAutoSyncLabel = lastAutoSync ? `${lastAutoSync.ok ? pc21.green("ok") : pc21.red(`FAILED (exit ${lastAutoSync.exitCode})`)} ${pc21.dim(relativeTime(Date.parse(lastAutoSync.ts), now))}` : postCommitStatus.installed ? pc21.dim("never (or hook predates this field -- reinstall with `nexusmem hook git-post install`)") : pc21.dim("n/a -- hook not installed");
+    const hooksPathNote2 = (target) => target.hooksPathConfig ? pc23.dim(` (core.hooksPath=${target.hooksPathConfig})`) : "";
+    const installedLabel = (installed) => installed ? pc23.green("installed") : pc23.yellow("not installed");
+    const lastAutoSyncLabel = lastAutoSync ? `${lastAutoSync.ok ? pc23.green("ok") : pc23.red(`FAILED (exit ${lastAutoSync.exitCode})`)} ${pc23.dim(relativeTime(Date.parse(lastAutoSync.ts), now))}` : postCommitStatus.installed ? pc23.dim("never (or hook predates this field -- reinstall with `nexusmem hook git-post install`)") : pc23.dim("n/a -- hook not installed");
     const hooksLines = [
-      pc21.dim("hooks"),
-      `    ${pc21.dim(`shell (${shellHook?.shell ?? "?"})`.padEnd(23))} ${shellHook ? installedLabel(shellHook.installed) : pc21.dim("unknown -- could not detect this machine\u2019s shell profile")}`,
-      `    ${pc21.dim("git pre-commit".padEnd(23))} ${installedLabel(preCommitStatus.installed)}${hooksPathNote2(preCommitTarget)}`,
-      `    ${pc21.dim("git post-commit".padEnd(23))} ${installedLabel(postCommitStatus.installed)}${hooksPathNote2(postCommitTarget)}`,
-      `    ${pc21.dim("last auto-sync".padEnd(23))} ${lastAutoSyncLabel}`
+      pc23.dim("hooks"),
+      `    ${pc23.dim(`shell (${shellHook?.shell ?? "?"})`.padEnd(23))} ${shellHook ? installedLabel(shellHook.installed) : pc23.dim("unknown -- could not detect this machine\u2019s shell profile")}`,
+      `    ${pc23.dim("git pre-commit".padEnd(23))} ${installedLabel(preCommitStatus.installed)}${hooksPathNote2(preCommitTarget)}`,
+      `    ${pc23.dim("git post-commit".padEnd(23))} ${installedLabel(postCommitStatus.installed)}${hooksPathNote2(postCommitTarget)}`,
+      `    ${pc23.dim("last auto-sync".padEnd(23))} ${lastAutoSyncLabel}`
     ];
     const dbBytes = fileSize(ws.dbPath) + fileSize(`${ws.dbPath}-wal`);
     const kinds = Object.entries(stats2.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
-    const staleProjectWarning = otherProjectIds.length ? `${pc21.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc21.bold(
+    const staleProjectWarning = otherProjectIds.length ? `${pc23.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc23.bold(
       "nexusmem sync --prune-source <name>"
     )} to remove stale source data` : "";
     out(
       [
-        `${pc21.dim("repo    ")} ${repo.root}`,
-        `${pc21.dim("branch  ")} ${repo.branch ?? pc21.yellow("(detached)")}`,
-        `${pc21.dim("project ")} ${pc21.cyan(projectId)}`,
-        `${pc21.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc21.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
-        `${pc21.dim("database")} ${ws.dbPath} ${pc21.dim(`(${humanBytes(dbBytes)})`)}`,
+        `${pc23.dim("repo    ")} ${repo.root}`,
+        `${pc23.dim("branch  ")} ${repo.branch ?? pc23.yellow("(detached)")}`,
+        `${pc23.dim("project ")} ${pc23.cyan(projectId)}`,
+        `${pc23.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc23.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
+        `${pc23.dim("database")} ${ws.dbPath} ${pc23.dim(`(${humanBytes(dbBytes)})`)}`,
         staleProjectWarning,
         "",
-        `${pc21.bold(String(stats2.total))} node(s)${stats2.total ? ` ${pc21.dim(`${stats2.oldest?.slice(0, 10)} .. ${stats2.newest?.slice(0, 10)}`)}` : ""}`,
+        `${pc23.bold(String(stats2.total))} node(s)${stats2.total ? ` ${pc23.dim(`${stats2.oldest?.slice(0, 10)} .. ${stats2.newest?.slice(0, 10)}`)}` : ""}`,
         ...kinds,
-        stats2.total ? `    ${pc21.dim(`${stats2.distinctFiles} distinct file path(s)`)}` : "",
+        stats2.total ? `    ${pc23.dim(`${stats2.distinctFiles} distinct file path(s)`)}` : "",
         "",
-        sources.length ? pc21.dim("sources") : pc21.yellow("no sources synced yet"),
+        sources.length ? pc23.dim("sources") : pc23.yellow("no sources synced yet"),
         ...sources.map((s) => {
           const when = s.lastRunAt ? new Date(s.lastRunAt).toISOString().slice(0, 16).replace("T", " ") : "never";
           const cursorLabel = s.source === "git" ? s.cursor?.slice(0, 7) ?? "-" : s.cursor ?? "-";
-          return `    ${s.source.padEnd(14)} ${pc21.dim(`last run ${when}`)}  ${pc21.dim(`cursor ${cursorLabel}`)}`;
+          return `    ${s.source.padEnd(14)} ${pc23.dim(`last run ${when}`)}  ${pc23.dim(`cursor ${cursorLabel}`)}`;
         }),
         "",
-        gitCursor && gitCursor !== repo.head ? `${pc21.yellow("git behind HEAD")} \u2014 run ${pc21.bold("nexusmem sync")}` : "",
-        chains.failuresTotal ? `${pc21.dim("chains  ")} ${pc21.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc21.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc21.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
-        structure.edges ? `${pc21.dim("structure")} ${pc21.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : "",
-        staleCount ? `${pc21.dim("aging   ")} ${pc21.bold(String(staleCount))} unconfirmed node(s) worth a look \u2014 run ${pc21.bold("nexusmem stale")}` : "",
-        flaggedCount ? `${pc21.dim("flagged ")} ${pc21.bold(String(flaggedCount))} likely-superseded node(s) awaiting review \u2014 run ${pc21.bold("nexusmem stale")} for detail` : "",
+        gitCursor && gitCursor !== repo.head ? `${pc23.yellow("git behind HEAD")} \u2014 run ${pc23.bold("nexusmem sync")}` : "",
+        chains.failuresTotal ? `${pc23.dim("chains  ")} ${pc23.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc23.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc23.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
+        structure.edges ? `${pc23.dim("structure")} ${pc23.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : "",
+        staleCount ? `${pc23.dim("aging   ")} ${pc23.bold(String(staleCount))} unconfirmed node(s) worth a look \u2014 run ${pc23.bold("nexusmem stale")}` : "",
+        flaggedCount ? `${pc23.dim("flagged ")} ${pc23.bold(String(flaggedCount))} likely-superseded node(s) awaiting review \u2014 run ${pc23.bold("nexusmem stale")} for detail` : "",
         "",
         ...hooksLines
       ].filter((line) => line !== "").join("\n").concat("\n")
@@ -7375,7 +8964,7 @@ function guard(run) {
       process.exitCode = await run();
     } catch (err) {
       if (isExpected(err)) {
-        process.stderr.write(`${pc22.red("error")} ${err.message}
+        process.stderr.write(`${pc24.red("error")} ${err.message}
 `);
         process.exitCode = 1;
         return;
@@ -7488,6 +9077,30 @@ program.command("forget").description(
     })
   )()
 );
+program.command("agent").description("Manage the opt-in Claude Code hooks that record what the agent tried, and recall past failures").addCommand(
+  new Command("install").description("Install (or update) NexusMem's hooks in Claude Code settings").option("-C, --cwd <path>", "repository path", process.cwd()).option("--project", "write to this repository's .claude/settings.local.json instead of the user settings", false).action(
+    (options) => guard(() => runAgentInstall({ cwd: options.cwd, scope: options.project ? "project" : "user" }))()
+  )
+).addCommand(
+  new Command("remove").description("Remove NexusMem's hooks from Claude Code settings, leaving any other tool's hooks alone").option("-C, --cwd <path>", "repository path", process.cwd()).option("--project", "use this repository's .claude/settings.local.json", false).action(
+    (options) => guard(() => runAgentRemove({ cwd: options.cwd, scope: options.project ? "project" : "user" }))()
+  )
+).addCommand(
+  new Command("status").description("Show whether the Claude Code hooks are installed and current").option("-C, --cwd <path>", "repository path", process.cwd()).option("--project", "use this repository's .claude/settings.local.json", false).action(
+    (options) => guard(() => runAgentStatus({ cwd: options.cwd, scope: options.project ? "project" : "user" }))()
+  )
+).addCommand(
+  new Command("recall").description("Read a hook payload on stdin and print matching failure history -- run by the hook, not by hand").option("--trigger <kind>", "which hook fired", "failure").action(() => guard(() => runAgentRecall())())
+).addCommand(
+  new Command("session-start").description("Start a background sync and print any unresolved-failure digest -- run by the hook, not by hand").action(() => guard(() => runAgentSessionStart())())
+);
+program.command("scrub-secrets").description(
+  "Redact secrets that older versions already stored (database rows, FTS index, embeddings, shell hook log) -- dry-run unless --yes"
+).option("-C, --cwd <path>", "repository path", process.cwd()).option("-a, --all-projects", "every repository in the NexusMem registry, not just this one", false).option("--no-embed", "leave re-embedding the redacted nodes to the next sync").option("--yes", "back up each database, then redact it in place", false).action(
+  (options) => guard(
+    () => runScrubSecrets({ cwd: options.cwd, allProjects: options.allProjects, yes: options.yes, embed: options.embed })
+  )()
+);
 program.command("mark-stale").description(
   "Mark a node as superseded by another -- the ranker down-weights it (never deletes it) so its replacement usually outranks it"
 ).argument("<nodeId>", "id of the node to mark stale").requiredOption("--supersedes <newNodeId>", "id of the node that supersedes it").option("-C, --cwd <path>", "repository path", process.cwd()).action(
@@ -7577,7 +9190,7 @@ program.command("scan-structure").description("Preview the JS/TS/Python/Go/Rust/
 program.command("mcp").description("Start the MCP server (stdio transport) for Claude Desktop, Cursor, Windsurf, etc.").action(() => guard(() => runMcpServer().then(() => 0))());
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
-  process.stderr.write(`${pc22.red("error")} ${message}
+  process.stderr.write(`${pc24.red("error")} ${message}
 `);
   process.exitCode = 1;
 });