nexusmem 0.5.2 → 0.5.3

package/dist/cli/index.js

@@ -764,46 +764,6 @@ import { mkdirSync } from "fs";
 import { dirname as dirname3 } from "path";
 import * as sqliteVec from "sqlite-vec";
 
-// src/core/types.ts
-function defaultProvenanceForKind(kind) {
-  switch (kind) {
-    case "git_commit":
-    case "code_diff":
-    case "shell_command":
-      return "observed";
-    case "conversation_turn":
-    case "session_summary":
-    case "doc_section":
-    case "note":
-      return "inferred";
-  }
-}
-
-// src/core/ids.ts
-import { createHash } from "crypto";
-var KEY_SEP = "\0";
-function sha256Hex(input) {
-  return createHash("sha256").update(input, "utf8").digest("hex");
-}
-function makeNodeId(projectId, kind, naturalKey) {
-  return sha256Hex([projectId, kind, naturalKey].join(KEY_SEP)).slice(0, 24);
-}
-
-// src/store/fts.ts
-var FTS_SYNTAX = /["'()*:^{}[\]-]/g;
-var LOW_SIGNAL_TOKENS = /* @__PURE__ */ new Set(["id"]);
-function significantTokens(input) {
-  const tokens = input.replace(FTS_SYNTAX, " ").split(/\s+/).map((t) => t.trim()).filter((t) => t.length > 0);
-  if (tokens.length === 0) return [];
-  const signal = tokens.filter((t) => !LOW_SIGNAL_TOKENS.has(t.toLowerCase()));
-  return signal.length > 0 ? signal : tokens;
-}
-function toMatchQuery(input) {
-  const kept = significantTokens(input);
-  if (kept.length === 0) return null;
-  return kept.map((t) => `"${t}"*`).join(" OR ");
-}
-
 // src/store/schema.ts
 var V1 = `
 CREATE TABLE meta (
@@ -1008,7 +968,227 @@ function migrate(db) {
   return { from, to: currentSchemaVersion(db) };
 }
 
-// src/store/store.ts
+// src/store/projects.ts
+function upsertProject(db, project) {
+  db.prepare(
+    `INSERT INTO projects (id, root, origin_url, created_at)
+     VALUES (@id, @root, @originUrl, @now)
+     ON CONFLICT(id) DO UPDATE SET root = excluded.root, origin_url = excluded.origin_url`
+  ).run({ ...project, now: Date.now() });
+}
+function markSynced(db, projectId) {
+  db.prepare("UPDATE projects SET last_synced_at = ? WHERE id = ?").run(Date.now(), projectId);
+}
+function listOtherProjectIds(db, currentProjectId) {
+  return db.prepare("SELECT id FROM projects WHERE id != ?").all(currentProjectId).map(
+    (r) => r.id
+  );
+}
+function countProjectNodes(db, projectIds) {
+  if (projectIds.length === 0) return 0;
+  const placeholders = projectIds.map(() => "?").join(", ");
+  const row = db.prepare(`SELECT COUNT(*) AS n FROM nodes WHERE project_id IN (${placeholders})`).get(...projectIds);
+  return row.n;
+}
+function getSyncCursor(db, projectId, source) {
+  const row = db.prepare("SELECT cursor FROM sync_state WHERE project_id = ? AND source = ?").get(projectId, source);
+  return row?.cursor ?? null;
+}
+function setSyncCursor(db, projectId, source, cursor) {
+  db.prepare(
+    `INSERT INTO sync_state (project_id, source, cursor, last_run_at)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(project_id, source) DO UPDATE SET cursor = excluded.cursor, last_run_at = excluded.last_run_at`
+  ).run(projectId, source, cursor, Date.now());
+}
+function listSyncState(db, projectId) {
+  return db.prepare("SELECT source, cursor, last_run_at AS lastRunAt FROM sync_state WHERE project_id = ? ORDER BY last_run_at DESC").all(projectId);
+}
+
+// src/core/types.ts
+function defaultProvenanceForKind(kind) {
+  switch (kind) {
+    case "git_commit":
+    case "code_diff":
+    case "shell_command":
+      return "observed";
+    case "conversation_turn":
+    case "session_summary":
+    case "doc_section":
+    case "note":
+      return "inferred";
+  }
+}
+
+// src/store/nodes.ts
+function epochOf(ts) {
+  const parsed = Date.parse(ts);
+  return Number.isNaN(parsed) ? Date.now() : parsed;
+}
+function upsertNodes(db, nodes) {
+  const exists = db.prepare("SELECT body, signal, title FROM nodes WHERE id = ?");
+  const dropStaleEmbedding = db.prepare("DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)");
+  const insertNode = db.prepare(
+    `INSERT INTO nodes (id, kind, project_id, ts, ts_epoch, source, title, body, signal, meta, provenance, supersedes, created_at)
+     VALUES (@id, @kind, @projectId, @ts, @tsEpoch, @source, @title, @body, @signal, @meta, @provenance, @supersedes, @now)
+     ON CONFLICT(id) DO UPDATE SET
+       ts = excluded.ts, ts_epoch = excluded.ts_epoch, source = excluded.source,
+       title = excluded.title, body = excluded.body, signal = excluded.signal, meta = excluded.meta,
+       provenance = excluded.provenance`
+  );
+  const clearFiles = db.prepare("DELETE FROM node_files WHERE node_id = ?");
+  const insertFile = db.prepare(
+    `INSERT INTO node_files (node_id, path, previous_path, insertions, deletions, is_binary)
+     VALUES (@nodeId, @path, @previousPath, @insertions, @deletions, @isBinary)
+     ON CONFLICT(node_id, path) DO UPDATE SET
+       previous_path = excluded.previous_path, insertions = excluded.insertions,
+       deletions = excluded.deletions, is_binary = excluded.is_binary`
+  );
+  const stats2 = { inserted: 0, updated: 0, unchanged: 0, denied: 0 };
+  const denyEntriesByProject = /* @__PURE__ */ new Map();
+  const run = db.transaction((batch) => {
+    const now = Date.now();
+    for (const node of batch) {
+      let denyEntries = denyEntriesByProject.get(node.projectId);
+      if (!denyEntries) {
+        denyEntries = listDenyListEntries(db, node.projectId);
+        denyEntriesByProject.set(node.projectId, denyEntries);
+      }
+      if (firstMatchingEntry(denyEntries, node)) {
+        stats2.denied += 1;
+        continue;
+      }
+      const prior = exists.get(node.id);
+      if (prior) {
+        if (prior.body === node.body && prior.signal === node.signal && prior.title === node.title) {
+          stats2.unchanged += 1;
+          continue;
+        }
+        stats2.updated += 1;
+        dropStaleEmbedding.run(node.id);
+      } else {
+        stats2.inserted += 1;
+      }
+      insertNode.run({
+        id: node.id,
+        kind: node.kind,
+        projectId: node.projectId,
+        ts: node.ts,
+        tsEpoch: epochOf(node.ts),
+        source: node.source,
+        title: node.title,
+        body: node.body,
+        signal: node.signal,
+        meta: JSON.stringify(node.meta),
+        provenance: node.provenance ?? defaultProvenanceForKind(node.kind),
+        supersedes: node.supersedes ?? null,
+        now
+      });
+      clearFiles.run(node.id);
+      for (const file of node.files) {
+        insertFile.run({
+          nodeId: node.id,
+          path: file.path,
+          previousPath: file.previousPath ?? null,
+          insertions: file.insertions,
+          deletions: file.deletions,
+          isBinary: file.binary ? 1 : 0
+        });
+      }
+    }
+  });
+  run(nodes);
+  return stats2;
+}
+function getNodeMeta(db, id) {
+  const row = db.prepare("SELECT meta FROM nodes WHERE id = ?").get(id);
+  if (!row) return null;
+  try {
+    return JSON.parse(row.meta);
+  } catch {
+    return null;
+  }
+}
+function clearProject(db, projectId) {
+  db.prepare("DELETE FROM nodes_vec WHERE rowid IN (SELECT rowid FROM nodes WHERE project_id = ?)").run(projectId);
+  const info = db.prepare("DELETE FROM nodes WHERE project_id = ?").run(projectId);
+  db.prepare("DELETE FROM sync_state WHERE project_id = ?").run(projectId);
+  return info.changes;
+}
+function getNodesByIds(db, ids) {
+  if (ids.length === 0) return [];
+  return db.prepare(
+    `SELECT id, kind, project_id AS projectId, ts, title, body, signal, provenance
+       FROM nodes WHERE id IN (SELECT value FROM json_each(?))`
+  ).all(JSON.stringify(ids));
+}
+function listRecentNodes(db, projectId, limit = 20) {
+  return db.prepare(
+    `SELECT id, kind, ts, source, title, signal, provenance
+       FROM nodes
+       WHERE project_id = ?
+       ORDER BY ts_epoch DESC
+       LIMIT ?`
+  ).all(projectId, limit);
+}
+function countSourceNodes(db, projectId, source) {
+  const row = db.prepare("SELECT COUNT(*) AS count FROM nodes WHERE project_id = ? AND source = ?").get(
+    projectId,
+    source
+  );
+  return row.count;
+}
+function pruneSourceNodes(db, projectId, source, keepIds, opts = {}) {
+  const scope = `project_id = @projectId AND source = @source
+      AND id NOT IN (SELECT value FROM json_each(@keepIds))
+      AND id NOT IN (SELECT node_id FROM node_files WHERE path IN (SELECT value FROM json_each(@keepPaths)))`;
+  const params = {
+    projectId,
+    source,
+    keepIds: JSON.stringify(keepIds),
+    keepPaths: JSON.stringify(opts.keepPaths ?? [])
+  };
+  return db.transaction(() => {
+    db.prepare(`DELETE FROM nodes_vec WHERE rowid IN (SELECT rowid FROM nodes WHERE ${scope})`).run(params);
+    return db.prepare(`DELETE FROM nodes WHERE ${scope}`).run(params).changes;
+  })();
+}
+function getNodeProjectId(db, id) {
+  const row = db.prepare("SELECT project_id FROM nodes WHERE id = ?").get(id);
+  return row?.project_id ?? null;
+}
+function getSupersededIds(db, projectId) {
+  const rows = db.prepare("SELECT DISTINCT supersedes AS id FROM nodes WHERE project_id = ? AND supersedes IS NOT NULL").all(projectId);
+  return new Set(rows.map((r) => r.id));
+}
+function setSupersedes(db, newNodeId, staleNodeId) {
+  db.prepare("UPDATE nodes SET supersedes = ? WHERE id = ?").run(staleNodeId, newNodeId);
+}
+
+// src/store/links.ts
+function linkNodes(db, fromNodeId, toNodeId, relation) {
+  db.prepare("INSERT OR IGNORE INTO node_links (from_node_id, to_node_id, relation, created_at) VALUES (?, ?, ?, ?)").run(
+    fromNodeId,
+    toNodeId,
+    relation,
+    Date.now()
+  );
+}
+function getLinkedNodeIds(db, fromNodeId, relation) {
+  return db.prepare("SELECT to_node_id FROM node_links WHERE from_node_id = ? AND relation = ? ORDER BY created_at DESC").all(fromNodeId, relation).map((row) => row.to_node_id);
+}
+
+// src/core/ids.ts
+import { createHash } from "crypto";
+var KEY_SEP = "\0";
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+function makeNodeId(projectId, kind, naturalKey) {
+  return sha256Hex([projectId, kind, naturalKey].join(KEY_SEP)).slice(0, 24);
+}
+
+// src/store/forget.ts
 function parseMeta(raw) {
   try {
     return JSON.parse(raw);
@@ -1016,10 +1196,228 @@ function parseMeta(raw) {
     return {};
   }
 }
-function epochOf(ts) {
-  const parsed = Date.parse(ts);
-  return Number.isNaN(parsed) ? Date.now() : parsed;
+function previewForget(db, projectId, otherProjectIds, input) {
+  validatePattern(input);
+  const probeEntry = { id: -1, projectId, createdAt: 0, ...input };
+  const select = db.prepare("SELECT project_id, source, title, body, meta FROM nodes WHERE project_id = ?");
+  const counts = /* @__PURE__ */ new Map();
+  for (const scopeId of [projectId, ...otherProjectIds]) {
+    const rows = select.all(scopeId);
+    for (const row of rows) {
+      if (!firstMatchingEntry([probeEntry], { title: row.title, body: row.body, meta: parseMeta(row.meta) })) continue;
+      const key = `${row.project_id} ${row.source}`;
+      const existing = counts.get(key);
+      if (existing) existing.count += 1;
+      else counts.set(key, { projectId: row.project_id, source: row.source, count: 1 });
+    }
+  }
+  return [...counts.values()];
+}
+function forget(db, projectId, otherProjectIds, input) {
+  return db.transaction(() => {
+    const entry = insertDenyListEntry(db, { ...input, projectId });
+    const startedAt = Date.now();
+    const auditId = Number(
+      db.prepare(
+        `INSERT INTO mutation_audit (action, project_id, detail, affected_count, succeeded, error, started_at, finished_at)
+           VALUES ('forget', @projectId, @detail, 0, 1, NULL, @startedAt, @startedAt)`
+      ).run({
+        projectId,
+        detail: JSON.stringify({
+          pattern: input.pattern,
+          matchType: input.matchType,
+          ignoreCase: input.ignoreCase,
+          reason: input.reason,
+          scopeProjectIds: [projectId, ...otherProjectIds]
+        }),
+        startedAt
+      }).lastInsertRowid
+    );
+    const select = db.prepare(
+      "SELECT id, kind, project_id, source, ts, signal, title, body, meta FROM nodes WHERE project_id = ?"
+    );
+    const dropEmbedding = db.prepare("DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)");
+    const deleteNode = db.prepare("DELETE FROM nodes WHERE id = ?");
+    const insertTombstone = db.prepare(
+      `INSERT INTO tombstones
+         (node_id, project_id, kind, source, ts, signal, body_sha256, title_sha256, body_length, deny_list_id, mutation_audit_id, removed_at)
+       VALUES (@nodeId, @projectId, @kind, @source, @ts, @signal, @bodySha256, @titleSha256, @bodyLength, @denyListId, @mutationAuditId, @removedAt)`
+    );
+    let removed = 0;
+    for (const scopeId of [projectId, ...otherProjectIds]) {
+      const rows = select.all(scopeId);
+      for (const row of rows) {
+        if (!firstMatchingEntry([entry], { title: row.title, body: row.body, meta: parseMeta(row.meta) })) continue;
+        dropEmbedding.run(row.id);
+        insertTombstone.run({
+          nodeId: row.id,
+          projectId: row.project_id,
+          kind: row.kind,
+          source: row.source,
+          ts: row.ts,
+          signal: row.signal,
+          bodySha256: sha256Hex(row.body),
+          titleSha256: sha256Hex(row.title),
+          bodyLength: row.body.length,
+          denyListId: entry.id,
+          mutationAuditId: auditId,
+          removedAt: Date.now()
+        });
+        deleteNode.run(row.id);
+        removed += 1;
+      }
+    }
+    db.prepare("UPDATE mutation_audit SET affected_count = ?, finished_at = ? WHERE id = ?").run(removed, Date.now(), auditId);
+    return { removed, entryId: entry.id, auditId };
+  })();
+}
+function listDenyList(db, projectId) {
+  return listDenyListEntries(db, projectId);
+}
+function previewImportDenyList(db, projectId, otherProjectIds, entries) {
+  return entries.map((input) => {
+    validatePattern(input);
+    if (denyListEntryExists(db, projectId, input)) {
+      return { matchType: input.matchType, pattern: input.pattern, alreadyPresent: true, wouldRemove: 0 };
+    }
+    const preview = previewForget(db, projectId, otherProjectIds, input);
+    return {
+      matchType: input.matchType,
+      pattern: input.pattern,
+      alreadyPresent: false,
+      wouldRemove: preview.reduce((sum, p) => sum + p.count, 0)
+    };
+  });
+}
+function importDenyList(db, projectId, otherProjectIds, entries) {
+  let imported = 0;
+  let skipped = 0;
+  let removedNodes = 0;
+  for (const input of entries) {
+    validatePattern(input);
+    if (denyListEntryExists(db, projectId, input)) {
+      skipped += 1;
+      continue;
+    }
+    const result = forget(db, projectId, otherProjectIds, input);
+    imported += 1;
+    removedNodes += result.removed;
+  }
+  return { imported, skipped, removedNodes };
+}
+
+// src/store/file-edges.ts
+function replaceFileEdges(db, projectId, edges) {
+  db.transaction(() => {
+    db.prepare("DELETE FROM file_edges WHERE project_id = ?").run(projectId);
+    const insert = db.prepare("INSERT OR IGNORE INTO file_edges (project_id, from_path, to_path, kind) VALUES (?, ?, ?, ?)");
+    for (const edge of edges) insert.run(projectId, edge.fromPath, edge.toPath, edge.kind);
+  })();
+}
+function fileEdgeStats(db, projectId) {
+  const edges = db.prepare("SELECT COUNT(*) AS c FROM file_edges WHERE project_id = ?").get(projectId).c;
+  const files = db.prepare("SELECT COUNT(DISTINCT from_path) AS c FROM file_edges WHERE project_id = ?").get(projectId).c;
+  return { edges, files };
+}
+
+// src/store/embeddings.ts
+function findNodesNeedingEmbedding(db, projectId, limit = 200, afterRowid = 0) {
+  return 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 AND n.rowid > ?
+       ORDER BY n.rowid
+       LIMIT ?`
+  ).all(projectId, afterRowid, limit);
+}
+function countNodesNeedingEmbedding(db, projectId) {
+  const row = 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;
+}
+function upsertEmbedding(db, rowid, embedding) {
+  db.prepare("INSERT OR REPLACE INTO nodes_vec (rowid, embedding) VALUES (?, ?)").run(BigInt(rowid), embedding);
+}
+function dropAllEmbeddings(db) {
+  return db.prepare("DELETE FROM nodes_vec").run().changes;
+}
+function vectorSearch(db, projectId, embedding, limit = 20) {
+  const overfetch = Math.max(limit * 8, 50);
+  return db.prepare(
+    `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal, n.provenance, v.distance AS distance
+       FROM nodes_vec v
+       JOIN nodes n ON n.rowid = v.rowid
+       WHERE v.embedding MATCH ? AND k = ? AND n.project_id = ?
+       ORDER BY v.distance
+       LIMIT ?`
+  ).all(embedding, overfetch, projectId, limit);
+}
+
+// src/store/fts.ts
+var FTS_SYNTAX = /["'()*:^{}[\]-]/g;
+var LOW_SIGNAL_TOKENS = /* @__PURE__ */ new Set(["id"]);
+function significantTokens(input) {
+  const tokens = input.replace(FTS_SYNTAX, " ").split(/\s+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  if (tokens.length === 0) return [];
+  const signal = tokens.filter((t) => !LOW_SIGNAL_TOKENS.has(t.toLowerCase()));
+  return signal.length > 0 ? signal : tokens;
 }
+function toMatchQuery(input) {
+  const kept = significantTokens(input);
+  if (kept.length === 0) return null;
+  return kept.map((t) => `"${t}"*`).join(" OR ");
+}
+
+// src/store/search.ts
+function search(db, projectId, query, limit = 20) {
+  const match = toMatchQuery(query);
+  if (!match) return [];
+  const rows = db.prepare(
+    `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal, n.provenance,
+              bm25(nodes_fts, 10.0, 1.0) AS rank
+       FROM nodes_fts
+       JOIN nodes n ON n.rowid = nodes_fts.rowid
+       WHERE nodes_fts MATCH ? AND n.project_id = ?
+       ORDER BY rank
+       LIMIT ?`
+  ).all(match, projectId, limit);
+  return rows;
+}
+function stats(db, projectId) {
+  const kinds = db.prepare("SELECT kind, COUNT(*) AS n FROM nodes WHERE project_id = ? GROUP BY kind").all(projectId);
+  const range = db.prepare("SELECT MIN(ts) AS oldest, MAX(ts) AS newest FROM nodes WHERE project_id = ?").get(projectId);
+  const files = db.prepare(
+    `SELECT COUNT(DISTINCT f.path) AS n
+       FROM node_files f JOIN nodes n ON n.id = f.node_id
+       WHERE n.project_id = ?`
+  ).get(projectId);
+  return {
+    total: kinds.reduce((sum, k) => sum + k.n, 0),
+    byKind: Object.fromEntries(kinds.map((k) => [k.kind, k.n])),
+    oldest: range.oldest,
+    newest: range.newest,
+    distinctFiles: files.n
+  };
+}
+
+// src/store/meta.ts
+function getMeta(db, key) {
+  const row = db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setMeta(db, key, value) {
+  db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(
+    key,
+    value
+  );
+}
+
+// src/store/store.ts
 var MemoryStore = class _MemoryStore {
   constructor(db) {
     this.db = db;
@@ -1039,35 +1437,17 @@ var MemoryStore = class _MemoryStore {
     this.db.close();
   }
   upsertProject(project) {
-    this.db.prepare(
-      `INSERT INTO projects (id, root, origin_url, created_at)
-         VALUES (@id, @root, @originUrl, @now)
-         ON CONFLICT(id) DO UPDATE SET root = excluded.root, origin_url = excluded.origin_url`
-    ).run({ ...project, now: Date.now() });
+    upsertProject(this.db, project);
   }
   markSynced(projectId) {
-    this.db.prepare("UPDATE projects SET last_synced_at = ? WHERE id = ?").run(Date.now(), projectId);
+    markSynced(this.db, projectId);
   }
-  /**
-   * Every other project id ever recorded in THIS repo's own database.
-   *
-   * A repo's `.nexusmem/memory.db` is never shared with another repo (each
-   * gets its own, gitignored), so any id here besides `currentProjectId` is
-   * evidence of a prior identity for this same repo -- typically its git
-   * remote URL changed since the last sync. See `reconcileProjectId` in
-   * `store/reconcile.ts`.
-   */
   listOtherProjectIds(currentProjectId) {
-    return this.db.prepare("SELECT id FROM projects WHERE id != ?").all(currentProjectId).map(
-      (r) => r.id
-    );
+    return listOtherProjectIds(this.db, currentProjectId);
   }
   /** Total nodes held under the given project identities. */
   countProjectNodes(projectIds) {
-    if (projectIds.length === 0) return 0;
-    const placeholders = projectIds.map(() => "?").join(", ");
-    const row = this.db.prepare(`SELECT COUNT(*) AS n FROM nodes WHERE project_id IN (${placeholders})`).get(...projectIds);
-    return row.n;
+    return countProjectNodes(this.db, projectIds);
   }
   /**
    * Write a batch of nodes in one transaction.
@@ -1077,81 +1457,7 @@ var MemoryStore = class _MemoryStore {
    * happens when scoring or body composition is improved between releases).
    */
   upsertNodes(nodes) {
-    const exists = this.db.prepare("SELECT body, signal, title FROM nodes WHERE id = ?");
-    const dropStaleEmbedding = this.db.prepare(
-      "DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)"
-    );
-    const insertNode = this.db.prepare(
-      `INSERT INTO nodes (id, kind, project_id, ts, ts_epoch, source, title, body, signal, meta, provenance, supersedes, created_at)
-       VALUES (@id, @kind, @projectId, @ts, @tsEpoch, @source, @title, @body, @signal, @meta, @provenance, @supersedes, @now)
-       ON CONFLICT(id) DO UPDATE SET
-         ts = excluded.ts, ts_epoch = excluded.ts_epoch, source = excluded.source,
-         title = excluded.title, body = excluded.body, signal = excluded.signal, meta = excluded.meta,
-         provenance = excluded.provenance`
-    );
-    const clearFiles = this.db.prepare("DELETE FROM node_files WHERE node_id = ?");
-    const insertFile = this.db.prepare(
-      `INSERT INTO node_files (node_id, path, previous_path, insertions, deletions, is_binary)
-       VALUES (@nodeId, @path, @previousPath, @insertions, @deletions, @isBinary)
-       ON CONFLICT(node_id, path) DO UPDATE SET
-         previous_path = excluded.previous_path, insertions = excluded.insertions,
-         deletions = excluded.deletions, is_binary = excluded.is_binary`
-    );
-    const stats = { inserted: 0, updated: 0, unchanged: 0, denied: 0 };
-    const denyEntriesByProject = /* @__PURE__ */ new Map();
-    const run = this.db.transaction((batch) => {
-      const now = Date.now();
-      for (const node of batch) {
-        let denyEntries = denyEntriesByProject.get(node.projectId);
-        if (!denyEntries) {
-          denyEntries = listDenyListEntries(this.db, node.projectId);
-          denyEntriesByProject.set(node.projectId, denyEntries);
-        }
-        if (firstMatchingEntry(denyEntries, node)) {
-          stats.denied += 1;
-          continue;
-        }
-        const prior = exists.get(node.id);
-        if (prior) {
-          if (prior.body === node.body && prior.signal === node.signal && prior.title === node.title) {
-            stats.unchanged += 1;
-            continue;
-          }
-          stats.updated += 1;
-          dropStaleEmbedding.run(node.id);
-        } else {
-          stats.inserted += 1;
-        }
-        insertNode.run({
-          id: node.id,
-          kind: node.kind,
-          projectId: node.projectId,
-          ts: node.ts,
-          tsEpoch: epochOf(node.ts),
-          source: node.source,
-          title: node.title,
-          body: node.body,
-          signal: node.signal,
-          meta: JSON.stringify(node.meta),
-          provenance: node.provenance ?? defaultProvenanceForKind(node.kind),
-          supersedes: node.supersedes ?? null,
-          now
-        });
-        clearFiles.run(node.id);
-        for (const file of node.files) {
-          insertFile.run({
-            nodeId: node.id,
-            path: file.path,
-            previousPath: file.previousPath ?? null,
-            insertions: file.insertions,
-            deletions: file.deletions,
-            isBinary: file.binary ? 1 : 0
-          });
-        }
-      }
-    });
-    run(nodes);
-    return stats;
+    return upsertNodes(this.db, nodes);
   }
   /**
    * The stored `meta` blob for one node, or null if it has never been
@@ -1159,53 +1465,28 @@ var MemoryStore = class _MemoryStore {
    * 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;
-    }
+    return getNodeMeta(this.db, id);
   }
   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;
+    return getSyncCursor(this.db, projectId, source);
   }
   setSyncCursor(projectId, source, cursor) {
-    this.db.prepare(
-      `INSERT INTO sync_state (project_id, source, cursor, last_run_at)
-         VALUES (?, ?, ?, ?)
-         ON CONFLICT(project_id, source) DO UPDATE SET cursor = excluded.cursor, last_run_at = excluded.last_run_at`
-    ).run(projectId, source, cursor, Date.now());
+    setSyncCursor(this.db, projectId, source, cursor);
   }
   /** Every source that has ever synced for this project, most recently run first. */
   listSyncState(projectId) {
-    return this.db.prepare("SELECT source, cursor, last_run_at AS lastRunAt FROM sync_state WHERE project_id = ? ORDER BY last_run_at DESC").all(projectId);
+    return listSyncState(this.db, projectId);
   }
   /** Drop every node for a project. Used by `sync --rebuild`. */
   clearProject(projectId) {
-    this.db.prepare("DELETE FROM nodes_vec WHERE rowid IN (SELECT rowid FROM nodes WHERE project_id = ?)").run(projectId);
-    const info = this.db.prepare("DELETE FROM nodes WHERE project_id = ?").run(projectId);
-    this.db.prepare("DELETE FROM sync_state WHERE project_id = ?").run(projectId);
-    return info.changes;
+    return clearProject(this.db, projectId);
   }
-  /**
-   * Record a directed relationship between two existing nodes -- e.g. a
-   * failed `shell_command` and whatever node later resolved it
-   * (`relation = 'resolved_by'`). A relation, not a new content node: the
-   * correlation *is* the relationship, and duplicating either side's content
-   * into a third node would just be another independently-ranked candidate.
-   *
-   * Idempotent by design (`INSERT OR IGNORE` against the table's own primary
-   * key) so re-running a correlation pass over already-linked nodes is a
-   * no-op, not a duplicate-row error.
-   */
   linkNodes(fromNodeId, toNodeId, relation) {
-    this.db.prepare("INSERT OR IGNORE INTO node_links (from_node_id, to_node_id, relation, created_at) VALUES (?, ?, ?, ?)").run(fromNodeId, toNodeId, relation, Date.now());
+    linkNodes(this.db, fromNodeId, toNodeId, relation);
   }
   /** Ids linked from `fromNodeId` under one relation, most recently linked first. Empty if none exist. */
   getLinkedNodeIds(fromNodeId, relation) {
-    return this.db.prepare("SELECT to_node_id FROM node_links WHERE from_node_id = ? AND relation = ? ORDER BY created_at DESC").all(fromNodeId, relation).map((row) => row.to_node_id);
+    return getLinkedNodeIds(this.db, fromNodeId, relation);
   }
   /**
    * Hydrate full content for a set of node ids, e.g. to pack a linked
@@ -1219,11 +1500,7 @@ var MemoryStore = class _MemoryStore {
    * that gap is not addressed here.
    */
   getNodesByIds(ids) {
-    if (ids.length === 0) return [];
-    return this.db.prepare(
-      `SELECT id, kind, project_id AS projectId, ts, title, body, signal, provenance
-         FROM nodes WHERE id IN (SELECT value FROM json_each(?))`
-    ).all(JSON.stringify(ids));
+    return getNodesByIds(this.db, ids);
   }
   /**
    * The most recently-remembered nodes for a project, newest event first --
@@ -1232,18 +1509,11 @@ var MemoryStore = class _MemoryStore {
    * `idx_nodes_project_ts` already exists for exactly this access pattern.
    */
   listRecentNodes(projectId, limit = 20) {
-    return this.db.prepare(
-      `SELECT id, kind, ts, source, title, signal, provenance
-         FROM nodes
-         WHERE project_id = ?
-         ORDER BY ts_epoch DESC
-         LIMIT ?`
-    ).all(projectId, limit);
+    return listRecentNodes(this.db, projectId, limit);
   }
   /** How many nodes of one source exist for a project. Used to preview a `pruneSourceNodes` wipe before running it. */
   countSourceNodes(projectId, source) {
-    const row = this.db.prepare("SELECT COUNT(*) AS count FROM nodes WHERE project_id = ? AND source = ?").get(projectId, source);
-    return row.count;
+    return countSourceNodes(this.db, projectId, source);
   }
   /**
    * Delete the nodes of one source that its latest full scan did not produce.
@@ -1271,314 +1541,70 @@ var MemoryStore = class _MemoryStore {
    * real history.
    */
   pruneSourceNodes(projectId, source, keepIds, opts = {}) {
-    const scope = `project_id = @projectId AND source = @source
-        AND id NOT IN (SELECT value FROM json_each(@keepIds))
-        AND id NOT IN (SELECT node_id FROM node_files WHERE path IN (SELECT value FROM json_each(@keepPaths)))`;
-    const params = {
-      projectId,
-      source,
-      keepIds: JSON.stringify(keepIds),
-      keepPaths: JSON.stringify(opts.keepPaths ?? [])
-    };
-    return this.db.transaction(() => {
-      this.db.prepare(`DELETE FROM nodes_vec WHERE rowid IN (SELECT rowid FROM nodes WHERE ${scope})`).run(params);
-      return this.db.prepare(`DELETE FROM nodes WHERE ${scope}`).run(params).changes;
-    })();
+    return pruneSourceNodes(this.db, projectId, source, keepIds, opts);
   }
-  /**
-   * What `forget(projectId, otherProjectIds, input)` with these same
-   * arguments would remove, without writing anything -- the `forget` CLI
-   * command's dry-run default.
-   */
   previewForget(projectId, otherProjectIds, input) {
-    validatePattern(input);
-    const probeEntry = { id: -1, projectId, createdAt: 0, ...input };
-    const select = this.db.prepare("SELECT project_id, source, title, body, meta FROM nodes WHERE project_id = ?");
-    const counts = /* @__PURE__ */ new Map();
-    for (const scopeId of [projectId, ...otherProjectIds]) {
-      const rows = select.all(scopeId);
-      for (const row of rows) {
-        if (!firstMatchingEntry([probeEntry], { title: row.title, body: row.body, meta: parseMeta(row.meta) })) continue;
-        const key = `${row.project_id} ${row.source}`;
-        const existing = counts.get(key);
-        if (existing) existing.count += 1;
-        else counts.set(key, { projectId: row.project_id, source: row.source, count: 1 });
-      }
-    }
-    return [...counts.values()];
+    return previewForget(this.db, projectId, otherProjectIds, input);
   }
-  /**
-   * Permanently deny-list a value and delete every node it currently matches
-   * across `projectId` + `otherProjectIds` (the same sweep `pruneSourceNodes`
-   * uses for a repo's stale prior identities).
-   *
-   * Unlike `pruneSourceNodes`, this doesn't just delete: the deny-list entry
-   * written here is consulted by `upsertNodes` and `reconcile.ts` on every
-   * future write, so a value forgotten today cannot be re-derived from an
-   * append-only source (the shell-hook log, a full transcript re-read) on a
-   * later `sync --rebuild`. Each removed node leaves a hash-only tombstone
-   * (never the content itself) and the whole operation writes one
-   * `mutation_audit` row, whether or not anything matched -- pre-emptively
-   * blocking a value that hasn't appeared yet is a valid, auditable call.
-   */
   forget(projectId, otherProjectIds, input) {
-    return this.db.transaction(() => {
-      const entry = insertDenyListEntry(this.db, { ...input, projectId });
-      const startedAt = Date.now();
-      const auditId = Number(
-        this.db.prepare(
-          `INSERT INTO mutation_audit (action, project_id, detail, affected_count, succeeded, error, started_at, finished_at)
-             VALUES ('forget', @projectId, @detail, 0, 1, NULL, @startedAt, @startedAt)`
-        ).run({
-          projectId,
-          detail: JSON.stringify({
-            pattern: input.pattern,
-            matchType: input.matchType,
-            ignoreCase: input.ignoreCase,
-            reason: input.reason,
-            scopeProjectIds: [projectId, ...otherProjectIds]
-          }),
-          startedAt
-        }).lastInsertRowid
-      );
-      const select = this.db.prepare(
-        "SELECT id, kind, project_id, source, ts, signal, title, body, meta FROM nodes WHERE project_id = ?"
-      );
-      const dropEmbedding = this.db.prepare("DELETE FROM nodes_vec WHERE rowid = (SELECT rowid FROM nodes WHERE id = ?)");
-      const deleteNode = this.db.prepare("DELETE FROM nodes WHERE id = ?");
-      const insertTombstone = this.db.prepare(
-        `INSERT INTO tombstones
-           (node_id, project_id, kind, source, ts, signal, body_sha256, title_sha256, body_length, deny_list_id, mutation_audit_id, removed_at)
-         VALUES (@nodeId, @projectId, @kind, @source, @ts, @signal, @bodySha256, @titleSha256, @bodyLength, @denyListId, @mutationAuditId, @removedAt)`
-      );
-      let removed = 0;
-      for (const scopeId of [projectId, ...otherProjectIds]) {
-        const rows = select.all(scopeId);
-        for (const row of rows) {
-          if (!firstMatchingEntry([entry], { title: row.title, body: row.body, meta: parseMeta(row.meta) })) continue;
-          dropEmbedding.run(row.id);
-          insertTombstone.run({
-            nodeId: row.id,
-            projectId: row.project_id,
-            kind: row.kind,
-            source: row.source,
-            ts: row.ts,
-            signal: row.signal,
-            bodySha256: sha256Hex(row.body),
-            titleSha256: sha256Hex(row.title),
-            bodyLength: row.body.length,
-            denyListId: entry.id,
-            mutationAuditId: auditId,
-            removedAt: Date.now()
-          });
-          deleteNode.run(row.id);
-          removed += 1;
-        }
-      }
-      this.db.prepare("UPDATE mutation_audit SET affected_count = ?, finished_at = ? WHERE id = ?").run(removed, Date.now(), auditId);
-      return { removed, entryId: entry.id, auditId };
-    })();
+    return forget(this.db, projectId, otherProjectIds, input);
   }
   /** Active deny-list entries for one project, oldest first. */
   listDenyList(projectId) {
-    return listDenyListEntries(this.db, projectId);
+    return listDenyList(this.db, projectId);
   }
-  /**
-   * What `importDenyList` with these same entries would do, without writing
-   * anything -- `forget --import`'s dry-run default, same convention as
-   * `previewForget`.
-   */
   previewImportDenyList(projectId, otherProjectIds, entries) {
-    return entries.map((input) => {
-      validatePattern(input);
-      if (denyListEntryExists(this.db, projectId, input)) {
-        return { matchType: input.matchType, pattern: input.pattern, alreadyPresent: true, wouldRemove: 0 };
-      }
-      const preview = this.previewForget(projectId, otherProjectIds, input);
-      return {
-        matchType: input.matchType,
-        pattern: input.pattern,
-        alreadyPresent: false,
-        wouldRemove: preview.reduce((sum, p) => sum + p.count, 0)
-      };
-    });
+    return previewImportDenyList(this.db, projectId, otherProjectIds, entries);
   }
-  /**
-   * Re-apply a previously-exported deny-list against this project.
-   *
-   * This is the fix for `forget`'s per-checkout gap: `deny_list` lives in
-   * `.nexusmem/memory.db`, which is gitignored and never travels with `git
-   * clone`/`git push`, while the things a fresh `sync` re-derives from --
-   * git history and the user-home shell-hook log -- both travel or persist
-   * independently of any one checkout. A fresh clone or a restored backup
-   * starts with an empty deny_list and no memory of what was forgotten. See
-   * docs/forget-mechanism.md.
-   *
-   * Entries already active (same matchType+pattern+ignoreCase) are left
-   * untouched. Every new one goes through `forget` itself, so an imported
-   * value is deleted from this checkout's nodes too, not just blocked going
-   * forward -- exactly what running `nexusmem forget <value>` fresh in this
-   * checkout would have done.
-   */
   importDenyList(projectId, otherProjectIds, entries) {
-    let imported = 0;
-    let skipped = 0;
-    let removedNodes = 0;
-    for (const input of entries) {
-      validatePattern(input);
-      if (denyListEntryExists(this.db, projectId, input)) {
-        skipped += 1;
-        continue;
-      }
-      const result = this.forget(projectId, otherProjectIds, input);
-      imported += 1;
-      removedNodes += result.removed;
-    }
-    return { imported, skipped, removedNodes };
+    return importDenyList(this.db, projectId, otherProjectIds, entries);
   }
-  /**
-   * Replace this project's entire `file_edges` snapshot in one transaction.
-   *
-   * Edges describe the current working tree, not history -- unlike
-   * `pruneSourceNodes`'s incremental diff-against-a-scan, there is no cursor
-   * to walk, so every `scan-structure`/sync run is a full rescan and this is
-   * always a delete-then-insert of the whole set, never a partial update.
-   */
   replaceFileEdges(projectId, edges) {
-    this.db.transaction(() => {
-      this.db.prepare("DELETE FROM file_edges WHERE project_id = ?").run(projectId);
-      const insert = this.db.prepare(
-        "INSERT OR IGNORE INTO file_edges (project_id, from_path, to_path, kind) VALUES (?, ?, ?, ?)"
-      );
-      for (const edge of edges) insert.run(projectId, edge.fromPath, edge.toPath, edge.kind);
-    })();
+    replaceFileEdges(this.db, projectId, edges);
   }
   /** Edge count + distinct source-file count, for `nexusmem status`'s `structure` line. */
   fileEdgeStats(projectId) {
-    const edges = this.db.prepare("SELECT COUNT(*) AS c FROM file_edges WHERE project_id = ?").get(projectId).c;
-    const files = this.db.prepare("SELECT COUNT(DISTINCT from_path) AS c FROM file_edges WHERE project_id = ?").get(projectId).c;
-    return { edges, files };
+    return fileEdgeStats(this.db, projectId);
   }
-  /**
-   * 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 AND n.rowid > ?
-         ORDER BY n.rowid
-         LIMIT ?`
-    ).all(projectId, afterRowid, limit);
+    return findNodesNeedingEmbedding(this.db, projectId, limit, afterRowid);
   }
   /** 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;
+    return countNodesNeedingEmbedding(this.db, projectId);
   }
   upsertEmbedding(rowid, embedding) {
-    this.db.prepare("INSERT OR REPLACE INTO nodes_vec (rowid, embedding) VALUES (?, ?)").run(BigInt(rowid), embedding);
+    upsertEmbedding(this.db, 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;
+    return dropAllEmbeddings(this.db);
   }
   getMeta(key) {
-    const row = this.db.prepare("SELECT value FROM meta WHERE key = ?").get(key);
-    return row?.value ?? null;
+    return getMeta(this.db, key);
   }
   setMeta(key, value) {
-    this.db.prepare("INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(key, value);
+    setMeta(this.db, key, value);
   }
-  /**
-   * Nearest-neighbour search over the corpus.
-   *
-   * `nodes_vec` has no `project_id` column of its own (embeddings are
-   * generic; project scoping lives on `nodes`), so this over-fetches `k`
-   * before joining and filtering, then caps to `limit`. Simple and correct;
-   * not the efficient way to do this at a scale this project isn't at yet.
-   */
   vectorSearch(projectId, embedding, limit = 20) {
-    const overfetch = Math.max(limit * 8, 50);
-    return this.db.prepare(
-      `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal, n.provenance, v.distance AS distance
-         FROM nodes_vec v
-         JOIN nodes n ON n.rowid = v.rowid
-         WHERE v.embedding MATCH ? AND k = ? AND n.project_id = ?
-         ORDER BY v.distance
-         LIMIT ?`
-    ).all(embedding, overfetch, projectId, limit);
+    return vectorSearch(this.db, projectId, embedding, limit);
   }
   stats(projectId) {
-    const kinds = this.db.prepare("SELECT kind, COUNT(*) AS n FROM nodes WHERE project_id = ? GROUP BY kind").all(projectId);
-    const range = this.db.prepare("SELECT MIN(ts) AS oldest, MAX(ts) AS newest FROM nodes WHERE project_id = ?").get(projectId);
-    const files = this.db.prepare(
-      `SELECT COUNT(DISTINCT f.path) AS n
-         FROM node_files f JOIN nodes n ON n.id = f.node_id
-         WHERE n.project_id = ?`
-    ).get(projectId);
-    return {
-      total: kinds.reduce((sum, k) => sum + k.n, 0),
-      byKind: Object.fromEntries(kinds.map((k) => [k.kind, k.n])),
-      oldest: range.oldest,
-      newest: range.newest,
-      distinctFiles: files.n
-    };
+    return stats(this.db, projectId);
   }
-  /**
-   * Lexical search over the corpus.
-   *
-   * Title is weighted 10x body: a commit subject that names the thing you asked
-   * about is far stronger evidence than the same word buried in a file list.
-   * Ranking by `relevance x signal` happens a layer up, in retrieval.
-   */
   search(projectId, query, limit = 20) {
-    const match = toMatchQuery(query);
-    if (!match) return [];
-    const rows = this.db.prepare(
-      `SELECT n.id, n.kind, n.ts, n.title, n.body, n.signal, n.provenance,
-                bm25(nodes_fts, 10.0, 1.0) AS rank
-         FROM nodes_fts
-         JOIN nodes n ON n.rowid = nodes_fts.rowid
-         WHERE nodes_fts MATCH ? AND n.project_id = ?
-         ORDER BY rank
-         LIMIT ?`
-    ).all(match, projectId, limit);
-    return rows;
+    return search(this.db, projectId, query, limit);
   }
   /** The project a node belongs to, or null if no node has this id. Used by `mark-stale` to validate both ids. */
   getNodeProjectId(id) {
-    const row = this.db.prepare("SELECT project_id FROM nodes WHERE id = ?").get(id);
-    return row?.project_id ?? null;
+    return getNodeProjectId(this.db, id);
   }
   /** Every node id some other node's `supersedes` points at, for one project -- what the ranker should down-weight. */
   getSupersededIds(projectId) {
-    const rows = this.db.prepare("SELECT DISTINCT supersedes AS id FROM nodes WHERE project_id = ? AND supersedes IS NOT NULL").all(projectId);
-    return new Set(rows.map((r) => r.id));
+    return getSupersededIds(this.db, projectId);
   }
   /** Record that `newNodeId` supersedes `staleNodeId` -- the write behind `nexusmem mark-stale`. Caller validates both ids first. */
   setSupersedes(newNodeId, staleNodeId) {
-    this.db.prepare("UPDATE nodes SET supersedes = ? WHERE id = ?").run(staleNodeId, newNodeId);
+    setSupersedes(this.db, newNodeId, staleNodeId);
   }
   /** Escape hatch for tests and future modules. */
   get raw() {
@@ -3915,8 +3941,8 @@ function hookEntryToRaw(e) {
 }
 async function tryReadScrapeSource(path, parse, tailLines) {
   if (!existsSync4(path)) return null;
-  const [raw, stats] = await Promise.all([readFile9(path, "utf8"), stat2(path)]);
-  return parse(raw, stats.mtimeMs, { tailLines });
+  const [raw, stats2] = await Promise.all([readFile9(path, "utf8"), stat2(path)]);
+  return parse(raw, stats2.mtimeMs, { tailLines });
 }
 async function collectAvailableShellHistory(opts = {}) {
   const results = [];
@@ -4575,7 +4601,7 @@ async function runSync(opts) {
     addStats(totals, conversation.totals);
     addStats(totals, sessions.totals);
     addStats(totals, docs.totals);
-    const stats = store.stats(projectId);
+    const stats2 = store.stats(projectId);
     const elapsed = ((Date.now() - started) / 1e3).toFixed(2);
     const conversationPart = conversationEnabled ? `, ${conversation.seen} conversation exchange(s)` : "";
     const sessionPart = config.sources.session.enabled ? `, ${sessions.seen} session summar${sessions.seen === 1 ? "y" : "ies"}` : "";
@@ -4587,7 +4613,7 @@ async function runSync(opts) {
       [
         `${pc7.green("synced")} ${git2.seen} commit(s)${diffPart}, ${shell.seen} shell entr${shell.seen === 1 ? "y" : "ies"}${conversationPart}${sessionPart}${docsPart}${structurePart} in ${elapsed}s`,
         `  ${pc7.green(`+${totals.inserted} new`)}  ${pc7.yellow(`~${totals.updated} updated`)}  ${pc7.dim(`=${totals.unchanged} unchanged`)}${deniedPart}`,
-        `  ${pc7.dim(`${stats.total} node(s) total across ${stats.distinctFiles} file path(s)`)}`,
+        `  ${pc7.dim(`${stats2.total} node(s) total across ${stats2.distinctFiles} file path(s)`)}`,
         ""
       ].join("\n") + embedLine + linkLine
     );
@@ -4682,8 +4708,8 @@ async function getStatus(input) {
   const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
   const store = MemoryStore.open(ws.dbPath);
   try {
-    const stats = store.stats(projectId);
-    return { total: stats.total, byKind: stats.byKind, sources: store.listSyncState(projectId) };
+    const stats2 = store.stats(projectId);
+    return { total: stats2.total, byKind: stats2.byKind, sources: store.listSyncState(projectId) };
   } finally {
     store.close();
   }
@@ -4995,6 +5021,26 @@ var BAND_COLOR = {
 function formatSignal(signal, bands) {
   return BAND_COLOR[signalBand(signal, bands)](signal.toFixed(2));
 }
+function approxTotalTokens(nodes) {
+  return nodes.reduce((n, x) => n + approxTokens(x.body), 0);
+}
+function summarize2(nodes) {
+  if (nodes.length === 0) return pc10.yellow("no commits matched");
+  const timestamps = nodes.map((n) => n.ts).sort();
+  const avgSignal = nodes.reduce((n, x) => n + x.signal, 0) / nodes.length;
+  const totalTokens = approxTotalTokens(nodes);
+  const fileHits = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    for (const f of node.files) fileHits.set(f.path, (fileHits.get(f.path) ?? 0) + 1);
+  }
+  const hottest = [...fileHits.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([path, count]) => `    ${String(count).padStart(3)}x ${path}`);
+  return [
+    `${pc10.bold(String(nodes.length))} nodes  ${pc10.dim(`${timestamps[0]?.slice(0, 10)} .. ${timestamps.at(-1)?.slice(0, 10)}`)}`,
+    `  avg signal ${avgSignal.toFixed(3)}   ~${totalTokens.toLocaleString()} tokens if sent raw`,
+    hottest.length ? `  hottest files:
+${hottest.join("\n")}` : ""
+  ].filter(Boolean).join("\n");
+}
 
 // src/cli/commands/scan-conversation.ts
 async function runScanConversation(opts) {
@@ -5019,7 +5065,7 @@ async function runScanConversation(opts) {
   for (const node of nodes) process.stdout.write(`${formatNode(node)}
 `);
   const redactedTotal = nodes.reduce((n, x) => n + (Number(x.meta.redactedCount) || 0), 0);
-  const approxTotal = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
+  const approxTotal = approxTotalTokens(nodes);
   process.stderr.write(
     `
 ${pc11.bold(String(nodes.length))} of ${turns.length} exchange(s) above threshold  ${pc11.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}` + (redactedTotal > 0 ? `  ${pc11.yellow(`${redactedTotal} secret-like value(s) redacted`)}` : "") + "\n"
@@ -5031,11 +5077,9 @@ function formatNode(node) {
 }
 
 // src/cli/commands/scan-diff.ts
-import pc13 from "picocolors";
-
-// src/cli/commands/scan-git.ts
 import pc12 from "picocolors";
-async function runScanGit(opts) {
+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) {
@@ -5043,19 +5087,16 @@ async function runScanGit(opts) {
       [
         `${pc12.dim("repo   ")} ${repo.root}`,
         `${pc12.dim("branch ")} ${repo.branch ?? pc12.yellow("(detached)")}`,
-        `${pc12.dim("origin ")} ${repo.originUrl ?? pc12.dim("(none)")}`,
         `${pc12.dim("project")} ${pc12.cyan(projectId)}`,
         ""
       ].join("\n")
     );
   }
   const nodes = [];
-  const collectOpts = {
+  for await (const node of collectCommitDiffs(repo.root, projectId, {
     since: opts.since ?? null,
-    maxCount: opts.limit ?? null,
-    includeMerges: opts.merges
-  };
-  for await (const node of collectGitCommits(repo.root, projectId, collectOpts)) {
+    maxCount: opts.limit ?? DEFAULT_SCAN_COMMITS
+  })) {
     if (node.signal < opts.minSignal) continue;
     nodes.push(node);
     if (!opts.json) process.stdout.write(`${formatNode2(node)}
@@ -5073,119 +5114,105 @@ ${summarize2(nodes)}
 }
 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);
   const churn = `+${node.meta.insertions ?? 0}/-${node.meta.deletions ?? 0}`;
   return [
-    formatSignal(node.signal, GIT_SIGNAL_BANDS),
-    pc12.dim(date),
+    formatSignal(node.signal, DIFF_SIGNAL_BANDS),
+    pc12.dim(node.ts.slice(0, 10)),
     pc12.magenta(sha),
-    node.title,
-    pc12.dim(`(${files} file${files === 1 ? "" : "s"}, ${churn})`)
+    String(node.meta.path ?? ""),
+    pc12.dim(`(${churn}, ${node.meta.hunkCount ?? 0} hunk(s))`)
   ].join(" ");
 }
-function summarize2(nodes) {
-  if (nodes.length === 0) return pc12.yellow("no commits matched");
-  const timestamps = nodes.map((n) => n.ts).sort();
-  const avgSignal = nodes.reduce((n, x) => n + x.signal, 0) / nodes.length;
-  const totalTokens = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
-  const fileHits = /* @__PURE__ */ new Map();
-  for (const node of nodes) {
-    for (const f of node.files) fileHits.set(f.path, (fileHits.get(f.path) ?? 0) + 1);
-  }
-  const hottest = [...fileHits.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([path, count]) => `    ${String(count).padStart(3)}x ${path}`);
-  return [
-    `${pc12.bold(String(nodes.length))} nodes  ${pc12.dim(`${timestamps[0]?.slice(0, 10)} .. ${timestamps.at(-1)?.slice(0, 10)}`)}`,
-    `  avg signal ${avgSignal.toFixed(3)}   ~${totalTokens.toLocaleString()} tokens if sent raw`,
-    hottest.length ? `  hottest files:
-${hottest.join("\n")}` : ""
-  ].filter(Boolean).join("\n");
-}
 
-// src/cli/commands/scan-diff.ts
-var DEFAULT_SCAN_COMMITS = 50;
-async function runScanDiff(opts) {
+// src/cli/commands/scan-docs.ts
+import pc13 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(
-      [
-        `${pc13.dim("repo   ")} ${repo.root}`,
-        `${pc13.dim("branch ")} ${repo.branch ?? pc13.yellow("(detached)")}`,
-        `${pc13.dim("project")} ${pc13.cyan(projectId)}`,
-        ""
-      ].join("\n")
+      files.length ? `${pc13.dim("tracked .md files")} ${files.map((f) => f.path).join(", ")}
+
+` : `${pc13.yellow("no tracked .md files found")}
+`
     );
-  }
-  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 (unreadable.length > 0) {
+      process.stderr.write(`${pc13.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;
   }
-  process.stderr.write(`
-${summarize2(nodes)}
+  for (const node of nodes) process.stdout.write(`${formatNode3(node)}
 `);
+  const approxTotal = approxTotalTokens(nodes);
+  process.stderr.write(
+    `
+${pc13.bold(String(nodes.length))} section(s) from ${files.length} file(s) above threshold  ${pc13.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
+`
+  );
   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),
-    pc13.dim(node.ts.slice(0, 10)),
-    pc13.magenta(sha),
-    String(node.meta.path ?? ""),
-    pc13.dim(`(${churn}, ${node.meta.hunkCount ?? 0} hunk(s))`)
-  ].join(" ");
+  return [formatSignal(node.signal, DOCS_SIGNAL_BANDS), node.title].join(" ");
 }
 
-// src/cli/commands/scan-docs.ts
+// src/cli/commands/scan-git.ts
 import pc14 from "picocolors";
-async function runScanDocs(opts) {
+async function runScanGit(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 ? `${pc14.dim("tracked .md files")} ${files.map((f) => f.path).join(", ")}
-
-` : `${pc14.yellow("no tracked .md files found")}
-`
+      [
+        `${pc14.dim("repo   ")} ${repo.root}`,
+        `${pc14.dim("branch ")} ${repo.branch ?? pc14.yellow("(detached)")}`,
+        `${pc14.dim("origin ")} ${repo.originUrl ?? pc14.dim("(none)")}`,
+        `${pc14.dim("project")} ${pc14.cyan(projectId)}`,
+        ""
+      ].join("\n")
     );
-    if (unreadable.length > 0) {
-      process.stderr.write(`${pc14.yellow("unreadable")} ${unreadable.join(", ")}
-
+  }
+  const nodes = [];
+  const collectOpts = {
+    since: opts.since ?? null,
+    maxCount: opts.limit ?? null,
+    includeMerges: opts.merges
+  };
+  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(`${formatNode4(node)}
 `);
-    }
   }
-  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)}
+  process.stderr.write(`
+${summarize2(nodes)}
 `);
-  const approxTotal = nodes.reduce((n, x) => n + approxTokens(x.body), 0);
-  process.stderr.write(
-    `
-${pc14.bold(String(nodes.length))} section(s) from ${files.length} file(s) above threshold  ${pc14.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
-`
-  );
   return 0;
 }
 function formatNode4(node) {
-  return [formatSignal(node.signal, DOCS_SIGNAL_BANDS), node.title].join(" ");
+  const sha = String(node.meta.shortSha ?? "").padEnd(9);
+  const date = node.ts.slice(0, 10);
+  const files = Number(node.meta.filesChanged ?? 0);
+  const churn = `+${node.meta.insertions ?? 0}/-${node.meta.deletions ?? 0}`;
+  return [
+    formatSignal(node.signal, GIT_SIGNAL_BANDS),
+    pc14.dim(date),
+    pc14.magenta(sha),
+    node.title,
+    pc14.dim(`(${files} file${files === 1 ? "" : "s"}, ${churn})`)
+  ].join(" ");
 }
 
 // src/cli/commands/scan-session.ts
@@ -5303,7 +5330,7 @@ async function runScanShell(opts) {
 `);
     return 0;
   }
-  const approxTotal = allNodes.reduce((n, x) => n + approxTokens(x.body), 0);
+  const approxTotal = approxTotalTokens(allNodes);
   process.stderr.write(`${pc16.bold(String(allNodes.length))} node(s) total  ${pc16.dim(`~${approxTotal.toLocaleString()} tokens if sent raw`)}
 `);
   return 0;
@@ -5362,7 +5389,7 @@ async function runStatus(opts) {
   const { repo, ws, projectId } = await loadContext(opts.cwd);
   const store = MemoryStore.open(ws.dbPath);
   try {
-    const stats = store.stats(projectId);
+    const stats2 = store.stats(projectId);
     const sources = store.listSyncState(projectId);
     const gitCursor = sources.find((s) => s.source === "git")?.cursor ?? null;
     const schema = currentSchemaVersion(store.raw);
@@ -5371,7 +5398,7 @@ async function runStatus(opts) {
     const otherProjectNodes = store.countProjectNodes(otherProjectIds);
     const structure = store.fileEdgeStats(projectId);
     const dbBytes = fileSize(ws.dbPath) + fileSize(`${ws.dbPath}-wal`);
-    const kinds = Object.entries(stats.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
+    const kinds = Object.entries(stats2.byKind).sort((a, b) => b[1] - a[1]).map(([kind, n]) => `    ${String(n).padStart(6)}  ${kind}`);
     const staleProjectWarning = otherProjectIds.length ? `${pc18.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc18.bold(
       "nexusmem sync --prune-source <name>"
     )} to remove stale source data` : "";
@@ -5384,9 +5411,9 @@ async function runStatus(opts) {
         `${pc18.dim("database")} ${ws.dbPath} ${pc18.dim(`(${humanBytes(dbBytes)})`)}`,
         staleProjectWarning,
         "",
-        `${pc18.bold(String(stats.total))} node(s)${stats.total ? ` ${pc18.dim(`${stats.oldest?.slice(0, 10)} .. ${stats.newest?.slice(0, 10)}`)}` : ""}`,
+        `${pc18.bold(String(stats2.total))} node(s)${stats2.total ? ` ${pc18.dim(`${stats2.oldest?.slice(0, 10)} .. ${stats2.newest?.slice(0, 10)}`)}` : ""}`,
         ...kinds,
-        stats.total ? `    ${pc18.dim(`${stats.distinctFiles} distinct file path(s)`)}` : "",
+        stats2.total ? `    ${pc18.dim(`${stats2.distinctFiles} distinct file path(s)`)}` : "",
         "",
         sources.length ? pc18.dim("sources") : pc18.yellow("no sources synced yet"),
         ...sources.map((s) => {
@@ -5394,8 +5421,8 @@ async function runStatus(opts) {
           const cursorLabel = s.source === "git" ? s.cursor?.slice(0, 7) ?? "-" : s.cursor ?? "-";
           return `    ${s.source.padEnd(14)} ${pc18.dim(`last run ${when}`)}  ${pc18.dim(`cursor ${cursorLabel}`)}`;
         }),
-        gitCursor && gitCursor !== repo.head ? `${pc18.yellow("git behind HEAD")} \u2014 run ${pc18.bold("nexusmem sync")}` : "",
         "",
+        gitCursor && gitCursor !== repo.head ? `${pc18.yellow("git behind HEAD")} \u2014 run ${pc18.bold("nexusmem sync")}` : "",
         chains.failuresTotal ? `${pc18.dim("chains  ")} ${pc18.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc18.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc18.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
         structure.edges ? `${pc18.dim("structure")} ${pc18.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : ""
       ].filter((line) => line !== "").join("\n").concat("\n")