nexusmem 0.1.1 → 0.2.0

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import pc11 from "picocolors";
+import pc13 from "picocolors";
 
 // src/config/workspace.ts
 import { existsSync } from "fs";
@@ -51,12 +51,28 @@ var ConfigSchema = z.object({
       enabled: z.boolean().default(true),
       /** git pathspecs passed to `git ls-files`. */
       include: z.array(z.string()).default(["*.md"])
-    }).default({ enabled: true, include: ["*.md"] })
+    }).default({ enabled: true, include: ["*.md"] }),
+    /**
+     * The patch text of each commit, one node per changed file.
+     *
+     * Bounded by `maxCommits` rather than by `git.since`, because patches
+     * are an order of magnitude bulkier than commit messages: an unbounded
+     * first sync of a long-lived repository would spend most of its time
+     * and database on code nobody will ask about. Later syncs walk only
+     * `cursor..HEAD`, so the cap effectively applies to the first run.
+     */
+    diff: z.object({
+      enabled: z.boolean().default(true),
+      maxCommits: z.number().int().positive().default(200),
+      maxFilesPerCommit: z.number().int().positive().default(20),
+      contextLines: z.number().int().nonnegative().default(3)
+    }).default({ enabled: true, maxCommits: 200, maxFilesPerCommit: 20, contextLines: 3 })
   }).default({
     git: { enabled: true, since: null, includeMerges: true },
     shell: { enabled: true, tailLines: 300 },
     conversation: { enabled: false },
-    docs: { enabled: true, include: ["*.md"] }
+    docs: { enabled: true, include: ["*.md"] },
+    diff: { enabled: true, maxCommits: 200, maxFilesPerCommit: 20, contextLines: 3 }
   }),
   limits: z.object({
     maxFilesPerNode: z.number().int().positive().default(40),
@@ -103,6 +119,14 @@ async function writeWorkspaceGitignore(ws) {
   await writeFile(join(ws.dir, ".gitignore"), "# Machine-local derived data.\n*\n", "utf8");
 }
 
+// src/core/version.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+function readOwnVersion() {
+  const pkgPath = fileURLToPath(new URL("../../package.json", import.meta.url));
+  return JSON.parse(readFileSync(pkgPath, "utf8")).version;
+}
+
 // src/git/exec.ts
 import { spawn } from "child_process";
 var GitError = class extends Error {
@@ -306,25 +330,31 @@ import { dirname } from "path";
 
 // src/shell/paths.ts
 import { execFile } from "child_process";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+import { promisify } from "util";
+
+// src/config/paths.ts
 import { homedir } from "os";
 import { join as join2 } from "path";
-import { promisify } from "util";
+function globalWorkspaceDir() {
+  return process.env.NEXUSMEM_HOME ?? join2(homedir(), ".nexusmem");
+}
+
+// src/shell/paths.ts
 var execFileAsync = promisify(execFile);
 function psReadLineHistoryPath() {
-  const appData = process.env.APPDATA ?? join2(homedir(), "AppData", "Roaming");
-  return join2(appData, "Microsoft", "Windows", "PowerShell", "PSReadLine", "ConsoleHost_history.txt");
+  const appData = process.env.APPDATA ?? join3(homedir2(), "AppData", "Roaming");
+  return join3(appData, "Microsoft", "Windows", "PowerShell", "PSReadLine", "ConsoleHost_history.txt");
 }
 function bashHistoryPath() {
-  return process.env.HISTFILE_BASH ?? join2(homedir(), ".bash_history");
+  return process.env.HISTFILE_BASH ?? join3(homedir2(), ".bash_history");
 }
 function zshHistoryPath() {
-  return process.env.HISTFILE ?? join2(homedir(), ".zsh_history");
-}
-function globalWorkspaceDir() {
-  return join2(homedir(), ".nexusmem");
+  return process.env.HISTFILE ?? join3(homedir2(), ".zsh_history");
 }
 function hookLogPath() {
-  return join2(globalWorkspaceDir(), "shell-history.jsonl");
+  return join3(globalWorkspaceDir(), "shell-history.jsonl");
 }
 async function resolvePowerShellProfilePath(exe = "powershell") {
   try {
@@ -478,6 +508,74 @@ async function runHookStatus(opts) {
 import { relative } from "path";
 import pc2 from "picocolors";
 
+// src/config/registry.ts
+import { existsSync as existsSync2 } from "fs";
+import { mkdir as mkdir3, readFile as readFile3, rename, writeFile as writeFile3 } from "fs/promises";
+import { join as join4 } from "path";
+import { z as z2 } from "zod";
+var ENTRY_SCHEMA = z2.object({
+  projectId: z2.string().min(1),
+  root: z2.string().min(1),
+  dbPath: z2.string().min(1),
+  originUrl: z2.string().nullable().default(null),
+  /** Epoch ms of the last `init`/`sync` that recorded this entry. */
+  lastSeenAt: z2.number().int().nonnegative()
+});
+var REGISTRY_SCHEMA = z2.object({
+  version: z2.literal(1),
+  projects: z2.array(ENTRY_SCHEMA).default([])
+});
+function registryPath() {
+  return join4(globalWorkspaceDir(), "projects.json");
+}
+async function readRegistry() {
+  let raw;
+  try {
+    raw = await readFile3(registryPath(), "utf8");
+  } catch {
+    return [];
+  }
+  try {
+    const parsed = REGISTRY_SCHEMA.safeParse(JSON.parse(raw));
+    if (!parsed.success) return [];
+    return [...parsed.data.projects].sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+  } catch {
+    return [];
+  }
+}
+async function readLiveRegistry() {
+  const all = await readRegistry();
+  const entries = [];
+  const missing = [];
+  for (const entry of all) {
+    (existsSync2(entry.dbPath) ? entries : missing).push(entry);
+  }
+  return { entries, missing };
+}
+async function recordProject(input) {
+  const existing = await readRegistry();
+  const entry = { ...input, lastSeenAt: Date.now() };
+  const projects = [entry, ...existing.filter((e) => e.projectId !== input.projectId)];
+  await writeRegistry(projects);
+  return projects;
+}
+async function forgetProjects(projectIds) {
+  const existing = await readRegistry();
+  const drop = new Set(projectIds);
+  const kept = existing.filter((e) => !drop.has(e.projectId));
+  if (kept.length === existing.length) return 0;
+  await writeRegistry(kept);
+  return existing.length - kept.length;
+}
+async function writeRegistry(projects) {
+  const path = registryPath();
+  const tmp = `${path}.${process.pid}.tmp`;
+  await mkdir3(globalWorkspaceDir(), { recursive: true });
+  await writeFile3(tmp, `${JSON.stringify({ version: 1, projects }, null, 2)}
+`, "utf8");
+  await rename(tmp, path);
+}
+
 // src/core/ids.ts
 import { createHash } from "crypto";
 var KEY_SEP = "\0";
@@ -897,6 +995,7 @@ async function runInit(opts) {
   } finally {
     store.close();
   }
+  await recordProject({ projectId, root: repo.root, dbPath: ws.dbPath, originUrl: repo.originUrl });
   const lines = [
     `${pc2.green("initialized")} ${ws.dir}`,
     `  project  ${pc2.cyan(projectId)}`,
@@ -931,10 +1030,68 @@ async function runInit(opts) {
   return 0;
 }
 
+// src/cli/commands/projects.ts
+import pc3 from "picocolors";
+async function runProjects(opts) {
+  const { entries, missing } = await readLiveRegistry();
+  const rows = entries.map((entry) => {
+    let nodes = null;
+    try {
+      const store = MemoryStore.open(entry.dbPath);
+      try {
+        nodes = store.stats(entry.projectId).total;
+      } finally {
+        store.close();
+      }
+    } catch {
+      nodes = null;
+    }
+    return { ...entry, nodes };
+  });
+  if (opts.prune) {
+    const removed = await forgetProjects(missing.map((entry) => entry.projectId));
+    process.stderr.write(`${pc3.yellow("pruned")} ${removed} project(s) whose database is gone
+`);
+  }
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify({ registry: registryPath(), projects: rows, missing }, null, 2)}
+`);
+    return 0;
+  }
+  process.stderr.write(`${pc3.dim("registry")} ${registryPath()}
+
+`);
+  if (rows.length === 0) {
+    process.stderr.write(`${pc3.yellow("no projects registered")} -- run ${pc3.bold("nexusmem sync")} in a repository
+`);
+    return 0;
+  }
+  for (const row of rows) {
+    const seen = new Date(row.lastSeenAt).toISOString().slice(0, 16).replace("T", " ");
+    const count = row.nodes === null ? pc3.yellow("unreadable") : `${row.nodes} node(s)`;
+    process.stdout.write(`${pc3.cyan(row.projectId.slice(0, 8))}  ${row.root}
+    ${pc3.dim(`${count}, last seen ${seen}`)}
+`);
+  }
+  if (!opts.prune && missing.length > 0) {
+    process.stderr.write(
+      `
+${pc3.yellow(`${missing.length} registered project(s) have no database on disk`)} ${pc3.dim("-- run with --prune to forget them")}
+`
+    );
+    for (const entry of missing) process.stderr.write(`    ${pc3.dim(entry.root)}
+`);
+  }
+  return 0;
+}
+
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+
+// src/mcp/tools.ts
+import { basename as basename2 } from "path";
 
 // src/core/text.ts
 function truncate(s, max) {
@@ -948,22 +1105,126 @@ function approxTokens(text) {
 var DEFAULT_SUMMARY_CHARS = 320;
 var NODE_OVERHEAD_TOKENS = 8;
 var CONVERSATION_ANSWER_MARKER = "\n\nA: ";
-function summarize(hit, maxChars) {
+var HUNK_BOUNDARY = "\n@@ ";
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "are",
+  "was",
+  "were",
+  "that",
+  "this",
+  "with",
+  "from",
+  "into",
+  "not",
+  "but",
+  "what",
+  "why",
+  "how",
+  "when",
+  "where",
+  "which",
+  "who",
+  "does",
+  "did",
+  "has",
+  "have",
+  "had",
+  "can",
+  "could",
+  "would",
+  "should",
+  "all",
+  "any",
+  "every",
+  "each",
+  "its",
+  "our",
+  "you",
+  "your",
+  "about"
+]);
+function queryTerms(query) {
+  const words = query.toLowerCase().match(/[a-z0-9_]{3,}/g) ?? [];
+  return [...new Set(words.filter((w) => !STOPWORDS.has(w)).map(singularize))];
+}
+function codeTokens(text) {
+  const spaced = text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase();
+  return new Set((spaced.match(/[a-z0-9]{2,}/g) ?? []).map(singularize));
+}
+function singularize(word) {
+  return word.length > 3 && word.endsWith("s") && !word.endsWith("ss") ? word.slice(0, -1) : word;
+}
+function pickHunk(patch, query) {
+  const first = patch.indexOf("@@ ");
+  if (first === -1) return patch;
+  const hunks = [];
+  let rest = patch.slice(first);
+  for (; ; ) {
+    const next = rest.indexOf(HUNK_BOUNDARY, 1);
+    if (next === -1) {
+      hunks.push(rest);
+      break;
+    }
+    hunks.push(rest.slice(0, next));
+    rest = rest.slice(next + 1);
+  }
+  const terms = queryTerms(query);
+  if (terms.length === 0) return hunks[0] ?? patch;
+  let best = hunks[0] ?? patch;
+  let bestScore = 0;
+  for (const hunk of hunks) {
+    const tokens = codeTokens(hunk);
+    const score = terms.reduce((n, term) => n + (tokens.has(term) ? 1 : 0), 0);
+    if (score > bestScore) {
+      best = hunk;
+      bestScore = score;
+    }
+  }
+  return focusHunk(best, terms);
+}
+function focusHunk(hunk, terms) {
+  const lines = hunk.split("\n");
+  const header = lines[0] ?? "";
+  const body = lines.slice(1);
+  const isChange = (line) => line.startsWith("+") || line.startsWith("-");
+  let idx = terms.length ? body.findIndex((line) => {
+    if (!isChange(line)) return false;
+    const tokens = codeTokens(line);
+    return terms.some((term) => tokens.has(term));
+  }) : -1;
+  if (idx === -1) idx = body.findIndex(isChange);
+  if (idx <= 1) return hunk;
+  return [header, ...body.slice(idx - 1)].join("\n");
+}
+function summarize(hit, maxChars, query) {
   const answerIdx = hit.body.indexOf(CONVERSATION_ANSWER_MARKER);
   if (answerIdx !== -1) {
     const answer = hit.body.slice(answerIdx + CONVERSATION_ANSWER_MARKER.length).trim();
     if (answer) return truncate(answer, maxChars);
   }
+  if (hit.kind === "code_diff") {
+    const patchStart = hit.body.indexOf(HUNK_BOUNDARY);
+    if (patchStart !== -1) {
+      const head = hit.body.slice(0, patchStart).trim();
+      const hunk = pickHunk(hit.body.slice(patchStart + 1), query);
+      return truncate(`${head}
+${hunk}`, maxChars);
+    }
+  }
   const rest = hit.body.startsWith(hit.title) ? hit.body.slice(hit.title.length).trim() : hit.body;
   return truncate(rest || hit.title, maxChars);
 }
 function packContext(ranked, tokensBudget, opts = {}) {
   const summaryChars = opts.summaryChars ?? DEFAULT_SUMMARY_CHARS;
+  const query = opts.query ?? "";
   const nodes = [];
   let tokensUsed = 0;
   let droppedForBudget = 0;
   for (const hit of ranked) {
-    const summary = summarize(hit, summaryChars);
+    const summary = summarize(hit, summaryChars, query);
     const tokens = approxTokens(hit.title) + approxTokens(summary) + NODE_OVERHEAD_TOKENS;
     if (tokensUsed + tokens > tokensBudget) {
       droppedForBudget += 1;
@@ -977,7 +1238,8 @@ function packContext(ranked, tokensBudget, opts = {}) {
       signal: hit.signal,
       score: hit.score,
       summary,
-      tokens
+      tokens,
+      ...hit.project ? { project: hit.project } : {}
     });
     tokensUsed += tokens;
   }
@@ -987,9 +1249,14 @@ function renderContextBlock(query, result) {
   if (result.nodes.length === 0) return `No remembered context matched "${query}".`;
   const lines = [`Relevant history for: ${query}`, ""];
   for (const node of result.nodes) {
-    lines.push(`- ${node.ts.slice(0, 10)} ${node.title}`);
+    const project = node.project ? `[${node.project}] ` : "";
+    lines.push(`- ${node.ts.slice(0, 10)} ${project}${node.title}`);
     if (node.summary && node.summary !== node.title) {
-      lines.push(`  ${node.summary.replace(/\n+/g, " ")}`);
+      if (node.kind === "code_diff") {
+        for (const line of node.summary.split("\n")) lines.push(`  ${line}`);
+      } else {
+        lines.push(`  ${node.summary.replace(/\n+/g, " ")}`);
+      }
     }
   }
   return lines.join("\n");
@@ -1068,6 +1335,31 @@ function rankHits(hits, opts = {}) {
 }
 
 // src/retrieval/query-pipeline.ts
+async function runCrossProjectQuery(sources, query, opts) {
+  const queryVector = opts.embeddingProvider ? await opts.embeddingProvider.embed(query) : null;
+  const lists = [];
+  const hits = [];
+  const perProject = [];
+  let bm25Count = 0;
+  let vectorCount = 0;
+  for (const source of sources) {
+    const label = (hit) => ({ ...hit, project: source.label });
+    const bm25Hits = source.store.search(source.projectId, query, opts.candidates).map(label);
+    const vectorHits = queryVector ? source.store.vectorSearch(source.projectId, queryVector, opts.candidates) : [];
+    bm25Count += bm25Hits.length;
+    vectorCount += vectorHits.length;
+    perProject.push({ label: source.label, bm25: bm25Hits.length, vector: vectorHits.length });
+    if (bm25Hits.length > 0) lists.push(bm25Hits);
+    if (vectorHits.length > 0) {
+      lists.push(vectorHits.map((hit) => ({ ...hit, rank: 0, project: source.label })));
+    }
+    hits.push(...mergeSearchAndVectorHits(bm25Hits, vectorHits).map(label));
+  }
+  const relevanceScores = reciprocalRankFusion(lists);
+  const ranked = rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores });
+  const packed = packContext(ranked, opts.budget, { query });
+  return { bm25Count, vectorCount, hits, packed, perProject };
+}
 async function runHybridQuery(store, projectId, query, opts) {
   const bm25Hits = store.search(projectId, query, opts.candidates);
   let vectorHits = [];
@@ -1078,10 +1370,55 @@ async function runHybridQuery(store, projectId, query, opts) {
   const hits = vectorHits.length > 0 ? mergeSearchAndVectorHits(bm25Hits, vectorHits) : bm25Hits;
   const relevanceScores = vectorHits.length > 0 ? reciprocalRankFusion([bm25Hits, vectorHits]) : void 0;
   const ranked = rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores });
-  const packed = packContext(ranked, opts.budget);
+  const packed = packContext(ranked, opts.budget, { query });
   return { bm25Count: bm25Hits.length, vectorCount: vectorHits.length, hits, packed };
 }
 
+// src/retrieval/sources.ts
+import { basename } from "path";
+async function openAllProjectSources(current) {
+  const { entries, missing } = await readLiveRegistry();
+  const wanted = [current];
+  for (const entry of entries) {
+    if (entry.projectId === current.projectId) continue;
+    wanted.push({ projectId: entry.projectId, root: entry.root, dbPath: entry.dbPath });
+  }
+  const labels = labelProjects(wanted);
+  const sources = [];
+  const unreadable = [];
+  wanted.forEach((project, index) => {
+    try {
+      sources.push({
+        store: MemoryStore.open(project.dbPath),
+        projectId: project.projectId,
+        label: labels[index] ?? project.projectId.slice(0, 8)
+      });
+    } catch (err) {
+      const entry = entries.find((e) => e.projectId === project.projectId);
+      if (entry) unreadable.push({ entry, reason: err.message });
+    }
+  });
+  return {
+    sources,
+    missing,
+    unreadable,
+    close: () => {
+      for (const source of sources) source.store.close();
+    }
+  };
+}
+function labelProjects(projects) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const project of projects) {
+    const name = basename(project.root) || project.root;
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return projects.map((project) => {
+    const name = basename(project.root) || project.root;
+    return (counts.get(name) ?? 0) > 1 ? `${name}#${project.projectId.slice(0, 6)}` : name;
+  });
+}
+
 // src/vector/embed.ts
 var DEFAULT_BASE_URL = "http://127.0.0.1:11434";
 var DEFAULT_MODEL = "nomic-embed-text";
@@ -1121,7 +1458,7 @@ var OllamaEmbeddingProvider = class {
 };
 
 // src/cli/commands/sync.ts
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 
 // src/conversation/chunk.ts
 var HEADING_LINE = /^#{1,6}\s+(.+)$/;
@@ -1161,21 +1498,31 @@ function chunkAssistantText(text, maxChars) {
 
 // src/conversation/redact.ts
 var RULES = [
-  { name: "private-key-block", pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g },
-  { name: "aws-access-key", pattern: /\bAKIA[0-9A-Z]{16}\b/g },
-  { name: "github-token", pattern: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/g },
-  { name: "slack-token", pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g },
-  { name: "jwt", pattern: /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g },
+  {
+    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
+    pattern: /\b((?:api[_-]?key|secret|password|passwd|token|access[_-]?key)s?)\s*[:=]\s*['"]?[A-Za-z0-9_\-./+=]{8,}['"]?/gi,
+    highConfidence: false
   }
 ];
-function redact(text) {
+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;
@@ -1190,8 +1537,8 @@ var DEFAULT_MAX_BODY_CHARS = 2500;
 var DEFAULT_MAX_CHUNK_CHARS = 900;
 var MAX_TITLE_CHARS = 200;
 var MAX_FILES_PER_NODE = 20;
-var EXPLANATION_MARKERS = /\b(because|the reason|design decision|trade-?off|instead of|rationale|so that)\b|เพราะ|ทำไม|เหตุผล/i;
-var TRIVIAL_ACK = /^(ok|okay|thanks?|ขอบคุณ|ครับ|ค่ะ|got it|sounds good|👍|done)\.?!?$/i;
+var EXPLANATION_MARKERS = /\b(because|the reason|design decision|trade-?off|instead of|rationale|so that)\b/i;
+var TRIVIAL_ACK = /^(ok|okay|thanks?|got it|sounds good|👍|done)\.?!?$/i;
 function scoreConversationTurn(userText, replyText) {
   const text = `${userText}
 ${replyText}`;
@@ -1265,63 +1612,6 @@ function collectConversationTurns(turns, projectId, opts = {}) {
   return turns.filter((t) => t.assistantText.length > 0).flatMap((turn) => toMemoryNodes(turn, projectId, opts));
 }
 
-// src/collectors/docs.ts
-var DEFAULT_MAX_BODY_CHARS2 = 2e3;
-var DEFAULT_MAX_CHUNK_CHARS2 = 1200;
-var MAX_TITLE_CHARS2 = 200;
-var EXPLANATION_MARKERS2 = /\b(because|the reason|design decision|trade-?off|instead of|rationale|why)\b/i;
-function scoreDocSection(path, heading, text) {
-  let score = 0.45;
-  if (EXPLANATION_MARKERS2.test(text)) score += 0.25;
-  if (/(^|\/)readme\.md$/i.test(path)) score += 0.1;
-  if (heading === null) score -= 0.1;
-  if (text.length < 80) score -= 0.15;
-  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
-}
-function slugify(heading, index) {
-  if (heading === null) return `_preamble-${index}`;
-  const slug = heading.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
-  return slug || `_section-${index}`;
-}
-function sectionTitle(path, heading, index, count) {
-  if (heading) return truncate(`${path} \u2014 ${heading}`, MAX_TITLE_CHARS2);
-  if (count > 1) return truncate(`${path} (part ${index + 1}/${count})`, MAX_TITLE_CHARS2);
-  return truncate(path, MAX_TITLE_CHARS2);
-}
-function toMemoryNodes2(file, projectId, opts = {}) {
-  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS2;
-  const maxChunk = opts.maxChunkChars ?? DEFAULT_MAX_CHUNK_CHARS2;
-  const chunks = chunkAssistantText(file.content, maxChunk);
-  if (chunks.length === 0) return [];
-  const seenSlugs = /* @__PURE__ */ new Map();
-  return chunks.map((chunk, index) => {
-    const baseSlug = slugify(chunk.heading, index);
-    const occurrence = seenSlugs.get(baseSlug) ?? 0;
-    seenSlugs.set(baseSlug, occurrence + 1);
-    const naturalKey = occurrence === 0 ? `${file.path}#${baseSlug}` : `${file.path}#${baseSlug}:${occurrence}`;
-    return {
-      id: makeNodeId(projectId, "doc_section", naturalKey),
-      kind: "doc_section",
-      projectId,
-      ts: file.ts,
-      source: "docs",
-      title: sectionTitle(file.path, chunk.heading, index, chunks.length),
-      body: truncate(chunk.text, maxBody),
-      files: [{ path: file.path, insertions: null, deletions: null, binary: false }],
-      signal: scoreDocSection(file.path, chunk.heading, chunk.text),
-      meta: {
-        path: file.path,
-        heading: chunk.heading,
-        chunkIndex: index,
-        chunkCount: chunks.length
-      }
-    };
-  });
-}
-function collectDocFiles(files, projectId, opts = {}) {
-  return files.flatMap((file) => toMemoryNodes2(file, projectId, opts));
-}
-
 // src/git/parse.ts
 var RECORD_SEP = "";
 var UNIT_SEP = "";
@@ -1431,8 +1721,182 @@ function unquoteGitPath(p) {
   return Buffer.from(bytes).toString("utf8");
 }
 
-// src/git/log.ts
+// src/git/diff.ts
+var GIT_DIFF_LOG_FORMAT = "%x1e%H%x1f%h%x1f%aI%x1f%s%x1f";
+var FIELD_COUNT2 = 5;
 var EMPTY_HISTORY = /does not have any commits yet|unknown revision|bad revision|ambiguous argument/i;
+function buildDiffLogArgs(opts = {}) {
+  const { rev = "HEAD", afterCommit, since, maxCount, contextLines = 3, paths } = opts;
+  const args = [
+    "log",
+    `--format=${GIT_DIFF_LOG_FORMAT}`,
+    "--patch",
+    "--no-color",
+    // A merge produces no patch at all unless `-m`/`--cc` is passed, and the
+    // combined diff those print is a different format from the one parsed
+    // here. Excluding merges up front keeps the parser honest about what it
+    // supports; the merge itself is still remembered as a `git_commit` node.
+    "--no-merges",
+    "--find-renames",
+    // Never run a user-configured textconv filter: it would execute an
+    // arbitrary program from repo config during a sync, and its output is not
+    // the diff we claim to be indexing.
+    "--no-textconv",
+    `--unified=${Math.max(0, contextLines)}`
+  ];
+  if (maxCount && maxCount > 0) args.push(`--max-count=${maxCount}`);
+  if (since) args.push(`--since=${since}`);
+  args.push(afterCommit ? `${afterCommit}..${rev}` : rev);
+  if (paths?.length) args.push("--", ...paths);
+  return args;
+}
+async function* readCommitDiffs(cwd, opts = {}) {
+  const args = buildDiffLogArgs(opts);
+  let buffer = "";
+  try {
+    for await (const chunk of gitStream(cwd, args)) {
+      buffer += chunk;
+      const { records, rest } = splitRecords(buffer);
+      buffer = rest;
+      for (const record of records) {
+        const commit = parseCommitDiffRecord(record);
+        if (commit) yield commit;
+      }
+    }
+  } catch (err) {
+    if (err instanceof GitError && EMPTY_HISTORY.test(err.stderr)) return;
+    throw err;
+  }
+  for (const record of splitRecords(buffer, true).records) {
+    const commit = parseCommitDiffRecord(record);
+    if (commit) yield commit;
+  }
+}
+function parseCommitDiffRecord(record) {
+  let payload = record;
+  while (payload.startsWith(RECORD_SEP)) payload = payload.slice(RECORD_SEP.length);
+  const parts = payload.split(UNIT_SEP);
+  if (parts.length < FIELD_COUNT2) return null;
+  const sha = parts[0] ?? "";
+  if (!/^[0-9a-f]{7,64}$/i.test(sha)) return null;
+  const patchBlock = parts[parts.length - 1] ?? "";
+  const subject = parts.slice(3, parts.length - 1).join(UNIT_SEP).trim();
+  return {
+    sha,
+    shortSha: parts[1] ?? "",
+    authoredAt: parts[2] ?? "",
+    subject,
+    files: parseFileDiffs(patchBlock)
+  };
+}
+var FILE_HEADER = "diff --git ";
+var HUNK_HEADER = /^@@ -\d+(?:,\d+)? \+\d+(?:,\d+)? @@/;
+function parseFileDiffs(block) {
+  const files = [];
+  let section = null;
+  const flush = () => {
+    if (!section) return;
+    const parsed = parseFileSection(section);
+    if (parsed) files.push(parsed);
+    section = null;
+  };
+  for (const raw of block.split("\n")) {
+    const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+    if (line.startsWith(FILE_HEADER)) {
+      flush();
+      section = [line];
+    } else if (section) {
+      section.push(line);
+    }
+  }
+  flush();
+  return files;
+}
+function parseFileSection(lines) {
+  let status = "modified";
+  let binary = false;
+  let fromPath = null;
+  let toPath = null;
+  let renamedFrom = null;
+  let hunkStart = -1;
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    if (HUNK_HEADER.test(line)) {
+      hunkStart = i;
+      break;
+    }
+    if (line.startsWith("new file mode")) status = "added";
+    else if (line.startsWith("deleted file mode")) status = "deleted";
+    else if (line.startsWith("rename from ")) renamedFrom = unquoteGitPath(line.slice("rename from ".length));
+    else if (line.startsWith("rename to ")) status = "renamed";
+    else if (line.startsWith("copy from ")) renamedFrom = unquoteGitPath(line.slice("copy from ".length));
+    else if (line.startsWith("Binary files ") || line.startsWith("GIT binary patch")) binary = true;
+    else if (line.startsWith("--- ")) fromPath = stripDiffPathPrefix(line.slice(4));
+    else if (line.startsWith("+++ ")) toPath = stripDiffPathPrefix(line.slice(4));
+  }
+  const header = parseDiffGitPaths(lines[0] ?? "");
+  const path = toPath ?? header.b ?? fromPath ?? header.a;
+  if (!path) return null;
+  const previousPath = renamedFrom ?? (status === "renamed" ? fromPath ?? header.a ?? void 0 : void 0);
+  if (binary || hunkStart === -1) {
+    return {
+      path,
+      ...previousPath && previousPath !== path ? { previousPath } : {},
+      status,
+      binary,
+      insertions: 0,
+      deletions: 0,
+      hunkCount: 0,
+      patch: ""
+    };
+  }
+  const hunkLines = lines.slice(hunkStart);
+  let insertions = 0;
+  let deletions = 0;
+  let hunkCount = 0;
+  for (const line of hunkLines) {
+    if (HUNK_HEADER.test(line)) hunkCount += 1;
+    else if (line.startsWith("+")) insertions += 1;
+    else if (line.startsWith("-")) deletions += 1;
+  }
+  return {
+    path,
+    ...previousPath && previousPath !== path ? { previousPath } : {},
+    status,
+    binary: false,
+    insertions,
+    deletions,
+    hunkCount,
+    patch: hunkLines.join("\n").trimEnd()
+  };
+}
+function stripDiffPathPrefix(raw) {
+  const cleaned = unquoteGitPath(raw.trim());
+  if (cleaned === "/dev/null") return null;
+  return cleaned.replace(/^[ab]\//, "");
+}
+function parseDiffGitPaths(headerLine) {
+  const rest = headerLine.slice(FILE_HEADER.length);
+  if (rest.startsWith('"')) {
+    const match = /^("(?:[^"\\]|\\.)*")\s+("(?:[^"\\]|\\.)*"|\S+)$/.exec(rest);
+    if (match) {
+      return { a: stripDiffPathPrefix(match[1] ?? ""), b: stripDiffPathPrefix(match[2] ?? "") };
+    }
+  }
+  const quotedSecond = /^(\S+)\s+("(?:[^"\\]|\\.)*")$/.exec(rest);
+  if (quotedSecond) {
+    return { a: stripDiffPathPrefix(quotedSecond[1] ?? ""), b: stripDiffPathPrefix(quotedSecond[2] ?? "") };
+  }
+  const split = / b\//.exec(rest);
+  if (!split || split.index <= 0) return { a: null, b: null };
+  return {
+    a: stripDiffPathPrefix(rest.slice(0, split.index)),
+    b: stripDiffPathPrefix(rest.slice(split.index + 1))
+  };
+}
+
+// src/git/log.ts
+var EMPTY_HISTORY2 = /does not have any commits yet|unknown revision|bad revision|ambiguous argument/i;
 function buildLogArgs(opts = {}) {
   const { rev = "HEAD", afterCommit, since, maxCount, includeMerges = true, paths } = opts;
   const args = ["log", `--format=${GIT_LOG_FORMAT}`, "--numstat", "--no-color"];
@@ -1457,7 +1921,7 @@ async function* readCommits(cwd, opts = {}) {
       }
     }
   } catch (err) {
-    if (err instanceof GitError && EMPTY_HISTORY.test(err.stderr)) return;
+    if (err instanceof GitError && EMPTY_HISTORY2.test(err.stderr)) return;
     throw err;
   }
   for (const record of splitRecords(buffer, true).records) {
@@ -1468,7 +1932,7 @@ async function* readCommits(cwd, opts = {}) {
 
 // src/collectors/git-commits.ts
 var DEFAULTS = { maxFilesPerNode: 40, maxBodyChars: 4e3 };
-var MAX_TITLE_CHARS3 = 200;
+var MAX_TITLE_CHARS2 = 200;
 var CONVENTIONAL = /^([a-z]+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/i;
 function parseConventionalHeader(subject) {
   const m = CONVENTIONAL.exec(subject.trim());
@@ -1537,7 +2001,7 @@ function toMemoryNode(commit, projectId, opts = {}) {
     projectId,
     ts: commit.authoredAt,
     source: "git",
-    title: truncate(commit.subject || `(no subject) ${commit.shortSha}`, MAX_TITLE_CHARS3),
+    title: truncate(commit.subject || `(no subject) ${commit.shortSha}`, MAX_TITLE_CHARS2),
     body: truncate(bodyParts.join("\n"), maxBody),
     files: keptFiles,
     signal: scoreCommit(commit),
@@ -1564,9 +2028,156 @@ async function* collectGitCommits(cwd, projectId, opts = {}) {
   }
 }
 
+// src/collectors/diffs.ts
+var DIFF_SOURCE = "diff";
+var DEFAULTS2 = { maxFilesPerCommit: 20, maxBodyChars: 2e3 };
+var MAX_TITLE_CHARS3 = 200;
+var GENERATED_PATHS = [
+  /(^|\/)(node_modules|dist|build|out|coverage|vendor|third_party)\//,
+  /(^|\/)(package-lock\.json|npm-shrinkwrap\.json|yarn\.lock|pnpm-lock\.yaml|composer\.lock|Cargo\.lock|poetry\.lock|Gemfile\.lock|go\.sum)$/,
+  /\.(min\.js|min\.css|map|snap)$/
+];
+function isGeneratedPath(path) {
+  return GENERATED_PATHS.some((re) => re.test(path));
+}
+var TEST_PATHS = /(^|\/)(tests?|__tests__|spec|e2e)\/|\.(test|spec)\.[cm]?[jt]sx?$/;
+function scoreFileDiff(subject, file) {
+  const header = parseConventionalHeader(subject);
+  let score = header.type ? TYPE_WEIGHTS[header.type] ?? 0.5 : 0.5;
+  if (header.breaking) score += 0.1;
+  if (TEST_PATHS.test(file.path)) score -= 0.1;
+  if (file.status === "added") score += 0.05;
+  if (file.status === "deleted") score -= 0.1;
+  const churn = file.insertions + file.deletions;
+  if (churn <= 2) score -= 0.05;
+  if (churn > 400) score *= 0.75;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+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));
+}
+var STATUS_LABEL = {
+  added: "added",
+  deleted: "deleted",
+  renamed: "renamed",
+  modified: "modified"
+};
+function fileTitle(shortSha, subject, file) {
+  return truncate(`${file.path} @ ${shortSha} \u2014 ${subject}`, MAX_TITLE_CHARS3);
+}
+function toMemoryNodes2(commit, projectId, opts = {}) {
+  const maxFiles = opts.maxFilesPerCommit ?? DEFAULTS2.maxFilesPerCommit;
+  const maxBody = opts.maxBodyChars ?? DEFAULTS2.maxBodyChars;
+  const kept = indexableFiles(commit.files).sort(byChurnDesc2).slice(0, maxFiles);
+  return kept.map((file) => {
+    const churn = `+${file.insertions}/-${file.deletions}`;
+    const renamePart = file.previousPath ? `, renamed from ${file.previousPath}` : "";
+    const head = [
+      `${commit.subject} (${commit.shortSha})`,
+      `${STATUS_LABEL[file.status]} ${file.path} (${churn}, ${file.hunkCount} hunk${file.hunkCount === 1 ? "" : "s"}${renamePart})`,
+      ""
+    ].join("\n");
+    const { text: patch } = redact(file.patch, "high-confidence");
+    return {
+      id: makeNodeId(projectId, "code_diff", `${commit.sha}:${file.path}`),
+      kind: "code_diff",
+      projectId,
+      ts: commit.authoredAt,
+      source: DIFF_SOURCE,
+      title: fileTitle(commit.shortSha, commit.subject, file),
+      body: truncate(head + patch, maxBody),
+      files: [
+        {
+          path: file.path,
+          ...file.previousPath ? { previousPath: file.previousPath } : {},
+          insertions: file.insertions,
+          deletions: file.deletions,
+          binary: false
+        }
+      ],
+      signal: scoreFileDiff(commit.subject, file),
+      meta: {
+        sha: commit.sha,
+        shortSha: commit.shortSha,
+        path: file.path,
+        status: file.status,
+        hunkCount: file.hunkCount,
+        insertions: file.insertions,
+        deletions: file.deletions,
+        subject: commit.subject
+      }
+    };
+  });
+}
+async function* collectCommitDiffs(cwd, projectId, opts = {}) {
+  for await (const commit of readCommitDiffs(cwd, opts)) {
+    for (const node of toMemoryNodes2(commit, projectId, opts)) yield node;
+  }
+}
+
+// src/collectors/docs.ts
+var DEFAULT_MAX_BODY_CHARS2 = 2e3;
+var DEFAULT_MAX_CHUNK_CHARS2 = 1200;
+var MAX_TITLE_CHARS4 = 200;
+var EXPLANATION_MARKERS2 = /\b(because|the reason|design decision|trade-?off|instead of|rationale|why)\b/i;
+function scoreDocSection(path, heading, text) {
+  let score = 0.45;
+  if (EXPLANATION_MARKERS2.test(text)) score += 0.25;
+  if (/(^|\/)readme\.md$/i.test(path)) score += 0.1;
+  if (heading === null) score -= 0.1;
+  if (text.length < 80) score -= 0.15;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+function slugify(heading, index) {
+  if (heading === null) return `_preamble-${index}`;
+  const slug = heading.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug || `_section-${index}`;
+}
+function sectionTitle(path, heading, index, count) {
+  if (heading) return truncate(`${path} \u2014 ${heading}`, MAX_TITLE_CHARS4);
+  if (count > 1) return truncate(`${path} (part ${index + 1}/${count})`, MAX_TITLE_CHARS4);
+  return truncate(path, MAX_TITLE_CHARS4);
+}
+function toMemoryNodes3(file, projectId, opts = {}) {
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS2;
+  const maxChunk = opts.maxChunkChars ?? DEFAULT_MAX_CHUNK_CHARS2;
+  const chunks = chunkAssistantText(file.content, maxChunk);
+  if (chunks.length === 0) return [];
+  const seenSlugs = /* @__PURE__ */ new Map();
+  return chunks.map((chunk, index) => {
+    const baseSlug = slugify(chunk.heading, index);
+    const occurrence = seenSlugs.get(baseSlug) ?? 0;
+    seenSlugs.set(baseSlug, occurrence + 1);
+    const naturalKey = occurrence === 0 ? `${file.path}#${baseSlug}` : `${file.path}#${baseSlug}:${occurrence}`;
+    return {
+      id: makeNodeId(projectId, "doc_section", naturalKey),
+      kind: "doc_section",
+      projectId,
+      ts: file.ts,
+      source: "docs",
+      title: sectionTitle(file.path, chunk.heading, index, chunks.length),
+      body: truncate(chunk.text, maxBody),
+      files: [{ path: file.path, insertions: null, deletions: null, binary: false }],
+      signal: scoreDocSection(file.path, chunk.heading, chunk.text),
+      meta: {
+        path: file.path,
+        heading: chunk.heading,
+        chunkIndex: index,
+        chunkCount: chunks.length
+      }
+    };
+  });
+}
+function collectDocFiles(files, projectId, opts = {}) {
+  return files.flatMap((file) => toMemoryNodes3(file, projectId, opts));
+}
+
 // src/collectors/shell-history.ts
 var DEFAULT_MAX_BODY_CHARS3 = 1e3;
-var MAX_TITLE_CHARS4 = 200;
+var MAX_TITLE_CHARS5 = 200;
 var NOISE = /^(cd|ls|dir|pwd|clear|cls|exit|history|whoami|date|type|cat|more|less|ll|la)\b/i;
 var BUILD_TEST = /^(npm|pnpm|yarn)\s+(run\s+)?(test|build|lint|typecheck|tsc)\b|^(pytest|go\s+test|cargo\s+(test|build)|mvn\s+test|gradle\s+test|dotnet\s+(test|build))\b/i;
 var INSTALL = /^(npm|pnpm|yarn)\s+(install|add|remove|uninstall|ci)\b|^pip\s+install\b|^(cargo\s+add|go\s+get|composer\s+require)\b/i;
@@ -1607,7 +2218,7 @@ function toMemoryNode2(entry, projectId, opts = {}) {
     projectId,
     ts: entry.ts,
     source: `shell:${entry.shell}`,
-    title: truncate(titleLine, MAX_TITLE_CHARS4),
+    title: truncate(titleLine, MAX_TITLE_CHARS5),
     body: renderBody(entry, maxBody),
     files: [],
     signal: scoreShellCommand(entry),
@@ -1626,24 +2237,24 @@ function collectShellHistory(entries, projectId, opts = {}) {
 }
 
 // src/conversation/claude-code-reader.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 
 // src/conversation/paths.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { readdir } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
 function claudeProjectSlug(repoRoot) {
   return repoRoot.replace(/[\\/:]/g, "-");
 }
 function claudeProjectTranscriptDir(repoRoot) {
-  return join3(homedir2(), ".claude", "projects", claudeProjectSlug(repoRoot));
+  return join5(homedir3(), ".claude", "projects", claudeProjectSlug(repoRoot));
 }
 async function listTranscriptFiles(repoRoot) {
   const dir = claudeProjectTranscriptDir(repoRoot);
-  if (!existsSync2(dir)) return [];
+  if (!existsSync3(dir)) return [];
   const entries = await readdir(dir, { withFileTypes: true });
-  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join3(dir, e.name));
+  return entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl")).map((e) => join5(dir, e.name));
 }
 
 // src/conversation/claude-code-reader.ts
@@ -1716,15 +2327,15 @@ async function collectClaudeCodeTranscripts(repoRoot) {
   const files = await listTranscriptFiles(repoRoot);
   const turns = [];
   for (const file of files) {
-    const raw = await readFile3(file, "utf8");
+    const raw = await readFile4(file, "utf8");
     turns.push(...parseClaudeCodeTranscript(raw));
   }
   return turns;
 }
 
 // src/docs/read.ts
-import { readFile as readFile4, stat } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile as readFile5, stat } from "fs/promises";
+import { join as join6 } from "path";
 var DEFAULT_PATHSPECS = ["*.md"];
 async function listDocFiles(repoRoot, opts = {}) {
   const pathspecs = opts.include ?? DEFAULT_PATHSPECS;
@@ -1737,11 +2348,11 @@ async function readDocFiles(repoRoot, opts = {}) {
   const unreadable = [];
   for (const relPath of paths) {
     const path = relPath.replace(/\\/g, "/");
-    const absPath = join4(repoRoot, relPath);
+    const absPath = join6(repoRoot, relPath);
     let content;
     let mtime;
     try {
-      [content, { mtime }] = await Promise.all([readFile4(absPath, "utf8"), stat(absPath)]);
+      [content, { mtime }] = await Promise.all([readFile5(absPath, "utf8"), stat(absPath)]);
     } catch {
       unreadable.push(path);
       continue;
@@ -1752,11 +2363,11 @@ async function readDocFiles(repoRoot, opts = {}) {
 }
 
 // src/shell/detect.ts
-import { existsSync as existsSync3 } from "fs";
-import { readFile as readFile6, stat as stat2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { readFile as readFile7, stat as stat2 } from "fs/promises";
 
 // src/shell/hook-log.ts
-import { appendFile, mkdir as mkdir3, readFile as readFile5 } from "fs/promises";
+import { appendFile, mkdir as mkdir4, readFile as readFile6 } from "fs/promises";
 import { dirname as dirname3 } from "path";
 function parseHookLogLine(line) {
   const trimmed = line.trim();
@@ -1781,7 +2392,7 @@ function parseHookLogLine(line) {
 async function readHookLog(path, fromLine) {
   let raw;
   try {
-    raw = await readFile5(path, "utf8");
+    raw = await readFile6(path, "utf8");
   } catch {
     return { entries: [], totalLines: fromLine };
   }
@@ -1914,8 +2525,8 @@ function hookEntryToRaw(e) {
   };
 }
 async function tryReadScrapeSource(path, parse, tailLines) {
-  if (!existsSync3(path)) return null;
-  const [raw, stats] = await Promise.all([readFile6(path, "utf8"), stat2(path)]);
+  if (!existsSync4(path)) return null;
+  const [raw, stats] = await Promise.all([readFile7(path, "utf8"), stat2(path)]);
   return parse(raw, stats.mtimeMs, { tailLines });
 }
 async function collectAvailableShellHistory(opts = {}) {
@@ -1923,7 +2534,7 @@ async function collectAvailableShellHistory(opts = {}) {
   const tailLines = opts.tailLines ?? 300;
   const preferHook = opts.preferHook ?? true;
   const hookPath = hookLogPath();
-  const hookExists = existsSync3(hookPath);
+  const hookExists = existsSync4(hookPath);
   if (hookExists) {
     const fromLine = Number(opts.hookCursor ?? "0") || 0;
     const { entries, totalLines } = await readHookLog(hookPath, fromLine);
@@ -1979,25 +2590,25 @@ function addStats(into, from) {
 async function syncGit(store, projectId, opts, repo, config, log) {
   const totals = { inserted: 0, updated: 0, unchanged: 0 };
   if (!repo.head) {
-    log(`${pc3.yellow("git")} skipped -- repository has no commits yet`);
+    log(`${pc4.yellow("git")} skipped -- repository has no commits yet`);
     return { totals, seen: 0 };
   }
   if (!config.sources.git.enabled) {
-    log(`${pc3.dim("git")} disabled in config`);
+    log(`${pc4.dim("git")} disabled in config`);
     return { totals, seen: 0 };
   }
   let cursor = opts.full || opts.rebuild ? null : store.getSyncCursor(projectId, GIT_SOURCE);
   if (cursor && !await isAncestor(repo.root, cursor, repo.head)) {
-    log(`${pc3.yellow("git cursor stale")} ${cursor.slice(0, 7)} is not an ancestor of HEAD \u2014 falling back to a full walk`);
+    log(`${pc4.yellow("git cursor stale")} ${cursor.slice(0, 7)} is not an ancestor of HEAD \u2014 falling back to a full walk`);
     cursor = null;
   }
   if (cursor === repo.head) {
-    log(`${pc3.green("git up to date")} at ${repo.head.slice(0, 7)}`);
+    log(`${pc4.green("git up to date")} at ${repo.head.slice(0, 7)}`);
     store.setSyncCursor(projectId, GIT_SOURCE, repo.head);
     return { totals, seen: 0 };
   }
   log(
-    `${pc3.dim("git syncing")} ${repo.branch ?? "HEAD"} ${cursor ? `${cursor.slice(0, 7)}..${repo.head.slice(0, 7)}` : "(full history)"}`
+    `${pc4.dim("git syncing")} ${repo.branch ?? "HEAD"} ${cursor ? `${cursor.slice(0, 7)}..${repo.head.slice(0, 7)}` : "(full history)"}`
   );
   let batch = [];
   let seen = 0;
@@ -2005,7 +2616,7 @@ async function syncGit(store, projectId, opts, repo, config, log) {
     if (batch.length === 0) return;
     addStats(totals, store.upsertNodes(batch));
     batch = [];
-    log(`  ${pc3.dim(`${seen} commits read, ${totals.inserted} new`)}`);
+    log(`  ${pc4.dim(`${seen} commits read, ${totals.inserted} new`)}`);
   };
   const nodes = collectGitCommits(repo.root, projectId, {
     afterCommit: cursor,
@@ -2023,10 +2634,51 @@ async function syncGit(store, projectId, opts, repo, config, log) {
   store.setSyncCursor(projectId, GIT_SOURCE, repo.head);
   return { totals, seen };
 }
+async function syncDiffs(store, projectId, opts, repo, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0 };
+  if (!repo.head) return { totals, seen: 0 };
+  if (!config.sources.diff.enabled) {
+    log(`${pc4.dim("diff")} disabled in config`);
+    return { totals, seen: 0 };
+  }
+  let cursor = opts.full || opts.rebuild ? null : store.getSyncCursor(projectId, DIFF_SOURCE);
+  if (cursor && !await isAncestor(repo.root, cursor, repo.head)) {
+    log(`${pc4.yellow("diff cursor stale")} ${cursor.slice(0, 7)} is not an ancestor of HEAD \u2014 falling back to a bounded walk`);
+    cursor = null;
+  }
+  if (cursor === repo.head) {
+    store.setSyncCursor(projectId, DIFF_SOURCE, repo.head);
+    return { totals, seen: 0 };
+  }
+  let batch = [];
+  let seen = 0;
+  const flush = () => {
+    if (batch.length === 0) return;
+    addStats(totals, store.upsertNodes(batch));
+    batch = [];
+  };
+  const nodes = collectCommitDiffs(repo.root, projectId, {
+    afterCommit: cursor,
+    since: opts.since ?? config.sources.git.since,
+    maxCount: config.sources.diff.maxCommits,
+    maxFilesPerCommit: config.sources.diff.maxFilesPerCommit,
+    contextLines: config.sources.diff.contextLines,
+    maxBodyChars: config.limits.maxBodyChars
+  });
+  for await (const node of nodes) {
+    batch.push(node);
+    seen += 1;
+    if (batch.length >= BATCH_SIZE) flush();
+  }
+  flush();
+  store.setSyncCursor(projectId, DIFF_SOURCE, repo.head);
+  log(`  ${pc4.dim(`${DIFF_SOURCE}: ${seen} file diff(s) read`)}`);
+  return { totals, seen };
+}
 async function syncShell(store, projectId, opts, repoRoot, config, log) {
   const totals = { inserted: 0, updated: 0, unchanged: 0 };
   if (!config.sources.shell.enabled) {
-    log(`${pc3.dim("shell")} disabled in config`);
+    log(`${pc4.dim("shell")} disabled in config`);
     return { totals, seen: 0 };
   }
   const results = await collectAvailableShellHistory({
@@ -2035,7 +2687,7 @@ async function syncShell(store, projectId, opts, repoRoot, config, log) {
     hookCursor: store.getSyncCursor(projectId, "shell:pwsh-hook")
   });
   if (results.length === 0) {
-    log(`${pc3.dim("shell")} no history source found on this machine`);
+    log(`${pc4.dim("shell")} no history source found on this machine`);
     return { totals, seen: 0 };
   }
   let seen = 0;
@@ -2047,7 +2699,7 @@ async function syncShell(store, projectId, opts, repoRoot, config, log) {
       addStats(totals, store.upsertNodes(nodes));
     }
     store.setSyncCursor(projectId, sourceKey, result.cursorAfter ?? `scanned:${result.entries.length}`);
-    log(`  ${pc3.dim(`${sourceKey}: ${nodes.length} entr${nodes.length === 1 ? "y" : "ies"} read`)}`);
+    log(`  ${pc4.dim(`${sourceKey}: ${nodes.length} entr${nodes.length === 1 ? "y" : "ies"} read`)}`);
   }
   return { totals, seen };
 }
@@ -2060,20 +2712,20 @@ async function syncConversation(store, projectId, repoRoot, config, log, forceEn
   }
   const turns = await collectClaudeCodeTranscripts(repoRoot);
   if (turns.length === 0) {
-    log(`${pc3.dim("conversation")} no transcripts found`);
+    log(`${pc4.dim("conversation")} no transcripts found`);
     return { totals, seen: 0 };
   }
   const nodes = collectConversationTurns(turns, projectId, { maxBodyChars: config.limits.maxBodyChars });
   if (nodes.length > 0) addStats(totals, store.upsertNodes(nodes));
   store.setSyncCursor(projectId, CONVERSATION_SOURCE, `scanned:${nodes.length}`);
-  log(`  ${pc3.dim(`${CONVERSATION_SOURCE}: ${nodes.length} of ${turns.length} exchange(s) kept`)}`);
+  log(`  ${pc4.dim(`${CONVERSATION_SOURCE}: ${nodes.length} of ${turns.length} exchange(s) kept`)}`);
   return { totals, seen: nodes.length };
 }
 var DOCS_SOURCE = "docs";
 async function syncDocs(store, projectId, repoRoot, config, log) {
   const totals = { inserted: 0, updated: 0, unchanged: 0 };
   if (!config.sources.docs.enabled) {
-    log(`${pc3.dim("docs")} disabled in config`);
+    log(`${pc4.dim("docs")} disabled in config`);
     return { totals, seen: 0 };
   }
   const { files, unreadable } = await readDocFiles(repoRoot, { include: config.sources.docs.include });
@@ -2087,11 +2739,11 @@ async function syncDocs(store, projectId, repoRoot, config, log) {
   );
   store.setSyncCursor(projectId, DOCS_SOURCE, `scanned:${nodes.length}`);
   if (files.length === 0 && unreadable.length === 0) {
-    log(`${pc3.dim("docs")} no tracked .md files found`);
+    log(`${pc4.dim("docs")} no tracked .md files found`);
   } else {
-    const prunedPart = pruned > 0 ? `, ${pc3.yellow(`${pruned} stale removed`)}` : "";
+    const prunedPart = pruned > 0 ? `, ${pc4.yellow(`${pruned} stale removed`)}` : "";
     const skippedPart = unreadable.length > 0 ? `, ${unreadable.length} unreadable (kept)` : "";
-    log(`  ${pc3.dim(`${DOCS_SOURCE}: ${nodes.length} section(s) from ${files.length} file(s)`)}${prunedPart}${pc3.dim(skippedPart)}`);
+    log(`  ${pc4.dim(`${DOCS_SOURCE}: ${nodes.length} section(s) from ${files.length} file(s)`)}${prunedPart}${pc4.dim(skippedPart)}`);
   }
   return { totals, seen: nodes.length };
 }
@@ -2106,11 +2758,13 @@ async function runSync(opts) {
   const started = Date.now();
   try {
     store.upsertProject({ id: projectId, root: repo.root, originUrl: repo.originUrl });
+    await recordProject({ projectId, root: repo.root, dbPath: ws.dbPath, originUrl: repo.originUrl });
     if (opts.rebuild) {
       const removed = store.clearProject(projectId);
-      log(`${pc3.dim("rebuild")} dropped ${removed} existing node(s)`);
+      log(`${pc4.dim("rebuild")} dropped ${removed} existing node(s)`);
     }
     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 conversation = await syncConversation(store, projectId, repo.root, config, log, opts.conversationOverride);
     const docs = await syncDocs(store, projectId, repo.root, config, log);
@@ -2118,15 +2772,16 @@ async function runSync(opts) {
     if (!opts.noEmbed) {
       const result = await embedPendingNodes(store, new OllamaEmbeddingProvider(), projectId);
       if (result.embedded > 0) {
-        embedLine = `  ${pc3.dim(`vector: ${result.embedded} node(s) embedded`)}${result.skipped > 0 ? pc3.dim(`, ${result.skipped} skipped`) : ""}
+        embedLine = `  ${pc4.dim(`vector: ${result.embedded} node(s) embedded`)}${result.skipped > 0 ? pc4.dim(`, ${result.skipped} skipped`) : ""}
 `;
       } else if (result.providerUnavailable) {
-        log(`${pc3.dim("vector")} embedding provider unavailable (is Ollama running with nomic-embed-text pulled?) -- BM25-only for now`);
+        log(`${pc4.dim("vector")} embedding provider unavailable (is Ollama running with nomic-embed-text pulled?) -- BM25-only for now`);
       }
     }
     store.markSynced(projectId);
     const totals = { inserted: 0, updated: 0, unchanged: 0 };
     addStats(totals, git2.totals);
+    addStats(totals, diffs.totals);
     addStats(totals, shell.totals);
     addStats(totals, conversation.totals);
     addStats(totals, docs.totals);
@@ -2135,11 +2790,12 @@ async function runSync(opts) {
     const conversationEnabled = opts.conversationOverride ?? config.sources.conversation.enabled;
     const conversationPart = conversationEnabled ? `, ${conversation.seen} conversation exchange(s)` : "";
     const docsPart = config.sources.docs.enabled ? `, ${docs.seen} doc section(s)` : "";
+    const diffPart = config.sources.diff.enabled ? `, ${diffs.seen} file diff(s)` : "";
     out(
       [
-        `${pc3.green("synced")} ${git2.seen} commit(s), ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${docsPart} in ${elapsed}s`,
-        `  ${pc3.green(`+${totals.inserted} new`)}  ${pc3.yellow(`~${totals.updated} updated`)}  ${pc3.dim(`=${totals.unchanged} unchanged`)}`,
-        `  ${pc3.dim(`${stats.total} node(s) total across ${stats.distinctFiles} file path(s)`)}`,
+        `${pc4.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${docsPart} in ${elapsed}s`,
+        `  ${pc4.green(`+${totals.inserted} new`)}  ${pc4.yellow(`~${totals.updated} updated`)}  ${pc4.dim(`=${totals.unchanged} unchanged`)}`,
+        `  ${pc4.dim(`${stats.total} node(s) total across ${stats.distinctFiles} file path(s)`)}`,
         ""
       ].join("\n") + embedLine
     );
@@ -2156,20 +2812,39 @@ async function searchMemory(input) {
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
   const budget = input.budget ?? 2e3;
   const candidates = input.candidates ?? 30;
+  const queryOpts = {
+    budget,
+    candidates,
+    embeddingProvider: input.noVector ? null : new OllamaEmbeddingProvider()
+  };
+  if (input.allProjects) {
+    const opened = await openAllProjectSources({ projectId, root: repo.root, dbPath: ws.dbPath });
+    try {
+      const { bm25Count, vectorCount, hits, packed } = await runCrossProjectQuery(opened.sources, input.query, queryOpts);
+      return {
+        text: renderContextBlock(input.query, packed),
+        matched: hits.length,
+        bm25Matched: bm25Count,
+        vectorMatched: vectorCount,
+        tokensUsed: packed.tokensUsed,
+        tokensBudget: packed.tokensBudget,
+        projectsSearched: opened.sources.map((s) => s.label)
+      };
+    } finally {
+      opened.close();
+    }
+  }
   const store = MemoryStore.open(ws.dbPath);
   try {
-    const { bm25Count, vectorCount, hits, packed } = await runHybridQuery(store, projectId, input.query, {
-      budget,
-      candidates,
-      embeddingProvider: input.noVector ? null : new OllamaEmbeddingProvider()
-    });
+    const { bm25Count, vectorCount, hits, packed } = await runHybridQuery(store, projectId, input.query, queryOpts);
     return {
       text: renderContextBlock(input.query, packed),
       matched: hits.length,
       bm25Matched: bm25Count,
       vectorMatched: vectorCount,
       tokensUsed: packed.tokensUsed,
-      tokensBudget: packed.tokensBudget
+      tokensBudget: packed.tokensBudget,
+      projectsSearched: [basename2(repo.root) || repo.root]
     };
   } finally {
     store.close();
@@ -2207,20 +2882,23 @@ async function getStatus(input) {
 
 // src/mcp/server.ts
 function createServer() {
-  const server = new McpServer({ name: "nexusmem", version: "0.1.0" });
+  const server = new McpServer({ name: "nexusmem", version: readOwnVersion() });
   server.registerTool(
     "search_memory",
     {
       title: "Search remembered project history",
-      description: "Search a NexusMem-tracked repository's remembered history: git commits, shell commands, tracked markdown docs, and (if enabled) conversation transcripts. Returns a token-budgeted, ranked context block -- not raw search results.",
+      description: "Search a NexusMem-tracked repository's remembered history: git commits, code diffs (the patch of each changed file), shell commands, tracked markdown docs, and (if enabled) conversation transcripts. Returns a token-budgeted, ranked context block -- not raw search results.",
       inputSchema: {
-        projectRoot: z2.string().describe("Absolute path to the repository root"),
-        query: z2.string().describe("Free-text question or search terms"),
-        budget: z2.number().int().positive().optional().describe("Max tokens in the returned context block. Default 2000.")
+        projectRoot: z3.string().describe("Absolute path to the repository root"),
+        query: z3.string().describe("Free-text question or search terms"),
+        budget: z3.number().int().positive().optional().describe("Max tokens in the returned context block. Default 2000."),
+        allProjects: z3.boolean().optional().describe(
+          "Search every repository NexusMem has been run in on this machine, not just projectRoot. Use when the answer may live in a different project (a pattern solved elsewhere, a tool that failed the same way before). Each result is tagged with its repository."
+        )
       }
     },
-    async ({ projectRoot, query, budget }) => {
-      const result = await searchMemory({ projectRoot, query, budget });
+    async ({ projectRoot, query, budget, allProjects }) => {
+      const result = await searchMemory({ projectRoot, query, budget, allProjects });
       return {
         content: [{ type: "text", text: result.text }],
         structuredContent: {
@@ -2229,7 +2907,8 @@ function createServer() {
           bm25Matched: result.bm25Matched,
           vectorMatched: result.vectorMatched,
           tokensUsed: result.tokensUsed,
-          tokensBudget: result.tokensBudget
+          tokensBudget: result.tokensBudget,
+          projectsSearched: result.projectsSearched
         }
       };
     }
@@ -2238,9 +2917,9 @@ function createServer() {
     "sync_project",
     {
       title: "Sync remembered history",
-      description: "Ingest new git, shell, docs and (if enabled) conversation history for a NexusMem-tracked repository into its local database.",
+      description: "Ingest new git, diff, shell, docs and (if enabled) conversation history for a NexusMem-tracked repository into its local database.",
       inputSchema: {
-        projectRoot: z2.string().describe("Absolute path to the repository root")
+        projectRoot: z3.string().describe("Absolute path to the repository root")
       }
     },
     async ({ projectRoot }) => {
@@ -2254,7 +2933,7 @@ function createServer() {
       title: "Show what is remembered",
       description: "Report how many nodes NexusMem currently remembers for a repository, broken down by kind and source.",
       inputSchema: {
-        projectRoot: z2.string().describe("Absolute path to the repository root")
+        projectRoot: z3.string().describe("Absolute path to the repository root")
       }
     },
     async ({ projectRoot }) => {
@@ -2274,17 +2953,41 @@ async function runMcpServer() {
 }
 
 // src/cli/commands/query.ts
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 async function runQuery(opts) {
-  const { ws, projectId } = await loadContext(opts.cwd);
-  const store = MemoryStore.open(ws.dbPath);
+  const { repo, ws, projectId } = await loadContext(opts.cwd);
+  const opened = opts.allProjects ? await openAllProjectSources({ projectId, root: repo.root, dbPath: ws.dbPath }) : null;
+  let store = null;
   try {
-    const { bm25Count, vectorCount, hits, packed } = await runHybridQuery(store, projectId, opts.query, {
+    const queryOpts = {
       budget: opts.budget,
       candidates: opts.candidates,
       halfLifeDays: opts.halfLifeDays,
       embeddingProvider: opts.noVector ? null : new OllamaEmbeddingProvider()
-    });
+    };
+    let result;
+    if (opened) {
+      result = await runCrossProjectQuery(opened.sources, opts.query, queryOpts);
+    } else {
+      store = MemoryStore.open(ws.dbPath);
+      result = await runHybridQuery(store, projectId, opts.query, queryOpts);
+    }
+    const { bm25Count, vectorCount, hits, packed } = result;
+    if (opened && !opts.json) {
+      const searched = opened.sources.map((s) => s.label).join(", ");
+      process.stderr.write(`${pc5.dim("scope  ")} ${opened.sources.length} project(s): ${searched}
+`);
+      for (const { entry } of opened.unreadable) {
+        process.stderr.write(`${pc5.yellow("unreadable")} ${entry.root} -- skipped
+`);
+      }
+      if (opened.missing.length > 0) {
+        process.stderr.write(
+          `${pc5.dim("skipped")} ${opened.missing.length} registered project(s) whose database is not on disk ${pc5.dim("(nexusmem projects --prune to forget them)")}
+`
+        );
+      }
+    }
     const matched = hits.length;
     const rawTokens = hits.reduce((n, h) => n + approxTokens(h.body), 0);
     const packerEfficiency = rawTokens > 0 ? 1 - packed.tokensUsed / rawTokens : 0;
@@ -2309,15 +3012,15 @@ async function runQuery(opts) {
       return 0;
     }
     if (matched === 0) {
-      process.stderr.write(`${pc4.yellow("no matches")} for "${opts.query}"
+      process.stderr.write(`${pc5.yellow("no matches")} for "${opts.query}"
 `);
       return 0;
     }
     process.stderr.write(
       [
-        `${pc4.dim("matched")} ${bm25Count} bm25${vectorCount > 0 ? ` + ${vectorCount} vector` : ""}, packed ${pc4.bold(String(packed.nodes.length))} into budget`,
-        `${pc4.dim("tokens ")} ${packed.tokensUsed}/${packed.tokensBudget}` + (packed.droppedForBudget ? pc4.dim(`  (${packed.droppedForBudget} dropped for budget)`) : ""),
-        rawTokens > 0 ? `${pc4.dim("vs raw ")} ${rawTokens} tokens if these same matches were sent unpacked  ${packerEfficiency >= 0 ? pc4.green(`(${(packerEfficiency * 100).toFixed(0)}% packer efficiency)`) : pc4.yellow(`(${(-packerEfficiency * 100).toFixed(0)}% larger -- overhead dominates on small result sets)`)}` : "",
+        `${pc5.dim("matched")} ${bm25Count} bm25${vectorCount > 0 ? ` + ${vectorCount} vector` : ""}, packed ${pc5.bold(String(packed.nodes.length))} into budget`,
+        `${pc5.dim("tokens ")} ${packed.tokensUsed}/${packed.tokensBudget}` + (packed.droppedForBudget ? pc5.dim(`  (${packed.droppedForBudget} dropped for budget)`) : ""),
+        rawTokens > 0 ? `${pc5.dim("vs raw ")} ${rawTokens} tokens if these same matches were sent unpacked  ${packerEfficiency >= 0 ? pc5.green(`(${(packerEfficiency * 100).toFixed(0)}% packer efficiency)`) : pc5.yellow(`(${(-packerEfficiency * 100).toFixed(0)}% larger -- overhead dominates on small result sets)`)}` : "",
         ""
       ].filter(Boolean).join("\n")
     );
@@ -2325,28 +3028,30 @@ async function runQuery(opts) {
 `);
     return 0;
   } finally {
-    store.close();
+    opened?.close();
+    store?.close();
   }
 }
 
 // src/cli/commands/scan-conversation.ts
-import pc6 from "picocolors";
+import pc7 from "picocolors";
 
 // src/cli/format.ts
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 var GIT_SIGNAL_BANDS = { high: 0.7, medium: 0.45 };
 var SHELL_SIGNAL_BANDS = { high: 0.6, medium: 0.4 };
 var CONVERSATION_SIGNAL_BANDS = { high: 0.55, medium: 0.35 };
 var DOCS_SIGNAL_BANDS = { high: 0.55, medium: 0.35 };
+var DIFF_SIGNAL_BANDS = { high: 0.7, medium: 0.45 };
 function signalBand(signal, bands) {
   if (signal >= bands.high) return "high";
   if (signal >= bands.medium) return "medium";
   return "low";
 }
 var BAND_COLOR = {
-  high: pc5.green,
-  medium: pc5.yellow,
-  low: pc5.dim
+  high: pc6.green,
+  medium: pc6.yellow,
+  low: pc6.dim
 };
 function formatSignal(signal, bands) {
   return BAND_COLOR[signalBand(signal, bands)](signal.toFixed(2));
@@ -2359,9 +3064,9 @@ async function runScanConversation(opts) {
   const files = await listTranscriptFiles(repo.root);
   if (!opts.json) {
     process.stderr.write(
-      files.length ? `${pc6.dim("transcripts")} ${files.length} file(s) in ${claudeProjectTranscriptDir(repo.root)}
+      files.length ? `${pc7.dim("transcripts")} ${files.length} file(s) in ${claudeProjectTranscriptDir(repo.root)}
 
-` : `${pc6.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
+` : `${pc7.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
 `
     );
   }
@@ -2378,7 +3083,7 @@ async function runScanConversation(opts) {
   const approxTotal = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
   process.stderr.write(
     `
-${pc6.bold(String(nodes.length))} of ${turns.length} exchange(s) above threshold  ${pc6.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}` + (redactedTotal > 0 ? `  ${pc6.yellow(`${redactedTotal} secret-like value(s) redacted`)}` : "") + "\n"
+${pc7.bold(String(nodes.length))} of ${turns.length} exchange(s) above threshold  ${pc7.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}` + (redactedTotal > 0 ? `  ${pc7.yellow(`${redactedTotal} secret-like value(s) redacted`)}` : "") + "\n"
   );
   return 0;
 }
@@ -2386,44 +3091,8 @@ function formatNode(node) {
   return [formatSignal(node.signal, CONVERSATION_SIGNAL_BANDS), node.ts.slice(0, 16).replace("T", " "), node.title].join(" ");
 }
 
-// src/cli/commands/scan-docs.ts
-import pc7 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);
-  if (!opts.json) {
-    process.stderr.write(
-      files.length ? `${pc7.dim("tracked .md files")} ${files.map((f) => f.path).join(", ")}
-
-` : `${pc7.yellow("no tracked .md files found")}
-`
-    );
-    if (unreadable.length > 0) {
-      process.stderr.write(`${pc7.yellow("unreadable")} ${unreadable.join(", ")}
-
-`);
-    }
-  }
-  const nodes = collectDocFiles(files, projectId).filter((n) => n.signal >= opts.minSignal);
-  if (opts.json) {
-    process.stdout.write(`${JSON.stringify(nodes, null, 2)}
-`);
-    return 0;
-  }
-  for (const node of nodes) process.stdout.write(`${formatNode2(node)}
-`);
-  const approxTotal = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
-  process.stderr.write(
-    `
-${pc7.bold(String(nodes.length))} section(s) from ${files.length} file(s) above threshold  ${pc7.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
-`
-  );
-  return 0;
-}
-function formatNode2(node) {
-  return [formatSignal(node.signal, DOCS_SIGNAL_BANDS), node.title].join(" ");
-}
+// src/cli/commands/scan-diff.ts
+import pc9 from "picocolors";
 
 // src/cli/commands/scan-git.ts
 import pc8 from "picocolors";
@@ -2450,7 +3119,7 @@ async function runScanGit(opts) {
   for await (const node of collectGitCommits(repo.root, projectId, collectOpts)) {
     if (node.signal < opts.minSignal) continue;
     nodes.push(node);
-    if (!opts.json) process.stdout.write(`${formatNode3(node)}
+    if (!opts.json) process.stdout.write(`${formatNode2(node)}
 `);
   }
   if (opts.json) {
@@ -2463,7 +3132,7 @@ ${summarize2(nodes)}
 `);
   return 0;
 }
-function formatNode3(node) {
+function formatNode2(node) {
   const sha = String(node.meta.shortSha ?? "").padEnd(9);
   const date = node.ts.slice(0, 10);
   const files = Number(node.meta.filesChanged ?? 0);
@@ -2494,17 +3163,103 @@ ${hottest.join("\n")}` : ""
   ].filter(Boolean).join("\n");
 }
 
+// src/cli/commands/scan-diff.ts
+var DEFAULT_SCAN_COMMITS = 50;
+async function runScanDiff(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  if (!opts.json) {
+    process.stderr.write(
+      [
+        `${pc9.dim("repo   ")} ${repo.root}`,
+        `${pc9.dim("branch ")} ${repo.branch ?? pc9.yellow("(detached)")}`,
+        `${pc9.dim("project")} ${pc9.cyan(projectId)}`,
+        ""
+      ].join("\n")
+    );
+  }
+  const nodes = [];
+  for await (const node of collectCommitDiffs(repo.root, projectId, {
+    since: opts.since ?? null,
+    maxCount: opts.limit ?? DEFAULT_SCAN_COMMITS
+  })) {
+    if (node.signal < opts.minSignal) continue;
+    nodes.push(node);
+    if (!opts.json) process.stdout.write(`${formatNode3(node)}
+`);
+  }
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(nodes, null, 2)}
+`);
+    return 0;
+  }
+  process.stderr.write(`
+${summarize2(nodes)}
+`);
+  return 0;
+}
+function formatNode3(node) {
+  const sha = String(node.meta.shortSha ?? "").padEnd(9);
+  const churn = `+${node.meta.insertions ?? 0}/-${node.meta.deletions ?? 0}`;
+  return [
+    formatSignal(node.signal, DIFF_SIGNAL_BANDS),
+    pc9.dim(node.ts.slice(0, 10)),
+    pc9.magenta(sha),
+    String(node.meta.path ?? ""),
+    pc9.dim(`(${churn}, ${node.meta.hunkCount ?? 0} hunk(s))`)
+  ].join(" ");
+}
+
+// src/cli/commands/scan-docs.ts
+import pc10 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);
+  if (!opts.json) {
+    process.stderr.write(
+      files.length ? `${pc10.dim("tracked .md files")} ${files.map((f) => f.path).join(", ")}
+
+` : `${pc10.yellow("no tracked .md files found")}
+`
+    );
+    if (unreadable.length > 0) {
+      process.stderr.write(`${pc10.yellow("unreadable")} ${unreadable.join(", ")}
+
+`);
+    }
+  }
+  const nodes = collectDocFiles(files, projectId).filter((n) => n.signal >= opts.minSignal);
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(nodes, null, 2)}
+`);
+    return 0;
+  }
+  for (const node of nodes) process.stdout.write(`${formatNode4(node)}
+`);
+  const approxTotal = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
+  process.stderr.write(
+    `
+${pc10.bold(String(nodes.length))} section(s) from ${files.length} file(s) above threshold  ${pc10.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+`
+  );
+  return 0;
+}
+function formatNode4(node) {
+  return [formatSignal(node.signal, DOCS_SIGNAL_BANDS), node.title].join(" ");
+}
+
 // src/cli/commands/scan-shell.ts
-import pc9 from "picocolors";
+import pc11 from "picocolors";
 async function runScanShell(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
   const results = await collectAvailableShellHistory({ tailLines: opts.tailLines, repoRoot: repo.root });
   if (!opts.json) {
     process.stderr.write(
-      results.length ? `${pc9.dim("sources found")} ${results.map((r) => r.name).join(", ")}
+      results.length ? `${pc11.dim("sources found")} ${results.map((r) => r.name).join(", ")}
 
-` : `${pc9.yellow("no shell history source found on this machine")}
+` : `${pc11.yellow("no shell history source found on this machine")}
 `
     );
   }
@@ -2513,9 +3268,9 @@ async function runScanShell(opts) {
     const nodes = collectShellHistory(result.entries, projectId).filter((n) => n.signal >= opts.minSignal);
     allNodes.push(...nodes);
     if (!opts.json) {
-      process.stdout.write(`${pc9.bold(`shell:${result.name}`)} ${pc9.dim(`(${nodes.length} of ${result.entries.length} above threshold)`)}
+      process.stdout.write(`${pc11.bold(`shell:${result.name}`)} ${pc11.dim(`(${nodes.length} of ${result.entries.length} above threshold)`)}
 `);
-      for (const node of nodes) process.stdout.write(`${formatNode4(node)}
+      for (const node of nodes) process.stdout.write(`${formatNode5(node)}
 `);
       process.stdout.write("\n");
     }
@@ -2526,20 +3281,20 @@ async function runScanShell(opts) {
     return 0;
   }
   const approxTotal = allNodes.reduce((n, x) => n + approxTokens(x.body), 0);
-  process.stderr.write(`${pc9.bold(String(allNodes.length))} node(s) total  ${pc9.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+  process.stderr.write(`${pc11.bold(String(allNodes.length))} node(s) total  ${pc11.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
 `);
   return 0;
 }
-function formatNode4(node) {
-  const approx = node.meta.tsApprox ? pc9.dim("~") : " ";
+function formatNode5(node) {
+  const approx = node.meta.tsApprox ? pc11.dim("~") : " ";
   const exit = node.meta.exitCode;
-  const exitLabel = typeof exit === "number" && exit !== 0 ? pc9.red(`exit ${exit}`) : "";
+  const exitLabel = typeof exit === "number" && exit !== 0 ? pc11.red(`exit ${exit}`) : "";
   return [formatSignal(node.signal, SHELL_SIGNAL_BANDS), approx + node.ts.slice(0, 16).replace("T", " "), node.title, exitLabel].filter(Boolean).join(" ");
 }
 
 // src/cli/commands/status.ts
 import { statSync } from "fs";
-import pc10 from "picocolors";
+import pc12 from "picocolors";
 function humanBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -2564,23 +3319,23 @@ async function runStatus(opts) {
     const kinds = Object.entries(stats.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
     process.stdout.write(
       [
-        `${pc10.dim("repo    ")} ${repo.root}`,
-        `${pc10.dim("branch  ")} ${repo.branch ?? pc10.yellow("(detached)")}`,
-        `${pc10.dim("project ")} ${pc10.cyan(projectId)}`,
-        `${pc10.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc10.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
-        `${pc10.dim("database")} ${ws.dbPath} ${pc10.dim(`(${humanBytes(dbBytes)})`)}`,
+        `${pc12.dim("repo    ")} ${repo.root}`,
+        `${pc12.dim("branch  ")} ${repo.branch ?? pc12.yellow("(detached)")}`,
+        `${pc12.dim("project ")} ${pc12.cyan(projectId)}`,
+        `${pc12.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc12.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
+        `${pc12.dim("database")} ${ws.dbPath} ${pc12.dim(`(${humanBytes(dbBytes)})`)}`,
         "",
-        `${pc10.bold(String(stats.total))} node(s)${stats.total ? ` ${pc10.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
+        `${pc12.bold(String(stats.total))} node(s)${stats.total ? ` ${pc12.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
         ...kinds,
-        stats.total ? `    ${pc10.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
+        stats.total ? `    ${pc12.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
         "",
-        sources.length ? pc10.dim("sources") : pc10.yellow("no sources synced yet"),
+        sources.length ? pc12.dim("sources") : pc12.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)} ${pc10.dim(`last run ${when}`)}  ${pc10.dim(`cursor ${cursorLabel}`)}`;
+          return `    ${s.source.padEnd(14)} ${pc12.dim(`last run ${when}`)}  ${pc12.dim(`cursor ${cursorLabel}`)}`;
         }),
-        gitCursor && gitCursor !== repo.head ? `${pc10.yellow("git behind HEAD")} \u2014 run ${pc10.bold("nexusmem sync")}` : "",
+        gitCursor && gitCursor !== repo.head ? `${pc12.yellow("git behind HEAD")} \u2014 run ${pc12.bold("nexusmem sync")}` : "",
         ""
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
@@ -2604,7 +3359,7 @@ function guard(run) {
       process.exitCode = await run();
     } catch (err) {
       if (isExpected(err)) {
-        process.stderr.write(`${pc11.red("error")} ${err.message}
+        process.stderr.write(`${pc13.red("error")} ${err.message}
 `);
         process.exitCode = 1;
         return;
@@ -2614,7 +3369,7 @@ function guard(run) {
   };
 }
 var program = new Command();
-program.name("nexusmem").description("NexusMem \u2014 local-first persistent memory for AI coding agents").version("0.1.0");
+program.name("nexusmem").description("NexusMem \u2014 local-first persistent memory for AI coding agents").version(readOwnVersion());
 program.command("init").description("Create the .nexusmem workspace and database for this repository").option("-C, --cwd <path>", "repository path", process.cwd()).option("--force", "overwrite an existing config (the database is kept)", false).option("--hook", "also install the opt-in PowerShell hook (cwd + exit code + timestamp)", false).option("--enable-conversation", "opt in to the conversation-transcript source (off by default -- see docs/phase-2-spec.md)", false).action(
   (options) => guard(
     () => runInit({ cwd: options.cwd, force: options.force, hook: options.hook, enableConversation: options.enableConversation })
@@ -2642,7 +3397,7 @@ program.command("hook").description("Manage the opt-in PowerShell hook that logs
   new Command("status").description("Show whether the hook is installed").option("--profile <path>", "override the auto-detected $PROFILE path").action((options) => guard(() => runHookStatus({ profile: options.profile }))())
 );
 program.command("status").description("Show what is currently remembered for this repository").option("-C, --cwd <path>", "repository path", process.cwd()).action((options) => guard(() => runStatus({ cwd: options.cwd }))());
-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("--json", "emit the packed result as JSON on stdout", false).action(
+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("--json", "emit the packed result as JSON on stdout", false).action(
   (text, options) => guard(
     () => runQuery({
       cwd: options.cwd,
@@ -2651,10 +3406,12 @@ program.command("query").description("Search remembered history and print a toke
       candidates: options.candidates,
       halfLifeDays: options.halfLife,
       noVector: !options.vector,
+      allProjects: options.allProjects,
       json: options.json
     })
   )()
 );
+program.command("projects").description("List the repositories `query --all-projects` would search").option("--prune", "forget registered projects whose database is no longer on disk", false).option("--json", "emit the registry as JSON on stdout", false).action((options) => guard(() => runProjects({ prune: options.prune, json: options.json }))());
 program.command("scan-git").description("Preview the MemoryNodes git history would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--since <date>", "only commits newer than this git date expression, e.g. 90.days.ago").option("-n, --limit <count>", "stop after N commits", (v) => Number.parseInt(v, 10)).option("--no-merges", "skip merge commits").option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
   (options) => guard(
     () => runScanGit({
@@ -2667,6 +3424,17 @@ program.command("scan-git").description("Preview the MemoryNodes git history wou
     })
   )()
 );
+program.command("scan-diff").description("Preview the MemoryNodes commit patches would produce, one per changed file (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--since <date>", "only commits newer than this git date expression, e.g. 90.days.ago").option("-n, --limit <count>", "stop after N commits (not N nodes)", (v) => Number.parseInt(v, 10)).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
+  (options) => guard(
+    () => runScanDiff({
+      cwd: options.cwd,
+      since: options.since,
+      limit: options.limit,
+      json: options.json,
+      minSignal: options.minSignal
+    })
+  )()
+);
 program.command("scan-shell").description("Preview the MemoryNodes shell history would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("-n, --tail-lines <count>", "lines kept from each scrape-based source", (v) => Number.parseInt(v, 10), 300).option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
   (options) => guard(
     () => runScanShell({ cwd: options.cwd, tailLines: options.tailLines, minSignal: options.minSignal, json: options.json })
@@ -2679,7 +3447,7 @@ program.command("scan-docs").description("Preview the MemoryNodes tracked .md fi
 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(`${pc11.red("error")} ${message}
+  process.stderr.write(`${pc13.red("error")} ${message}
 `);
   process.exitCode = 1;
 });