nexusmem 0.10.1 → 0.10.3

package/dist/cli/index.js

@@ -606,13 +606,41 @@ async function hookStatus(target) {
 }
 
 // src/hooks/install-git-precommit.ts
-import { chmod, mkdir as mkdir3, readFile as readFile3, unlink, writeFile as writeFile3 } from "fs/promises";
-import { dirname as dirname2, join as join4 } from "path";
+import { join as join4 } from "path";
+
+// src/hooks/git-hook-snippet.ts
+var SHEBANG = "#!/bin/sh";
+function isHookInstalled2(content, markers) {
+  return content.includes(markers.markStart);
+}
+function isForeignHook(content, markers) {
+  return content.trim().length > 0 && !isHookInstalled2(content, markers);
+}
+function stripHookSnippet2(content, markers) {
+  const startIdx = content.indexOf(markers.markStart);
+  const endIdx = content.indexOf(markers.markEnd);
+  if (startIdx === -1 || endIdx === -1) return content;
+  const afterBlock = content.slice(endIdx + markers.markEnd.length).replace(/^\r?\n/, "");
+  return content.slice(0, startIdx) + afterBlock;
+}
+function upsertHookSnippet2(content, markers, renderHookSnippet4) {
+  const stripped = stripHookSnippet2(content, markers).replace(/\s+$/, "");
+  const prefix = stripped.length > 0 ? `${stripped}
+
+` : "";
+  return `${prefix}${renderHookSnippet4()}`;
+}
+function ensureShebang(content) {
+  if (content.startsWith("#!")) return content;
+  return content.length > 0 ? `${SHEBANG}
+${content}` : `${SHEBANG}
+`;
+}
 
 // src/hooks/git-pre-commit.ts
 var MARK_START2 = "# >>> nexusmem precommit hook >>>";
 var MARK_END2 = "# <<< nexusmem precommit hook <<<";
-var SHEBANG = "#!/bin/sh";
+var MARKERS = { markStart: MARK_START2, markEnd: MARK_END2 };
 function renderHookSnippet2() {
   return [
     MARK_START2,
@@ -627,47 +655,23 @@ function renderHookSnippet2() {
     ""
   ].join("\n");
 }
-function isHookInstalled2(content) {
-  return content.includes(MARK_START2);
+function isHookInstalled3(content) {
+  return isHookInstalled2(content, MARKERS);
 }
-function isForeignHook(content) {
-  return content.trim().length > 0 && !isHookInstalled2(content);
+function isForeignHook2(content) {
+  return isForeignHook(content, MARKERS);
 }
-function stripHookSnippet2(content) {
-  const startIdx = content.indexOf(MARK_START2);
-  const endIdx = content.indexOf(MARK_END2);
-  if (startIdx === -1 || endIdx === -1) return content;
-  const afterBlock = content.slice(endIdx + MARK_END2.length).replace(/^\r?\n/, "");
-  return content.slice(0, startIdx) + afterBlock;
+function stripHookSnippet3(content) {
+  return stripHookSnippet2(content, MARKERS);
 }
-function upsertHookSnippet2(content) {
-  const stripped = stripHookSnippet2(content).replace(/\s+$/, "");
-  const prefix = stripped.length > 0 ? `${stripped}
-
-` : "";
-  return `${prefix}${renderHookSnippet2()}`;
-}
-function ensureShebang(content) {
-  if (content.startsWith("#!")) return content;
-  return content.length > 0 ? `${SHEBANG}
-${content}` : `${SHEBANG}
-`;
+function upsertHookSnippet3(content) {
+  return upsertHookSnippet2(content, MARKERS, renderHookSnippet2);
 }
+var ensureShebang2 = ensureShebang;
 
-// src/hooks/install-git-precommit.ts
-var ForeignGitHookError = class extends Error {
-  constructor(hookPath) {
-    super(
-      `${hookPath} already has a pre-commit hook NexusMem did not install. Pass --force to append nexusmem's check to the end of it, or integrate manually.`
-    );
-    this.hookPath = hookPath;
-    this.name = "ForeignGitHookError";
-  }
-  hookPath;
-};
-function resolveGitHookTarget(repoRoot) {
-  return { hookPath: join4(repoRoot, ".git", "hooks", "pre-commit") };
-}
+// src/hooks/git-hook-install.ts
+import { chmod, mkdir as mkdir3, readFile as readFile3, unlink, writeFile as writeFile3 } from "fs/promises";
+import { dirname as dirname2 } from "path";
 async function readHook(path) {
   try {
     return await readFile3(path, "utf8");
@@ -675,14 +679,14 @@ async function readHook(path) {
     return "";
   }
 }
-async function installGitHook(target, opts = {}) {
+async function installGitHookGeneric(target, kind, opts = {}) {
   const current = await readHook(target.hookPath);
-  const alreadyInstalled = isHookInstalled2(current);
-  const foreign = isForeignHook(current);
+  const alreadyInstalled = kind.isHookInstalled(current);
+  const foreign = kind.isForeignHook(current);
   if (foreign && !alreadyInstalled && !opts.force) {
-    throw new ForeignGitHookError(target.hookPath);
+    throw kind.createForeignError(target.hookPath);
   }
-  const next = upsertHookSnippet2(ensureShebang(current));
+  const next = kind.upsertHookSnippet(kind.ensureShebang(current));
   if (next === current) return { changed: false, alreadyInstalled, appendedToForeign: false };
   await mkdir3(dirname2(target.hookPath), { recursive: true });
   await writeFile3(target.hookPath, next, "utf8");
@@ -690,11 +694,11 @@ async function installGitHook(target, opts = {}) {
   });
   return { changed: true, alreadyInstalled, appendedToForeign: foreign && !alreadyInstalled };
 }
-async function removeGitHook(target) {
+async function removeGitHookGeneric(target, kind) {
   const current = await readHook(target.hookPath);
-  if (!isHookInstalled2(current)) return { changed: false };
-  const stripped = stripHookSnippet2(current).trim();
-  if (stripped === "" || stripped === SHEBANG) {
+  if (!kind.isHookInstalled(current)) return { changed: false };
+  const stripped = kind.stripHookSnippet(current).trim();
+  if (stripped === "" || stripped === kind.SHEBANG) {
     await unlink(target.hookPath).catch(() => {
     });
   } else {
@@ -703,9 +707,114 @@ async function removeGitHook(target) {
   }
   return { changed: true };
 }
-async function gitHookStatus(target) {
+async function gitHookStatusGeneric(target, kind) {
   const current = await readHook(target.hookPath);
-  return { installed: isHookInstalled2(current), foreign: isForeignHook(current) };
+  return { installed: kind.isHookInstalled(current), foreign: kind.isForeignHook(current) };
+}
+
+// src/hooks/install-git-precommit.ts
+var ForeignGitHookError = class extends Error {
+  constructor(hookPath) {
+    super(
+      `${hookPath} already has a pre-commit hook NexusMem did not install. Pass --force to append nexusmem's check to the end of it, or integrate manually.`
+    );
+    this.hookPath = hookPath;
+    this.name = "ForeignGitHookError";
+  }
+  hookPath;
+};
+var KIND = {
+  isHookInstalled: isHookInstalled3,
+  isForeignHook: isForeignHook2,
+  stripHookSnippet: stripHookSnippet3,
+  upsertHookSnippet: upsertHookSnippet3,
+  ensureShebang: ensureShebang2,
+  SHEBANG,
+  createForeignError: (hookPath) => new ForeignGitHookError(hookPath)
+};
+function resolveGitHookTarget(repoRoot) {
+  return { hookPath: join4(repoRoot, ".git", "hooks", "pre-commit") };
+}
+async function installGitHook(target, opts = {}) {
+  return installGitHookGeneric(target, KIND, opts);
+}
+async function removeGitHook(target) {
+  return removeGitHookGeneric(target, KIND);
+}
+async function gitHookStatus(target) {
+  return gitHookStatusGeneric(target, KIND);
+}
+
+// src/hooks/install-git-postcommit.ts
+import { join as join5 } from "path";
+
+// src/hooks/git-post-commit.ts
+var MARK_START3 = "# >>> nexusmem postcommit hook >>>";
+var MARK_END3 = "# <<< nexusmem postcommit hook <<<";
+var MARKERS2 = { markStart: MARK_START3, markEnd: MARK_END3 };
+var LOG_PATH = ".nexusmem/post-commit-sync.log";
+var LOG_TRUNCATE_THRESHOLD = 2e3;
+function renderHookSnippet3() {
+  return [
+    MARK_START3,
+    "# Runs a full `nexusmem sync` (including embedding) in the background after",
+    "# each commit -- detached, so this never makes `git commit` itself wait.",
+    `# Output goes to ${LOG_PATH} (reset once it passes ${LOG_TRUNCATE_THRESHOLD} lines), not the terminal.`,
+    "# Installed by: nexusmem hook git-post install",
+    "# Remove with:  nexusmem hook git-post remove",
+    "if command -v nexusmem >/dev/null 2>&1; then",
+    "  mkdir -p .nexusmem",
+    `  nohup sh -c '[ "$(wc -l <${LOG_PATH} 2>/dev/null || echo 0)" -gt ${LOG_TRUNCATE_THRESHOLD} ] && : >${LOG_PATH}; nexusmem sync --quiet --auto >>${LOG_PATH} 2>&1' >/dev/null 2>&1 &`,
+    "fi",
+    MARK_END3,
+    ""
+  ].join("\n");
+}
+function isHookInstalled4(content) {
+  return isHookInstalled2(content, MARKERS2);
+}
+function isForeignHook3(content) {
+  return isForeignHook(content, MARKERS2);
+}
+function stripHookSnippet4(content) {
+  return stripHookSnippet2(content, MARKERS2);
+}
+function upsertHookSnippet4(content) {
+  return upsertHookSnippet2(content, MARKERS2, renderHookSnippet3);
+}
+var ensureShebang3 = ensureShebang;
+
+// src/hooks/install-git-postcommit.ts
+var ForeignPostCommitHookError = class extends Error {
+  constructor(hookPath) {
+    super(
+      `${hookPath} already has a post-commit hook NexusMem did not install. Pass --force to append nexusmem's sync to the end of it, or integrate manually.`
+    );
+    this.hookPath = hookPath;
+    this.name = "ForeignPostCommitHookError";
+  }
+  hookPath;
+};
+var KIND2 = {
+  isHookInstalled: isHookInstalled4,
+  isForeignHook: isForeignHook3,
+  stripHookSnippet: stripHookSnippet4,
+  upsertHookSnippet: upsertHookSnippet4,
+  ensureShebang: ensureShebang3,
+  SHEBANG,
+  createForeignError: (hookPath) => new ForeignPostCommitHookError(hookPath)
+};
+function resolvePostCommitHookTarget(repoRoot) {
+  return { hookPath: join5(repoRoot, ".git", "hooks", "post-commit") };
+}
+async function installPostCommitGitHook(target, opts = {}) {
+  return installGitHookGeneric(target, KIND2, opts);
+}
+async function removePostCommitGitHook(target) {
+  return removeGitHookGeneric(target, KIND2);
+}
+async function postCommitGitHookStatus(target) {
+  return gitHookStatusGeneric(target, KIND2);
 }
 
 // src/store/deny-list.ts
@@ -2106,7 +2215,47 @@ async function runHookGitStatus(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const target = resolveGitHookTarget(repo.root);
   const result = await gitHookStatus(target);
-  const statusLabel = result.installed ? pc2.green("installed") : result.foreign ? pc2.yellow("a foreign hook exists (not nexusmem) -- install --force to append") : pc2.yellow("not installed");
+  const statusLabel = result.installed ? pc2.green("installed") : result.foreign ? pc2.yellow("a foreign hook exists (not nexusmem) -- nexusmem hook git install --force to append") : pc2.yellow("not installed");
+  process.stdout.write([`${pc2.dim("hook  ")} ${target.hookPath}`, `${pc2.dim("status")} ${statusLabel}`, ""].join("\n"));
+  return 0;
+}
+async function runHookGitPostInstall(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const target = resolvePostCommitHookTarget(repo.root);
+  const result = await installPostCommitGitHook(target, { force: opts.force });
+  const lines = [
+    result.changed ? `${pc2.green(result.alreadyInstalled ? "updated" : "installed")} git post-commit hook` : `${pc2.dim("already up to date")}`,
+    `  hook ${target.hookPath}`
+  ];
+  if (result.appendedToForeign) {
+    lines.push(`  ${pc2.yellow("appended after an existing post-commit hook -- review")} ${target.hookPath}`);
+  }
+  lines.push(
+    "",
+    `Runs a full ${pc2.bold("nexusmem sync")} (including embedding) in the background after each commit --`,
+    `detached, so it never makes ${pc2.bold("git commit")} itself wait. Output goes to .nexusmem/post-commit-sync.log.`,
+    `Run ${pc2.bold("nexusmem hook git-post remove")} to undo this.`,
+    ""
+  );
+  process.stdout.write(lines.join("\n"));
+  return 0;
+}
+async function runHookGitPostRemove(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const target = resolvePostCommitHookTarget(repo.root);
+  const result = await removePostCommitGitHook(target);
+  process.stdout.write(
+    result.changed ? `${pc2.green("removed")} nexusmem's block from ${target.hookPath}
+` : `${pc2.dim("nothing to remove")} \u2014 no nexusmem block found in ${target.hookPath}
+`
+  );
+  return 0;
+}
+async function runHookGitPostStatus(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const target = resolvePostCommitHookTarget(repo.root);
+  const result = await postCommitGitHookStatus(target);
+  const statusLabel = result.installed ? pc2.green("installed") : result.foreign ? pc2.yellow("a foreign hook exists (not nexusmem) -- nexusmem hook git-post install --force to append") : pc2.yellow("not installed");
   process.stdout.write([`${pc2.dim("hook  ")} ${target.hookPath}`, `${pc2.dim("status")} ${statusLabel}`, ""].join("\n"));
   return 0;
 }
@@ -2161,7 +2310,7 @@ import pc4 from "picocolors";
 // src/config/registry.ts
 import { existsSync as existsSync2 } from "fs";
 import { mkdir as mkdir4, readFile as readFile5, rename, writeFile as writeFile5 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 import { z as z3 } from "zod";
 var ENTRY_SCHEMA = z3.object({
   projectId: z3.string().min(1),
@@ -2176,7 +2325,7 @@ var REGISTRY_SCHEMA = z3.object({
   projects: z3.array(ENTRY_SCHEMA).default([])
 });
 function registryPath() {
-  return join5(globalWorkspaceDir(), "projects.json");
+  return join6(globalWorkspaceDir(), "projects.json");
 }
 async function readRegistry() {
   let raw;
@@ -3989,8 +4138,8 @@ function scoreShellCommand(entry) {
   else if (cmd.length <= 3) score -= 0.05;
   return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
 }
-function renderBody2(entry, maxChars) {
-  const parts = [`$ ${entry.command}`];
+function renderBody2(entry, command, maxChars) {
+  const parts = [`$ ${command}`];
   const metaLine = [];
   if (entry.cwd) metaLine.push(`cwd: ${entry.cwd}`);
   if (entry.exitCode !== null) metaLine.push(`exit: ${entry.exitCode}`);
@@ -4000,7 +4149,8 @@ function renderBody2(entry, maxChars) {
 }
 function toMemoryNode3(entry, projectId, opts = {}) {
   const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS5;
-  const titleLine = entry.command.split(/\r?\n/)[0] ?? entry.command;
+  const { text: redactedCommand } = redact(entry.command);
+  const titleLine = redactedCommand.split(/\r?\n/)[0] ?? redactedCommand;
   return {
     id: makeNodeId(projectId, "shell_command", entry.naturalKey),
     kind: "shell_command",
@@ -4008,7 +4158,7 @@ function toMemoryNode3(entry, projectId, opts = {}) {
     ts: entry.ts,
     source: `shell:${entry.shell}`,
     title: truncate(titleLine, MAX_TITLE_CHARS7),
-    body: renderBody2(entry, maxBody),
+    body: renderBody2(entry, redactedCommand, maxBody),
     files: [],
     signal: scoreShellCommand(entry),
     provenance: "observed",
@@ -4034,18 +4184,18 @@ import { basename as basename2 } from "path";
 import { existsSync as existsSync3 } from "fs";
 import { readdir } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 function claudeProjectSlug(repoRoot) {
   return repoRoot.replace(/[\\/:]/g, "-");
 }
 function claudeProjectTranscriptDir(repoRoot) {
-  return join6(homedir3(), ".claude", "projects", claudeProjectSlug(repoRoot));
+  return join7(homedir3(), ".claude", "projects", claudeProjectSlug(repoRoot));
 }
 async function listTranscriptFiles(repoRoot) {
   const dir = claudeProjectTranscriptDir(repoRoot);
   if (!existsSync3(dir)) return [];
   const entries = await readdir(dir, { withFileTypes: true });
-  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join6(dir, e.name));
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join7(dir, e.name));
 }
 
 // src/conversation/claude-code-reader.ts
@@ -4128,7 +4278,7 @@ async function collectClaudeCodeTranscripts(repoRoot) {
 
 // src/docs/read.ts
 import { readFile as readFile7, stat } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var DEFAULT_PATHSPECS = ["*.md"];
 async function listDocFiles(repoRoot, opts = {}) {
   const pathspecs = opts.include ?? DEFAULT_PATHSPECS;
@@ -4141,7 +4291,7 @@ async function readDocFiles(repoRoot, opts = {}) {
   const unreadable = [];
   for (const relPath of paths) {
     const path = relPath.replace(/\\/g, "/");
-    const absPath = join7(repoRoot, relPath);
+    const absPath = join8(repoRoot, relPath);
     let content;
     let mtime;
     try {
@@ -4671,7 +4821,7 @@ function reconcileProjectId(db, oldProjectId, newProjectId) {
 
 // src/structure/collect.ts
 import { readFile as readFile10 } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/structure/extract.ts
 var IMPORT_PATTERNS = [
@@ -5110,7 +5260,7 @@ async function collectFileEdges(repoRoot) {
   const trackedPaths = new Set(paths);
   let goModulePath = null;
   try {
-    goModulePath = parseGoModulePath(await readFile10(join8(repoRoot, "go.mod"), "utf8"));
+    goModulePath = parseGoModulePath(await readFile10(join9(repoRoot, "go.mod"), "utf8"));
   } catch {
     goModulePath = null;
   }
@@ -5120,7 +5270,7 @@ async function collectFileEdges(repoRoot) {
   for (const path of paths) {
     let content;
     try {
-      content = await readFile10(join8(repoRoot, path), "utf8");
+      content = await readFile10(join9(repoRoot, path), "utf8");
     } catch {
       unreadable.push(path);
       continue;
@@ -5209,6 +5359,52 @@ ${node.body}`)
   };
 }
 
+// src/cli/sync-lock.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { join as join10 } from "path";
+function lockPath(wsDir) {
+  return join10(wsDir, "sync.lock");
+}
+function readOwner(path) {
+  try {
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const pid = parsed?.pid;
+    return typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function acquireSyncLock(wsDir) {
+  mkdirSync2(wsDir, { recursive: true });
+  const path = lockPath(wsDir);
+  for (; ; ) {
+    try {
+      writeFileSync(path, `${JSON.stringify({ pid: process.pid })}
+`, { flag: "wx" });
+      return { release: () => tryUnlink(path) };
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const owner = readOwner(path);
+    if (owner && isPidAlive(owner.pid)) return null;
+    tryUnlink(path);
+  }
+}
+function tryUnlink(path) {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+}
+
 // src/cli/commands/sync.ts
 var BATCH_SIZE = 500;
 var PROGRESS_THRESHOLD = 200;
@@ -5525,6 +5721,15 @@ async function runSync(opts) {
 `);
   };
   const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  let lock = null;
+  if (opts.auto) {
+    lock = acquireSyncLock(ws.dir);
+    if (!lock) {
+      out(`${pc7.dim("auto-sync")} another sync is already running for this project -- skipping
+`);
+      return 0;
+    }
+  }
   const store = MemoryStore.open(ws.dbPath);
   const started = Date.now();
   try {
@@ -5634,6 +5839,7 @@ async function runSync(opts) {
     return 0;
   } finally {
     store.close();
+    lock?.release();
   }
 }
 
@@ -5735,6 +5941,44 @@ async function getStatus(input) {
     store.close();
   }
 }
+async function listStaleSuggestions(input) {
+  const repo = await readRepoInfo(input.projectRoot);
+  const ws = resolveWorkspace(repo.root);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    return { suggestions: store.listContradictionSuggestions(projectId, { limit: input.limit }) };
+  } finally {
+    store.close();
+  }
+}
+async function resolveStaleSuggestion(input) {
+  if (input.action === "dismiss") {
+    const repo = await readRepoInfo(input.projectRoot);
+    const ws = resolveWorkspace(repo.root);
+    const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+    const store = MemoryStore.open(ws.dbPath);
+    try {
+      const dismissed = store.dismissContradictionSuggestion(projectId, input.candidateId);
+      return {
+        summary: dismissed > 0 ? `dismissed the contradiction suggestion for ${input.candidateId}` : `no open contradiction suggestion for ${input.candidateId}`
+      };
+    } finally {
+      store.close();
+    }
+  }
+  if (!input.againstId) {
+    throw new Error("againstId is required to accept a stale suggestion");
+  }
+  const chunks = [];
+  await runMarkStale({
+    cwd: input.projectRoot,
+    nodeId: input.candidateId,
+    supersedesId: input.againstId,
+    out: (chunk2) => chunks.push(chunk2)
+  });
+  return { summary: stripAnsi(chunks.join("").trim()) };
+}
 
 // src/mcp/server.ts
 function createServer() {
@@ -5824,6 +6068,41 @@ function createServer() {
       };
     }
   );
+  server.registerTool(
+    "list_stale_suggestions",
+    {
+      title: "List open contradiction suggestions",
+      description: 'List open contradiction verdicts for a NexusMem-tracked repository -- candidates flagged by "nexusmem stale --check-contradictions" (or automatically during sync) as likely superseded by a newer, similar node. Nothing has been written yet; use resolve_stale_suggestion to act on one.',
+      inputSchema: {
+        projectRoot: z4.string().describe("Absolute path to the repository root"),
+        limit: z4.number().int().positive().optional().describe("Max suggestions to return, most recently judged first. Default 50.")
+      }
+    },
+    async ({ projectRoot, limit }) => {
+      const result = await listStaleSuggestions({ projectRoot, limit });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result.suggestions, null, 2) }],
+        structuredContent: { suggestions: result.suggestions }
+      };
+    }
+  );
+  server.registerTool(
+    "resolve_stale_suggestion",
+    {
+      title: "Accept or dismiss a contradiction suggestion",
+      description: '"accept" writes a supersede link from candidateId to againstId (the same effect as "nexusmem mark-stale") -- the ranker down-weights candidateId from then on but never deletes it. "dismiss" silences the suggestion without changing ranking, so it stops resurfacing on future stale/sync runs.',
+      inputSchema: {
+        projectRoot: z4.string().describe("Absolute path to the repository root"),
+        candidateId: z4.string().describe("Id of the stale/superseded node"),
+        action: z4.enum(["accept", "dismiss"]).describe("Whether to write the supersede link or silence the suggestion"),
+        againstId: z4.string().optional().describe('Id of the superseding node. Required for "accept", ignored for "dismiss".')
+      }
+    },
+    async ({ projectRoot, candidateId, action, againstId }) => {
+      const result = await resolveStaleSuggestion({ projectRoot, candidateId, action, againstId });
+      return { content: [{ type: "text", text: result.summary }] };
+    }
+  );
   return server;
 }
 async function runMcpServer() {
@@ -6652,7 +6931,7 @@ function isExpected(err) {
   // the user fixes, not stack traces they debug.
   err instanceof GitSpawnError || // Survived every retry, so git is genuinely unstable on this machine
   // (antivirus, a bad install). Actionable, and not our stack to print.
-  err instanceof GitCrashError || err instanceof ConfigError || err instanceof ProfileNotFoundError || err instanceof ForeignGitHookError || err instanceof DenyListError || err instanceof MarkStaleError || err instanceof QueryError || err instanceof ReviewError;
+  err instanceof GitCrashError || err instanceof ConfigError || err instanceof ProfileNotFoundError || err instanceof ForeignGitHookError || err instanceof ForeignPostCommitHookError || err instanceof DenyListError || err instanceof MarkStaleError || err instanceof QueryError || err instanceof ReviewError;
 }
 function guard(run) {
   return async () => {
@@ -6688,7 +6967,11 @@ program.command("sync").description("Ingest new history into the local database"
   "--link-failures",
   "opt-in (experimental): after ingest, link failed shell commands to whatever later resolved them",
   false
-).option("-q, --quiet", "only print the final summary", false).action(
+).option("-q, --quiet", "only print the final summary", false).option(
+  "--auto",
+  "used by the post-commit hook: skip (instead of running) if another --auto sync already holds this project's lock -- a manually-run sync never checks it",
+  false
+).action(
   (options) => guard(
     () => runSync({
       cwd: options.cwd,
@@ -6704,7 +6987,8 @@ program.command("sync").description("Ingest new history into the local database"
       pruneStaleShell: options.pruneStaleShell,
       yes: options.yes,
       linkFailures: options.linkFailures,
-      quiet: options.quiet
+      quiet: options.quiet,
+      auto: options.auto
     })
   )()
 );
@@ -6722,6 +7006,14 @@ program.command("hook").description("Manage the opt-in PowerShell hook that logs
   ).addCommand(
     new Command("status").description("Show whether the git pre-commit hook is installed").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runHookGitStatus({ cwd: options.cwd }))())
   )
+).addCommand(
+  new Command("git-post").description("Manage the opt-in git post-commit hook that runs a full `nexusmem sync` (with embedding) after each commit").addCommand(
+    new Command("install").description("Install (or update) the hook in .git/hooks/post-commit").option("-C, --cwd <path>", "repository path", process.cwd()).option("--force", "append after an existing foreign post-commit hook instead of refusing", false).action((options) => guard(() => runHookGitPostInstall({ cwd: options.cwd, force: options.force }))())
+  ).addCommand(
+    new Command("remove").description("Remove nexusmem's block from .git/hooks/post-commit").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runHookGitPostRemove({ cwd: options.cwd }))())
+  ).addCommand(
+    new Command("status").description("Show whether the git post-commit hook is installed").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runHookGitPostStatus({ cwd: options.cwd }))())
+  )
 );
 program.command("status").description("Show what is currently remembered for this repository").option("-C, --cwd <path>", "repository path", process.cwd()).option("--share", "print a plain-text summary formatted for sharing, e.g. on X or Reddit").action((options) => guard(() => runStatus({ cwd: options.cwd, share: options.share }))());
 program.command("query").description("Search remembered history and print a token-budgeted context block").argument("<text>", "free-text query").option("-C, --cwd <path>", "repository path", process.cwd()).option("-b, --budget <tokens>", "max tokens in the packed context", (v) => Number.parseInt(v, 10), 2e3).option("-n, --candidates <count>", "how many search hits to rank before packing", (v) => Number.parseInt(v, 10), 30).option("--half-life <days>", "days for a node's recency weight to halve", (v) => Number.parseFloat(v)).option("--no-vector", "BM25 only -- skip embedding the query and vector search").option("-a, --all-projects", "search every registered repository, not just this one", false).option("--as-of <date>", 'bi-temporal read: only nodes recorded at or before this date -- "what did the store hold then", not "what happened then"').option("--json", "emit the packed result as JSON on stdout", false).action(