nexusmem 0.1.2 → 0.3.0

package/dist/cli/index.js

@@ -2,13 +2,68 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import pc11 from "picocolors";
+import pc14 from "picocolors";
 
 // src/config/workspace.ts
 import { existsSync } from "fs";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { join } from "path";
 import { z } from "zod";
+
+// src/slm/provider.ts
+var DEFAULT_BASE_URL = "http://127.0.0.1:11434";
+var DEFAULT_SLM_MODEL = "qwen2.5:3b";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_MAX_TOKENS = 400;
+var OllamaChatProvider = class {
+  identity;
+  baseUrl;
+  model;
+  timeoutMs;
+  maxTokens;
+  constructor(opts = {}) {
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.model = opts.model ?? DEFAULT_SLM_MODEL;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxTokens = opts.maxTokens ?? DEFAULT_MAX_TOKENS;
+    this.identity = `ollama:${this.model}`;
+  }
+  async complete(prompt) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(`${this.baseUrl}/api/generate`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: this.model,
+          prompt,
+          stream: false,
+          options: {
+            // Deterministic: the same session must summarize to the same text
+            // across syncs, or the content hash that suppresses re-work would
+            // never match and every sync would rewrite every summary node.
+            temperature: 0,
+            seed: 1,
+            num_predict: this.maxTokens
+          }
+        }),
+        signal: controller.signal
+      });
+      if (!res.ok) return null;
+      const data = await res.json();
+      if (typeof data.response !== "string") return null;
+      const text = data.response.trim();
+      return text.length > 0 ? text : null;
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+};
+
+// src/config/workspace.ts
 var WORKSPACE_DIR = ".nexusmem";
 function resolveWorkspace(repoRoot) {
   const dir = join(repoRoot, WORKSPACE_DIR);
@@ -46,17 +101,66 @@ var ConfigSchema = z.object({
     conversation: z.object({
       enabled: z.boolean().default(false)
     }).default({ enabled: false }),
+    /**
+     * One distilled node per finished working session, written by a local
+     * small language model.
+     *
+     * Opt-in for the same reason as `conversation` -- it reads the same
+     * transcripts -- and additionally because it is the only source that
+     * costs real compute. Independent of `conversation.enabled`: summaries
+     * without the raw exchanges is a legitimate, and much smaller, way to
+     * remember a session.
+     */
+    session: z.object({
+      enabled: z.boolean().default(false),
+      /** Ollama model tag. Must be pulled locally; nothing is downloaded automatically. */
+      model: z.string().default(DEFAULT_SLM_MODEL),
+      /** Minutes of quiet before a session counts as finished and can be summarized. */
+      settleMinutes: z.number().int().nonnegative().default(30),
+      /** Sessions summarized per sync. Each is a model call measured in seconds. */
+      maxSessions: z.number().int().positive().default(10),
+      maxPromptChars: z.number().int().positive().default(12e3)
+    }).default({
+      enabled: false,
+      model: DEFAULT_SLM_MODEL,
+      settleMinutes: 30,
+      maxSessions: 10,
+      maxPromptChars: 12e3
+    }),
     /** Tracked `.md` files -- README, architecture docs. On by default like git/shell: no secrets risk, just project prose. */
     docs: 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"] }
+    session: {
+      enabled: false,
+      model: DEFAULT_SLM_MODEL,
+      settleMinutes: 30,
+      maxSessions: 10,
+      maxPromptChars: 12e3
+    },
+    docs: { enabled: true, include: ["*.md"] },
+    diff: { enabled: true, maxCommits: 200, maxFilesPerCommit: 20, contextLines: 3 }
   }),
   limits: z.object({
     maxFilesPerNode: z.number().int().positive().default(40),
@@ -193,9 +297,9 @@ async function* gitStream(cwd, args, opts = {}) {
   for (let attempt = 0; ; attempt += 1) {
     let produced = false;
     try {
-      for await (const chunk of runGitOnce(cwd, args, opts)) {
+      for await (const chunk2 of runGitOnce(cwd, args, opts)) {
         produced = true;
-        yield chunk;
+        yield chunk2;
       }
       return;
     } catch (err) {
@@ -211,8 +315,8 @@ async function* runGitOnce(cwd, args, opts) {
   child.stdout.setEncoding("utf8");
   child.stderr.setEncoding("utf8");
   let stderr = "";
-  child.stderr.on("data", (chunk) => {
-    if (stderr.length < 64 * 1024) stderr += chunk;
+  child.stderr.on("data", (chunk2) => {
+    if (stderr.length < 64 * 1024) stderr += chunk2;
   });
   const exited = new Promise((resolve2, reject) => {
     child.once("error", (err) => reject(toSpawnError(err, cwd, fullArgs)));
@@ -221,8 +325,8 @@ async function* runGitOnce(cwd, args, opts) {
   exited.catch(() => {
   });
   try {
-    for await (const chunk of child.stdout) {
-      yield chunk;
+    for await (const chunk2 of child.stdout) {
+      yield chunk2;
     }
   } finally {
     if (child.exitCode === null) child.kill();
@@ -251,7 +355,7 @@ async function* runGitOnce(cwd, args, opts) {
 }
 async function git(cwd, args, opts = {}) {
   let out = "";
-  for await (const chunk of gitStream(cwd, args, opts)) out += chunk;
+  for await (const chunk2 of gitStream(cwd, args, opts)) out += chunk2;
   return out;
 }
 async function gitOrNull(cwd, args, opts = {}) {
@@ -314,25 +418,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 {
@@ -486,6 +596,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";
@@ -741,6 +919,20 @@ var MemoryStore = class _MemoryStore {
     run(nodes);
     return stats;
   }
+  /**
+   * The stored `meta` blob for one node, or null if it has never been
+   * written. Used by the session summarizer to recognise work it has
+   * already done without re-reading the node's whole body.
+   */
+  getNodeMeta(id) {
+    const row = this.db.prepare("SELECT meta FROM nodes WHERE id = ?").get(id);
+    if (!row) return null;
+    try {
+      return JSON.parse(row.meta);
+    } catch {
+      return null;
+    }
+  }
   getSyncCursor(projectId, source) {
     const row = this.db.prepare("SELECT cursor FROM sync_state WHERE project_id = ? AND source = ?").get(projectId, source);
     return row?.cursor ?? null;
@@ -803,19 +995,57 @@ var MemoryStore = class _MemoryStore {
       return this.db.prepare(`DELETE FROM nodes WHERE ${scope}`).run(params).changes;
     })();
   }
-  /** Nodes for this project that have no embedding yet (new, or invalidated by a content change). */
-  findNodesNeedingEmbedding(projectId, limit = 200) {
+  /**
+   * Nodes for this project that have no embedding yet (new, or invalidated
+   * by a content change).
+   *
+   * `afterRowid` makes paging monotonic: the pass walks rowids strictly
+   * upward instead of re-reading "the first N still pending". That matters
+   * because a node the provider *failed* on stays pending -- an offset-free
+   * loop would fetch the same failures forever, which is exactly the shape
+   * of an infinite sync.
+   */
+  findNodesNeedingEmbedding(projectId, limit = 200, afterRowid = 0) {
     return this.db.prepare(
       `SELECT n.rowid AS rowid, n.id AS id, n.title AS title, n.body AS body
          FROM nodes n
          LEFT JOIN nodes_vec v ON v.rowid = n.rowid
-         WHERE n.project_id = ? AND v.rowid IS NULL
+         WHERE n.project_id = ? AND v.rowid IS NULL AND n.rowid > ?
+         ORDER BY n.rowid
          LIMIT ?`
-    ).all(projectId, limit);
+    ).all(projectId, afterRowid, limit);
+  }
+  /** How many of this project's nodes still need a vector. For progress reporting. */
+  countNodesNeedingEmbedding(projectId) {
+    const row = this.db.prepare(
+      `SELECT COUNT(*) AS n
+         FROM nodes n
+         LEFT JOIN nodes_vec v ON v.rowid = n.rowid
+         WHERE n.project_id = ? AND v.rowid IS NULL`
+    ).get(projectId);
+    return row.n;
   }
   upsertEmbedding(rowid, embedding) {
     this.db.prepare("INSERT OR REPLACE INTO nodes_vec (rowid, embedding) VALUES (?, ?)").run(BigInt(rowid), embedding);
   }
+  /**
+   * Drop every vector in this database, across all projects.
+   *
+   * Whole-database on purpose: `nodes_vec` is shared and holds no
+   * provenance, so once the vectors in it stopped being comparable there is
+   * no subset that is still trustworthy. Nodes are untouched, so the next
+   * embedding pass simply rebuilds them.
+   */
+  dropAllEmbeddings() {
+    return this.db.prepare("DELETE FROM nodes_vec").run().changes;
+  }
+  getMeta(key) {
+    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+    return row?.value ?? null;
+  }
+  setMeta(key, value) {
+    this.db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+  }
   /**
    * Nearest-neighbour search over the corpus.
    *
@@ -880,7 +1110,7 @@ var MemoryStore = class _MemoryStore {
 
 // src/cli/commands/init.ts
 async function runInit(opts) {
-  const out = opts.out ?? ((chunk) => void process.stdout.write(chunk));
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
   const repo = await readRepoInfo(opts.cwd);
   const ws = resolveWorkspace(repo.root);
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
@@ -905,6 +1135,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)}`,
@@ -939,10 +1170,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 basename3 } from "path";
 
 // src/core/text.ts
 function truncate(s, max) {
@@ -956,22 +1245,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;
@@ -985,7 +1378,8 @@ function packContext(ranked, tokensBudget, opts = {}) {
       signal: hit.signal,
       score: hit.score,
       summary,
-      tokens
+      tokens,
+      ...hit.project ? { project: hit.project } : {}
     });
     tokensUsed += tokens;
   }
@@ -995,9 +1389,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");
@@ -1032,8 +1431,10 @@ var RECENCY_FLOOR = 0.3;
 var DEFAULT_HALF_LIFE_DAYS = 30;
 var MS_PER_DAY = 864e5;
 var MAX_PRIOR_OVERTURN = 2;
-var SIGNAL_EXPONENT = Math.log(MAX_PRIOR_OVERTURN) / Math.log(1 / SIGNAL_FLOOR);
-var RECENCY_EXPONENT = Math.log(MAX_PRIOR_OVERTURN) / Math.log(1 / RECENCY_FLOOR);
+var PRIOR_COUNT = 2;
+var PER_PRIOR_OVERTURN = MAX_PRIOR_OVERTURN ** (1 / PRIOR_COUNT);
+var SIGNAL_EXPONENT = Math.log(PER_PRIOR_OVERTURN) / Math.log(1 / SIGNAL_FLOOR);
+var RECENCY_EXPONENT = Math.log(PER_PRIOR_OVERTURN) / Math.log(1 / RECENCY_FLOOR);
 function normalizeRelevance(hits) {
   const costs = hits.map((h) => h.rank);
   const min = Math.min(...costs);
@@ -1076,6 +1477,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 = [];
@@ -1086,42 +1512,102 @@ 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_BASE_URL2 = "http://127.0.0.1:11434";
 var DEFAULT_MODEL = "nomic-embed-text";
 var DEFAULT_DIMENSION = 768;
-var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_TIMEOUT_MS2 = 1e4;
+var DEFAULT_MAX_TIMEOUT_MS = 12e4;
+var EMBED_PATH = "/api/embed";
 var OllamaEmbeddingProvider = class {
   dimension;
+  identity;
   baseUrl;
   model;
   timeoutMs;
+  maxTimeoutMs;
   constructor(opts = {}) {
-    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL;
+    this.baseUrl = opts.baseUrl ?? DEFAULT_BASE_URL2;
     this.model = opts.model ?? DEFAULT_MODEL;
     this.dimension = opts.dimension ?? DEFAULT_DIMENSION;
-    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+    this.maxTimeoutMs = opts.maxTimeoutMs ?? DEFAULT_MAX_TIMEOUT_MS;
+    this.identity = `ollama${EMBED_PATH}:${this.model}:${this.dimension}`;
   }
   async embed(text) {
+    const [only] = await this.embedBatch([text]);
+    return only ?? null;
+  }
+  async embedBatch(texts) {
+    if (texts.length === 0) return [];
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    const budget = Math.min(this.timeoutMs * texts.length, this.maxTimeoutMs);
+    const timeout = setTimeout(() => controller.abort(), budget);
     try {
-      const res = await fetch(`${this.baseUrl}/api/embeddings`, {
+      const res = await fetch(`${this.baseUrl}${EMBED_PATH}`, {
         method: "POST",
         headers: { "content-type": "application/json" },
-        body: JSON.stringify({ model: this.model, prompt: text }),
+        body: JSON.stringify({ model: this.model, input: texts }),
         signal: controller.signal
       });
-      if (!res.ok) return null;
+      if (!res.ok) return texts.map(() => null);
       const data = await res.json();
-      if (!Array.isArray(data.embedding) || data.embedding.length !== this.dimension) return null;
-      return new Float32Array(data.embedding);
+      if (!Array.isArray(data.embeddings)) return texts.map(() => null);
+      if (data.embeddings.length !== texts.length) return texts.map(() => null);
+      return data.embeddings.map(
+        (row) => Array.isArray(row) && row.length === this.dimension ? new Float32Array(row) : null
+      );
     } catch {
-      return null;
+      return texts.map(() => null);
     } finally {
       clearTimeout(timeout);
     }
@@ -1129,7 +1615,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+(.+)$/;
@@ -1169,21 +1655,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;
@@ -1198,8 +1694,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}`;
@@ -1241,25 +1737,25 @@ function toMemoryNodes(turn, projectId, opts = {}) {
   const assistantRedacted = redact(turn.assistantText);
   const chunks = chunkAssistantText(assistantRedacted.text, maxChunk);
   if (chunks.length === 0) return [];
-  return chunks.map((chunk, index) => {
-    const body = [`Q: ${userRedacted.text}`, "", `A: ${chunk.text}`].join("\n");
+  return chunks.map((chunk2, index) => {
+    const body = [`Q: ${userRedacted.text}`, "", `A: ${chunk2.text}`].join("\n");
     return {
       id: makeNodeId(projectId, "conversation_turn", `${turn.naturalKey}:${index}`),
       kind: "conversation_turn",
       projectId,
       ts: turn.ts,
       source: `conversation:${turn.source}`,
-      title: chunkTitle(userFirstLine, chunk.heading, index, chunks.length),
+      title: chunkTitle(userFirstLine, chunk2.heading, index, chunks.length),
       body: truncate(body, maxBody),
       files: extractMentionedFiles(`${userRedacted.text}
-${chunk.text}`),
-      signal: scoreConversationTurn(userRedacted.text, chunk.text),
+${chunk2.text}`),
+      signal: scoreConversationTurn(userRedacted.text, chunk2.text),
       meta: {
         cwd: turn.cwd,
         source: turn.source,
         chunkIndex: index,
         chunkCount: chunks.length,
-        heading: chunk.heading,
+        heading: chunk2.heading,
         // Redaction runs once over the whole reply before chunking (so a
         // secret can never straddle a chunk boundary and slip through) --
         // this is the turn's total, repeated on every chunk it produced,
@@ -1273,63 +1769,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 = "";
@@ -1439,28 +1878,45 @@ 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 buildLogArgs(opts = {}) {
-  const { rev = "HEAD", afterCommit, since, maxCount, includeMerges = true, paths } = opts;
-  const args = ["log", `--format=${GIT_LOG_FORMAT}`, "--numstat", "--no-color"];
-  if (!includeMerges) args.push("--no-merges");
+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* readCommits(cwd, opts = {}) {
-  const args = buildLogArgs(opts);
+async function* readCommitDiffs(cwd, opts = {}) {
+  const args = buildDiffLogArgs(opts);
   let buffer = "";
   try {
-    for await (const chunk of gitStream(cwd, args)) {
-      buffer += chunk;
+    for await (const chunk2 of gitStream(cwd, args)) {
+      buffer += chunk2;
       const { records, rest } = splitRecords(buffer);
       buffer = rest;
       for (const record of records) {
-        const commit = parseCommitRecord(record);
+        const commit = parseCommitDiffRecord(record);
         if (commit) yield commit;
       }
     }
@@ -1469,55 +1925,212 @@ async function* readCommits(cwd, opts = {}) {
     throw err;
   }
   for (const record of splitRecords(buffer, true).records) {
-    const commit = parseCommitRecord(record);
+    const commit = parseCommitDiffRecord(record);
     if (commit) yield commit;
   }
 }
-
-// src/collectors/git-commits.ts
-var DEFAULTS = { maxFilesPerNode: 40, maxBodyChars: 4e3 };
-var MAX_TITLE_CHARS3 = 200;
-var CONVENTIONAL = /^([a-z]+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/i;
-function parseConventionalHeader(subject) {
-  const m = CONVENTIONAL.exec(subject.trim());
-  if (!m) return { type: null, scope: null, breaking: false, description: subject.trim() };
+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 {
-    type: (m[1] ?? "").toLowerCase(),
-    scope: m[2] ?? null,
-    breaking: Boolean(m[3]),
-    description: (m[4] ?? "").trim()
+    sha,
+    shortSha: parts[1] ?? "",
+    authoredAt: parts[2] ?? "",
+    subject,
+    files: parseFileDiffs(patchBlock)
   };
 }
-var TYPE_WEIGHTS = {
-  fix: 0.8,
-  feat: 0.8,
-  revert: 0.78,
-  perf: 0.7,
-  refactor: 0.68,
-  security: 0.85,
-  test: 0.45,
-  docs: 0.35,
-  build: 0.32,
-  ci: 0.28,
-  chore: 0.25,
-  style: 0.2
-};
-var AUTOMATED = /^(merge (branch|pull request|remote)|bump |update dependenc|\[bot\]|revert "merge)/i;
-function scoreCommit(commit) {
-  const header = parseConventionalHeader(commit.subject);
-  let score = header.type ? TYPE_WEIGHTS[header.type] ?? 0.5 : 0.5;
-  if (header.breaking) score += 0.12;
-  if (commit.messageBody.length > 120) score += 0.1;
-  if (commit.isMerge) score = Math.min(score, 0.3);
-  if (AUTOMATED.test(commit.subject)) score -= 0.15;
-  const churn = commit.files.reduce((n, f) => n + (f.insertions ?? 0) + (f.deletions ?? 0), 0);
-  if (commit.files.length > 100 || churn > 5e3) score *= 0.75;
-  if (commit.files.length <= 1 && churn <= 3) score -= 0.05;
-  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
-}
-function byChurnDesc(a, b) {
-  const ca = (a.insertions ?? 0) + (a.deletions ?? 0);
-  const cb = (b.insertions ?? 0) + (b.deletions ?? 0);
+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"];
+  if (!includeMerges) args.push("--no-merges");
+  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* readCommits(cwd, opts = {}) {
+  const args = buildLogArgs(opts);
+  let buffer = "";
+  try {
+    for await (const chunk2 of gitStream(cwd, args)) {
+      buffer += chunk2;
+      const { records, rest } = splitRecords(buffer);
+      buffer = rest;
+      for (const record of records) {
+        const commit = parseCommitRecord(record);
+        if (commit) yield commit;
+      }
+    }
+  } catch (err) {
+    if (err instanceof GitError && EMPTY_HISTORY2.test(err.stderr)) return;
+    throw err;
+  }
+  for (const record of splitRecords(buffer, true).records) {
+    const commit = parseCommitRecord(record);
+    if (commit) yield commit;
+  }
+}
+
+// src/collectors/git-commits.ts
+var DEFAULTS = { maxFilesPerNode: 40, maxBodyChars: 4e3 };
+var MAX_TITLE_CHARS2 = 200;
+var CONVENTIONAL = /^([a-z]+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/i;
+function parseConventionalHeader(subject) {
+  const m = CONVENTIONAL.exec(subject.trim());
+  if (!m) return { type: null, scope: null, breaking: false, description: subject.trim() };
+  return {
+    type: (m[1] ?? "").toLowerCase(),
+    scope: m[2] ?? null,
+    breaking: Boolean(m[3]),
+    description: (m[4] ?? "").trim()
+  };
+}
+var TYPE_WEIGHTS = {
+  fix: 0.8,
+  feat: 0.8,
+  revert: 0.78,
+  perf: 0.7,
+  refactor: 0.68,
+  security: 0.85,
+  test: 0.45,
+  docs: 0.35,
+  build: 0.32,
+  ci: 0.28,
+  chore: 0.25,
+  style: 0.2
+};
+var AUTOMATED = /^(merge (branch|pull request|remote)|bump |update dependenc|\[bot\]|revert "merge)/i;
+function scoreCommit(commit) {
+  const header = parseConventionalHeader(commit.subject);
+  let score = header.type ? TYPE_WEIGHTS[header.type] ?? 0.5 : 0.5;
+  if (header.breaking) score += 0.12;
+  if (commit.messageBody.length > 120) score += 0.1;
+  if (commit.isMerge) score = Math.min(score, 0.3);
+  if (AUTOMATED.test(commit.subject)) score -= 0.15;
+  const churn = commit.files.reduce((n, f) => n + (f.insertions ?? 0) + (f.deletions ?? 0), 0);
+  if (commit.files.length > 100 || churn > 5e3) score *= 0.75;
+  if (commit.files.length <= 1 && churn <= 3) score -= 0.05;
+  return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
+}
+function byChurnDesc(a, b) {
+  const ca = (a.insertions ?? 0) + (a.deletions ?? 0);
+  const cb = (b.insertions ?? 0) + (b.deletions ?? 0);
   return cb - ca;
 }
 function renderFileLine(f) {
@@ -1545,7 +2158,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),
@@ -1572,9 +2185,364 @@ async function* collectGitCommits(cwd, projectId, opts = {}) {
   }
 }
 
-// src/collectors/shell-history.ts
-var DEFAULT_MAX_BODY_CHARS3 = 1e3;
+// 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((chunk2, index) => {
+    const baseSlug = slugify(chunk2.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, chunk2.heading, index, chunks.length),
+      body: truncate(chunk2.text, maxBody),
+      files: [{ path: file.path, insertions: null, deletions: null, binary: false }],
+      signal: scoreDocSection(file.path, chunk2.heading, chunk2.text),
+      meta: {
+        path: file.path,
+        heading: chunk2.heading,
+        chunkIndex: index,
+        chunkCount: chunks.length
+      }
+    };
+  });
+}
+function collectDocFiles(files, projectId, opts = {}) {
+  return files.flatMap((file) => toMemoryNodes3(file, projectId, opts));
+}
+
+// src/slm/summarize.ts
+var MAX_USER_CHARS = 400;
+var MAX_REPLY_CHARS = 700;
+var DEFAULT_MAX_PROMPT_CHARS = 12e3;
+function groupTurnsIntoSessions(turns) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const turn of turns) {
+    const existing = groups.get(turn.sessionKey);
+    if (existing) {
+      existing.turns.push(turn);
+      if (turn.ts < existing.startedAt) existing.startedAt = turn.ts;
+      if (turn.ts > existing.endedAt) existing.endedAt = turn.ts;
+      existing.cwd ??= turn.cwd;
+      continue;
+    }
+    groups.set(turn.sessionKey, {
+      sessionKey: turn.sessionKey,
+      source: turn.source,
+      cwd: turn.cwd,
+      turns: [turn],
+      startedAt: turn.ts,
+      endedAt: turn.ts
+    });
+  }
+  for (const group of groups.values()) {
+    group.turns.sort((a, b) => a.ts.localeCompare(b.ts));
+  }
+  return [...groups.values()].sort((a, b) => a.startedAt.localeCompare(b.startedAt));
+}
+function selectSettledSessions(sessions, settleMinutes, now = /* @__PURE__ */ new Date()) {
+  const cutoff = now.getTime() - settleMinutes * 6e4;
+  return sessions.filter((s) => {
+    const ended = Date.parse(s.endedAt);
+    return Number.isNaN(ended) || ended <= cutoff;
+  });
+}
+var SESSION_INSTRUCTIONS = `You are summarizing one working session between a developer and an AI coding assistant, so that a future assistant can recall what happened without re-reading the transcript.
+
+Your first line MUST begin with "TITLE: " and nothing else. Start your reply with those six characters.
+
+Write your answer in exactly this shape:
+TITLE: <under 15 words, naming the specific work, e.g. "Raised the Node floor to 22 after a CI failure">
+- <a decision that was made, and why>
+- <a problem that was diagnosed, and its cause>
+- <what was left unfinished or explicitly deferred>
+
+Rules:
+- Answer in English, whatever language the transcript is in. This summary is stored in a keyword index that cannot segment languages without spaces between words.
+- The title must name this session specifically. "Summary of the session" or "Project update" are wrong.
+- Prefer reasons over narration. "Chose X over Y because Z" is worth more than "worked on X".
+- Only state what the transcript supports. Do not guess or invent.
+- Between 3 and 6 bullets. No preamble, no closing remarks, no markdown bold.`;
+function buildSessionPrompt(session, maxPromptChars = DEFAULT_MAX_PROMPT_CHARS) {
+  const rendered = session.turns.map((turn) => {
+    const user = redact(turn.userText).text;
+    const reply = redact(turn.assistantText).text;
+    return {
+      ts: turn.ts,
+      text: [`[${turn.ts}] developer: ${truncate(user, MAX_USER_CHARS)}`, `assistant: ${truncate(reply, MAX_REPLY_CHARS)}`].join(
+        "\n"
+      ),
+      signal: scoreConversationTurn(user, reply)
+    };
+  });
+  const budget = maxPromptChars - SESSION_INSTRUCTIONS.length;
+  const kept = [];
+  let used = 0;
+  for (const turn of [...rendered].sort((a, b) => b.signal - a.signal)) {
+    if (used + turn.text.length > budget) continue;
+    kept.push(turn);
+    used += turn.text.length;
+  }
+  kept.sort((a, b) => a.ts.localeCompare(b.ts));
+  const body = kept.map((t) => t.text).join("\n\n");
+  const prompt = `${SESSION_INSTRUCTIONS}
+
+---
+
+${body}
+
+---
+
+Summary:`;
+  return { prompt, hash: sha256Hex(prompt), includedTurns: kept.length };
+}
+function sessionFallbackTitle(session) {
+  const opening = session.turns[0];
+  if (!opening) return "Working session";
+  const line = redact(opening.userText).text.split(/\r?\n/)[0]?.trim();
+  return line && line.length > 0 ? line : "Working session";
+}
+var MAX_TITLE_CHARS5 = 200;
+var GENERIC_TITLE = /^(a |the )?(session |conversation |project |work )?(summary|update|overview|recap|status)\b/i;
+function cleanTitle(line) {
+  return line.replace(/^[-*#>\s]+/, "").replace(/\*+/g, "").replace(/\s*:\s*$/, "").trim();
+}
+function parseSummary(raw, fallbackTitle) {
+  const text = redact(raw).text.trim();
+  if (text.length === 0) return null;
+  const lines = text.split(/\r?\n/);
+  const firstIndex = lines.findIndex((line) => line.trim().length > 0);
+  if (firstIndex === -1) return null;
+  const first = lines[firstIndex].trim();
+  const labelled = /^TITLE:\s*(.+)$/i.exec(first);
+  const fallback = truncate(cleanTitle(fallbackTitle) || "Working session", MAX_TITLE_CHARS5);
+  if (!labelled) return { title: fallback, body: text };
+  const candidate = cleanTitle(labelled[1]);
+  const rest = lines.slice(firstIndex + 1).join("\n").trim();
+  return {
+    title: candidate.length > 0 && !GENERIC_TITLE.test(candidate) ? truncate(candidate, MAX_TITLE_CHARS5) : fallback,
+    // A model that emitted only a title still gets a usable node: the title
+    // doubles as the body rather than storing an empty one.
+    body: rest.length > 0 ? rest : candidate
+  };
+}
+
+// src/collectors/sessions.ts
+var SESSION_SOURCE_PREFIX = "session";
+var DEFAULT_SETTLE_MINUTES = 30;
+var DEFAULT_MAX_BODY_CHARS3 = 2500;
+var DEFAULT_MAX_SESSIONS = 10;
+function scoreSession(turnCount) {
+  const score = 0.6 + Math.min(0.25, turnCount / 100);
+  return Number(score.toFixed(3));
+}
+function toNode(session, projectId, summary, meta, maxBodyChars) {
+  const header = `Session of ${session.startedAt.slice(0, 10)} \u2014 ${session.turns.length} exchange(s)`;
+  const body = `${header}
+
+${summary.body}`;
+  return {
+    id: makeNodeId(projectId, "session_summary", session.sessionKey),
+    kind: "session_summary",
+    projectId,
+    // The session's end, not its start: a summary describes a finished piece
+    // of work, and recency ranking should treat it as being as fresh as the
+    // last thing that happened in it.
+    ts: session.endedAt,
+    source: `${SESSION_SOURCE_PREFIX}:${session.source}`,
+    title: truncate(summary.title, 200),
+    body: truncate(body, maxBodyChars),
+    // Drawn from the whole session rather than only the summary: the model
+    // mentions few paths, but `node_files` is what lets "why is this file
+    // like this" reach the session that explains it.
+    files: extractMentionedFiles(session.turns.map((t) => `${t.userText}
+${t.assistantText}`).join("\n")),
+    signal: scoreSession(session.turns.length),
+    meta: {
+      sessionKey: session.sessionKey,
+      source: session.source,
+      turnCount: session.turns.length,
+      summarizedTurns: meta.includedTurns,
+      startedAt: session.startedAt,
+      endedAt: session.endedAt,
+      cwd: session.cwd,
+      model: meta.model,
+      contentHash: meta.hash
+    }
+  };
+}
+async function collectSessionSummaries(turns, projectId, provider, opts = {}) {
+  const maxBodyChars = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS3;
+  const maxSessions = opts.maxSessions ?? DEFAULT_MAX_SESSIONS;
+  const all = groupTurnsIntoSessions(turns);
+  const settled = selectSettledSessions(all, opts.settleMinutes ?? DEFAULT_SETTLE_MINUTES, opts.now);
+  const nodes = [];
+  let cached = 0;
+  let failed = 0;
+  let attempted = 0;
+  const candidates = [...settled].sort((a, b) => b.endedAt.localeCompare(a.endedAt));
+  const pending = [];
+  for (const session of candidates) {
+    const prompt = buildSessionPrompt(session, opts.maxPromptChars);
+    if (opts.knownHash?.(session.sessionKey) === prompt.hash) {
+      cached += 1;
+      continue;
+    }
+    pending.push({ session, prompt });
+  }
+  for (const { session, prompt } of pending.slice(0, maxSessions)) {
+    const raw = await provider.complete(prompt.prompt);
+    attempted += 1;
+    const summary = raw === null ? null : parseSummary(raw, sessionFallbackTitle(session));
+    if (!summary) {
+      failed += 1;
+      continue;
+    }
+    nodes.push(
+      toNode(
+        session,
+        projectId,
+        summary,
+        { hash: prompt.hash, model: provider.identity, includedTurns: prompt.includedTurns },
+        maxBodyChars
+      )
+    );
+    opts.onProgress?.(nodes.length, Math.min(pending.length, maxSessions));
+  }
+  return {
+    nodes,
+    cached,
+    unsettled: all.length - settled.length,
+    deferred: Math.max(0, pending.length - maxSessions),
+    failed,
+    providerUnavailable: attempted > 0 && nodes.length === 0
+  };
+}
+
+// src/collectors/shell-history.ts
+var DEFAULT_MAX_BODY_CHARS4 = 1e3;
+var MAX_TITLE_CHARS6 = 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 +2575,7 @@ function renderBody(entry, maxChars) {
   return truncate(parts.join("\n"), maxChars);
 }
 function toMemoryNode2(entry, projectId, opts = {}) {
-  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS3;
+  const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS4;
   const titleLine = entry.command.split(/\r?\n/)[0] ?? entry.command;
   return {
     id: makeNodeId(projectId, "shell_command", entry.naturalKey),
@@ -1615,7 +2583,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_CHARS6),
     body: renderBody(entry, maxBody),
     files: [],
     signal: scoreShellCommand(entry),
@@ -1634,24 +2602,25 @@ 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";
+import { basename as basename2 } from "path";
 
 // 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
@@ -1681,6 +2650,7 @@ function extractAssistantText(line) {
 }
 function parseClaudeCodeTranscript(raw, opts = {}) {
   const source = opts.source ?? "claude-code";
+  const sessionKey = `${source}:${opts.sessionId ?? "unknown"}`;
   const turns = [];
   let current = null;
   const flush = () => {
@@ -1692,7 +2662,8 @@ function parseClaudeCodeTranscript(raw, opts = {}) {
       assistantText,
       ts: current.ts,
       cwd: current.cwd,
-      source
+      source,
+      sessionKey
     });
     current = null;
   };
@@ -1724,15 +2695,15 @@ async function collectClaudeCodeTranscripts(repoRoot) {
   const files = await listTranscriptFiles(repoRoot);
   const turns = [];
   for (const file of files) {
-    const raw = await readFile3(file, "utf8");
-    turns.push(...parseClaudeCodeTranscript(raw));
+    const raw = await readFile4(file, "utf8");
+    turns.push(...parseClaudeCodeTranscript(raw, { sessionId: basename2(file, ".jsonl") }));
   }
   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;
@@ -1745,11 +2716,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;
@@ -1760,11 +2731,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();
@@ -1789,7 +2760,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 };
   }
@@ -1922,8 +2893,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 = {}) {
@@ -1931,7 +2902,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);
@@ -1951,21 +2922,76 @@ async function collectAvailableShellHistory(opts = {}) {
 }
 
 // src/vector/sync.ts
+var EMBEDDING_IDENTITY_KEY = "embedding.identity";
+var DEFAULT_BATCH_SIZE = 32;
+var DEFAULT_PAGE_SIZE = 500;
+var DEFAULT_FAILURE_TOLERANCE = 3;
+function reconcileProviderIdentity(store, provider) {
+  if (store.getMeta(EMBEDDING_IDENTITY_KEY) === provider.identity) return 0;
+  const invalidated = store.dropAllEmbeddings();
+  store.setMeta(EMBEDDING_IDENTITY_KEY, provider.identity);
+  return invalidated;
+}
+async function embedTexts(provider, texts) {
+  if (provider.embedBatch) return provider.embedBatch(texts);
+  const out = [];
+  for (const text of texts) out.push(await provider.embed(text));
+  return out;
+}
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size));
+  return out;
+}
 async function embedPendingNodes(store, provider, projectId, opts = {}) {
-  const pending = store.findNodesNeedingEmbedding(projectId, opts.batchLimit ?? 200);
+  const batchSize = opts.batchSize ?? DEFAULT_BATCH_SIZE;
+  const pageSize = opts.pageSize ?? DEFAULT_PAGE_SIZE;
+  const failureTolerance = opts.failureTolerance ?? DEFAULT_FAILURE_TOLERANCE;
+  const maxNodes = opts.maxNodes ?? Number.POSITIVE_INFINITY;
+  const invalidated = reconcileProviderIdentity(store, provider);
+  if (invalidated > 0) opts.onInvalidated?.(invalidated);
+  const total = Math.min(store.countNodesNeedingEmbedding(projectId), maxNodes);
   let embedded = 0;
   let skipped = 0;
-  for (const node of pending) {
-    const vector = await provider.embed(`${node.title}
-${node.body}`);
-    if (vector && vector.length === provider.dimension) {
-      store.upsertEmbedding(node.rowid, vector);
-      embedded += 1;
-    } else {
-      skipped += 1;
+  let attempted = 0;
+  let consecutiveFailedRequests = 0;
+  let cursor = 0;
+  outer: while (attempted < maxNodes) {
+    const page = store.findNodesNeedingEmbedding(projectId, Math.min(pageSize, maxNodes - attempted), cursor);
+    if (page.length === 0) break;
+    cursor = page[page.length - 1].rowid;
+    for (const group of chunk(page, batchSize)) {
+      const vectors = await embedTexts(
+        provider,
+        group.map((node) => `${node.title}
+${node.body}`)
+      );
+      let embeddedHere = 0;
+      for (const [index, node] of group.entries()) {
+        const vector = vectors[index];
+        if (vector && vector.length === provider.dimension) {
+          store.upsertEmbedding(node.rowid, vector);
+          embedded += 1;
+          embeddedHere += 1;
+        } else {
+          skipped += 1;
+        }
+      }
+      attempted += group.length;
+      consecutiveFailedRequests = embeddedHere === 0 ? consecutiveFailedRequests + 1 : 0;
+      opts.onProgress?.(attempted, total);
+      if (consecutiveFailedRequests >= failureTolerance) break outer;
     }
   }
-  return { embedded, skipped, providerUnavailable: pending.length > 0 && embedded === 0 };
+  return {
+    embedded,
+    skipped,
+    // Unchanged meaning: nothing came back at all. Reached far sooner now --
+    // `failureTolerance` requests instead of the whole first page.
+    providerUnavailable: attempted > 0 && embedded === 0,
+    invalidated,
+    remaining: store.countNodesNeedingEmbedding(projectId)
+  };
 }
 
 // src/cli/context.ts
@@ -1978,6 +3004,8 @@ async function loadContext(cwd) {
 
 // src/cli/commands/sync.ts
 var BATCH_SIZE = 500;
+var PROGRESS_THRESHOLD = 200;
+var PROGRESS_EVERY = 100;
 var GIT_SOURCE = "git";
 function addStats(into, from) {
   into.inserted += from.inserted;
@@ -1987,25 +3015,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;
@@ -2013,7 +3041,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,
@@ -2031,10 +3059,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({
@@ -2043,7 +3112,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;
@@ -2055,33 +3124,68 @@ 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 };
 }
 var CONVERSATION_SOURCE = "conversation:claude-code";
-async function syncConversation(store, projectId, repoRoot, config, log, forceEnabled) {
+function syncConversation(store, projectId, turns, config, log, forceEnabled) {
   const totals = { inserted: 0, updated: 0, unchanged: 0 };
   const enabled = forceEnabled ?? config.sources.conversation.enabled;
   if (!enabled) {
     return { totals, seen: 0 };
   }
-  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 SESSION_SOURCE = "session:claude-code";
+async function syncSessions(store, projectId, turns, config, log) {
+  const totals = { inserted: 0, updated: 0, unchanged: 0 };
+  const settings = config.sources.session;
+  if (!settings.enabled) return { totals, seen: 0 };
+  if (turns.length === 0) {
+    log(`${pc4.dim("session")} no transcripts found`);
+    return { totals, seen: 0 };
+  }
+  const result = await collectSessionSummaries(turns, projectId, new OllamaChatProvider({ model: settings.model }), {
+    settleMinutes: settings.settleMinutes,
+    maxSessions: settings.maxSessions,
+    maxPromptChars: settings.maxPromptChars,
+    maxBodyChars: config.limits.maxBodyChars,
+    knownHash: (sessionKey) => {
+      const meta = store.getNodeMeta(makeNodeId(projectId, "session_summary", sessionKey));
+      return typeof meta?.contentHash === "string" ? meta.contentHash : null;
+    },
+    onProgress: (done, total) => log(`  ${pc4.dim(`session: summarizing ${done}/${total}`)}`)
+  });
+  if (result.nodes.length > 0) addStats(totals, store.upsertNodes(result.nodes));
+  if (result.providerUnavailable) {
+    log(
+      `${pc4.dim("session")} summarization model unavailable (is Ollama running with \`${settings.model}\` pulled?) -- skipped`
+    );
+  } else {
+    const parts = [`${result.nodes.length} summarized`];
+    if (result.cached > 0) parts.push(`${result.cached} unchanged`);
+    if (result.deferred > 0) parts.push(`${result.deferred} queued for the next sync`);
+    if (result.unsettled > 0) parts.push(`${result.unsettled} still active`);
+    if (result.failed > 0) parts.push(`${result.failed} failed`);
+    log(`  ${pc4.dim(`${SESSION_SOURCE}: ${parts.join(", ")}`)}`);
+  }
+  store.setSyncCursor(projectId, SESSION_SOURCE, `scanned:${result.nodes.length}`);
+  return { totals, seen: result.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 });
@@ -2095,11 +3199,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 };
 }
@@ -2109,45 +3213,64 @@ async function runSync(opts) {
     if (!opts.quiet) process.stderr.write(`${line}
 `);
   };
-  const out = opts.out ?? ((chunk) => void process.stdout.write(chunk));
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
   const store = MemoryStore.open(ws.dbPath);
   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 conversationEnabled = opts.conversationOverride ?? config.sources.conversation.enabled;
+    const turns = conversationEnabled || config.sources.session.enabled ? await collectClaudeCodeTranscripts(repo.root) : [];
+    const conversation = syncConversation(store, projectId, turns, config, log, opts.conversationOverride);
+    const sessions = await syncSessions(store, projectId, turns, config, log);
     const docs = await syncDocs(store, projectId, repo.root, config, log);
     let embedLine = "";
     if (!opts.noEmbed) {
-      const result = await embedPendingNodes(store, new OllamaEmbeddingProvider(), projectId);
+      let lastLogged = 0;
+      const result = await embedPendingNodes(store, new OllamaEmbeddingProvider(), projectId, {
+        maxNodes: opts.embedLimit,
+        onInvalidated: (count) => log(`${pc4.yellow("vector")} embedding model changed -- dropped ${count} vector(s), re-embedding from scratch`),
+        onProgress: (attempted, total) => {
+          if (total < PROGRESS_THRESHOLD || attempted - lastLogged < PROGRESS_EVERY) return;
+          lastLogged = attempted;
+          log(`  ${pc4.dim(`vector: ${attempted}/${total} embedded`)}`);
+        }
+      });
       if (result.embedded > 0) {
-        embedLine = `  ${pc3.dim(`vector: ${result.embedded} node(s) embedded`)}${result.skipped > 0 ? pc3.dim(`, ${result.skipped} skipped`) : ""}
+        const skippedPart = result.skipped > 0 ? pc4.dim(`, ${result.skipped} skipped`) : "";
+        const remainingPart = result.remaining > 0 ? pc4.yellow(`, ${result.remaining} still pending`) : "";
+        embedLine = `  ${pc4.dim(`vector: ${result.embedded} node(s) embedded`)}${skippedPart}${remainingPart}
 `;
       } 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, sessions.totals);
     addStats(totals, docs.totals);
     const stats = store.stats(projectId);
     const elapsed = ((Date.now() - started) / 1e3).toFixed(2);
-    const conversationEnabled = opts.conversationOverride ?? config.sources.conversation.enabled;
     const conversationPart = conversationEnabled ? `, ${conversation.seen} conversation exchange(s)` : "";
+    const sessionPart = config.sources.session.enabled ? `, ${sessions.seen} session summar${sessions.seen === 1 ? "y" : "ies"}` : "";
     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}${sessionPart}${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
     );
@@ -2164,20 +3287,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: [basename3(repo.root) || repo.root]
     };
   } finally {
     store.close();
@@ -2185,8 +3327,8 @@ async function searchMemory(input) {
 }
 async function syncProject(input) {
   const chunks = [];
-  const out = (chunk) => {
-    chunks.push(chunk);
+  const out = (chunk2) => {
+    chunks.push(chunk2);
   };
   await runInit({ cwd: input.projectRoot, force: false, hook: false, enableConversation: false, out });
   const opts = {
@@ -2220,15 +3362,18 @@ function createServer() {
     "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 and per-session summaries. 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: {
@@ -2237,7 +3382,8 @@ function createServer() {
           bm25Matched: result.bm25Matched,
           vectorMatched: result.vectorMatched,
           tokensUsed: result.tokensUsed,
-          tokensBudget: result.tokensBudget
+          tokensBudget: result.tokensBudget,
+          projectsSearched: result.projectsSearched
         }
       };
     }
@@ -2246,9 +3392,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 }) => {
@@ -2262,7 +3408,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 }) => {
@@ -2282,17 +3428,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;
@@ -2317,15 +3487,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")
     );
@@ -2333,28 +3503,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));
@@ -2367,9 +3539,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)}
 `
     );
   }
@@ -2386,7 +3558,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;
 }
@@ -2394,44 +3566,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";
@@ -2458,7 +3594,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) {
@@ -2471,7 +3607,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);
@@ -2502,17 +3638,187 @@ ${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-session.ts
+import pc11 from "picocolors";
+async function runScanSession(opts) {
+  const repo = await readRepoInfo(opts.cwd);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const turns = await collectClaudeCodeTranscripts(repo.root);
+  if (turns.length === 0) {
+    process.stderr.write(`${pc11.yellow("no transcripts found")} at ${claudeProjectTranscriptDir(repo.root)}
+`);
+    return 0;
+  }
+  const sessions = groupTurnsIntoSessions(turns);
+  const settled = selectSettledSessions(sessions, opts.settleMinutes);
+  if (!opts.json) {
+    process.stderr.write(
+      `${pc11.dim("sessions")} ${sessions.length} found, ${settled.length} settled (quiet ${opts.settleMinutes}m+)
+
+`
+    );
+  }
+  if (opts.dryRun) {
+    const previews = settled.slice(0, opts.maxSessions).map((session) => {
+      const { prompt, hash, includedTurns } = buildSessionPrompt(session);
+      return {
+        sessionKey: session.sessionKey,
+        startedAt: session.startedAt,
+        endedAt: session.endedAt,
+        turns: session.turns.length,
+        includedTurns,
+        hash,
+        promptChars: prompt.length,
+        prompt
+      };
+    });
+    if (opts.json) {
+      process.stdout.write(`${JSON.stringify(previews, null, 2)}
+`);
+      return 0;
+    }
+    for (const preview of previews) {
+      process.stdout.write(
+        `${pc11.bold(preview.sessionKey)}  ${preview.startedAt.slice(0, 16).replace("T", " ")}  ${preview.includedTurns}/${preview.turns} turn(s), ${preview.promptChars} chars
+${preview.prompt}
+
+`
+      );
+    }
+    return 0;
+  }
+  const result = await collectSessionSummaries(turns, projectId, new OllamaChatProvider({ model: opts.model }), {
+    settleMinutes: opts.settleMinutes,
+    maxSessions: opts.maxSessions,
+    onProgress: (done, total) => {
+      if (!opts.json) process.stderr.write(`  ${pc11.dim(`summarizing ${done}/${total}`)}
+`);
+    }
+  });
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify(result.nodes, null, 2)}
+`);
+    return 0;
+  }
+  for (const node of result.nodes) {
+    process.stdout.write(`${pc11.bold(node.title)}
+${pc11.dim(node.ts.slice(0, 16).replace("T", " "))}
+${node.body}
+
+`);
+  }
+  if (result.providerUnavailable) {
+    process.stderr.write(
+      `${pc11.yellow("model unavailable")} -- is Ollama running with \`${opts.model}\` pulled? (\`ollama pull ${opts.model}\`)
+`
+    );
+    return 0;
+  }
+  process.stderr.write(
+    `${pc11.bold(String(result.nodes.length))} summarized` + (result.failed > 0 ? `, ${pc11.yellow(`${result.failed} failed`)}` : "") + ` ${pc11.dim(`(model ${opts.model})`)}
+`
+  );
+  return 0;
+}
+var SCAN_SESSION_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
+
 // src/cli/commands/scan-shell.ts
-import pc9 from "picocolors";
+import pc12 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 ? `${pc12.dim("sources found")} ${results.map((r) => r.name).join(", ")}
 
-` : `${pc9.yellow("no shell history source found on this machine")}
+` : `${pc12.yellow("no shell history source found on this machine")}
 `
     );
   }
@@ -2521,9 +3827,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(`${pc12.bold(`shell:${result.name}`)} ${pc12.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");
     }
@@ -2534,20 +3840,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(`${pc12.bold(String(allNodes.length))} node(s) total  ${pc12.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 ? pc12.dim("~") : " ";
   const exit = node.meta.exitCode;
-  const exitLabel = typeof exit === "number" && exit !== 0 ? pc9.red(`exit ${exit}`) : "";
+  const exitLabel = typeof exit === "number" && exit !== 0 ? pc12.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 pc13 from "picocolors";
 function humanBytes(bytes) {
   if (bytes < 1024) return `${bytes} B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
@@ -2572,23 +3878,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)})`)}`,
+        `${pc13.dim("repo    ")} ${repo.root}`,
+        `${pc13.dim("branch  ")} ${repo.branch ?? pc13.yellow("(detached)")}`,
+        `${pc13.dim("project ")} ${pc13.cyan(projectId)}`,
+        `${pc13.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc13.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
+        `${pc13.dim("database")} ${ws.dbPath} ${pc13.dim(`(${humanBytes(dbBytes)})`)}`,
         "",
-        `${pc10.bold(String(stats.total))} node(s)${stats.total ? ` ${pc10.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
+        `${pc13.bold(String(stats.total))} node(s)${stats.total ? ` ${pc13.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
         ...kinds,
-        stats.total ? `    ${pc10.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
+        stats.total ? `    ${pc13.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
         "",
-        sources.length ? pc10.dim("sources") : pc10.yellow("no sources synced yet"),
+        sources.length ? pc13.dim("sources") : pc13.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)} ${pc13.dim(`last run ${when}`)}  ${pc13.dim(`cursor ${cursorLabel}`)}`;
         }),
-        gitCursor && gitCursor !== repo.head ? `${pc10.yellow("git behind HEAD")} \u2014 run ${pc10.bold("nexusmem sync")}` : "",
+        gitCursor && gitCursor !== repo.head ? `${pc13.yellow("git behind HEAD")} \u2014 run ${pc13.bold("nexusmem sync")}` : "",
         ""
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
@@ -2612,7 +3918,7 @@ function guard(run) {
       process.exitCode = await run();
     } catch (err) {
       if (isExpected(err)) {
-        process.stderr.write(`${pc11.red("error")} ${err.message}
+        process.stderr.write(`${pc14.red("error")} ${err.message}
 `);
         process.exitCode = 1;
         return;
@@ -2628,7 +3934,11 @@ program.command("init").description("Create the .nexusmem workspace and database
     () => runInit({ cwd: options.cwd, force: options.force, hook: options.hook, enableConversation: options.enableConversation })
   )()
 );
-program.command("sync").description("Ingest new history into the local database").option("-C, --cwd <path>", "repository path", process.cwd()).option("--full", "ignore the stored cursor and re-walk all history", false).option("--rebuild", "drop this project's nodes and re-ingest from scratch", false).option("--since <date>", "override the configured git cutoff, e.g. 1.year.ago").option("--shell-lines <count>", "override the configured shell tail-window size", (v) => Number.parseInt(v, 10)).option("--conversation", "force the conversation source on for this run, without persisting it to config", false).option("--no-embed", "skip the vector-embedding pass for this run").option("-q, --quiet", "only print the final summary", false).action(
+program.command("sync").description("Ingest new history into the local database").option("-C, --cwd <path>", "repository path", process.cwd()).option("--full", "ignore the stored cursor and re-walk all history", false).option("--rebuild", "drop this project's nodes and re-ingest from scratch", false).option("--since <date>", "override the configured git cutoff, e.g. 1.year.ago").option("--shell-lines <count>", "override the configured shell tail-window size", (v) => Number.parseInt(v, 10)).option("--conversation", "force the conversation source on for this run, without persisting it to config", false).option("--no-embed", "skip the vector-embedding pass for this run").option(
+  "--embed-limit <count>",
+  "stop embedding after this many nodes (default: embed everything pending)",
+  (v) => Number.parseInt(v, 10)
+).option("-q, --quiet", "only print the final summary", false).action(
   (options) => guard(
     () => runSync({
       cwd: options.cwd,
@@ -2638,6 +3948,7 @@ program.command("sync").description("Ingest new history into the local database"
       shellTailLines: options.shellLines,
       conversationOverride: options.conversation ? true : void 0,
       noEmbed: !options.embed,
+      embedLimit: options.embedLimit,
       quiet: options.quiet
     })
   )()
@@ -2650,7 +3961,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,
@@ -2659,10 +3970,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({
@@ -2675,6 +3988,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 })
@@ -2683,11 +4007,23 @@ program.command("scan-shell").description("Preview the MemoryNodes shell history
 program.command("scan-conversation").description("Preview the MemoryNodes the conversation transcript would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).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(() => runScanConversation({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))()
 );
+program.command("scan-session").description("Preview the session summaries a local model would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--model <name>", "Ollama model to summarize with", SCAN_SESSION_DEFAULT_MODEL).option("--settle-minutes <count>", "minutes of quiet before a session counts as finished", (v) => Number.parseInt(v, 10), 30).option("-n, --max-sessions <count>", "how many sessions to summarize", (v) => Number.parseInt(v, 10), 3).option("--dry-run", "print the prompts instead of calling the model", false).option("--json", "emit as JSON on stdout", false).action(
+  (options) => guard(
+    () => runScanSession({
+      cwd: options.cwd,
+      model: options.model,
+      settleMinutes: options.settleMinutes,
+      maxSessions: options.maxSessions,
+      dryRun: options.dryRun,
+      json: options.json
+    })
+  )()
+);
 program.command("scan-docs").description("Preview the MemoryNodes tracked .md files would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).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(() => runScanDocs({ cwd: options.cwd, minSignal: options.minSignal, json: options.json }))());
 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(`${pc14.red("error")} ${message}
 `);
   process.exitCode = 1;
 });