nexusmem 0.3.0 → 0.3.2

package/dist/cli/index.js

@@ -698,10 +698,22 @@ import * as sqliteVec from "sqlite-vec";
 
 // src/store/fts.ts
 var FTS_SYNTAX = /["'()*:^{}[\]-]/g;
-function toMatchQuery(input) {
+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 null;
-  return tokens.map((t) => `"${t}"*`).join(" OR ");
+  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 ");
+}
+function toStrictMatchQuery(input) {
+  const kept = significantTokens(input);
+  if (kept.length === 0) return null;
+  return kept.map((t) => `"${t}"*`).join(" AND ");
 }
 
 // src/store/schema.ts
@@ -795,9 +807,28 @@ CREATE VIRTUAL TABLE nodes_vec USING vec0 (
   embedding float[${EMBEDDING_DIM}]
 );
 `;
+var V3 = `
+-- A relation between two existing nodes, not a new content node -- the
+-- "failure -> fix" correlation is the relationship itself, and duplicating
+-- either side's content into a third node would just be another
+-- independently-ranked candidate instead of the link the feature needs.
+-- One physical table, multiple relation kinds; 'resolved_by' is the first.
+CREATE TABLE node_links (
+  from_node_id TEXT NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+  to_node_id   TEXT NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+  relation     TEXT NOT NULL,
+  created_at   INTEGER NOT NULL,
+  PRIMARY KEY (from_node_id, to_node_id, relation)
+);
+
+-- Packing a failure node needs its resolutions; nothing needs the reverse
+-- direction yet, so only the forward lookup gets an index.
+CREATE INDEX idx_node_links_from ON node_links (from_node_id);
+`;
 var MIGRATIONS = [
   { version: 1, up: (db) => db.exec(V1) },
-  { version: 2, up: (db) => db.exec(V2) }
+  { version: 2, up: (db) => db.exec(V2) },
+  { version: 3, up: (db) => db.exec(V3) }
 ];
 var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
 function currentSchemaVersion(db) {
@@ -848,6 +879,20 @@ var MemoryStore = class _MemoryStore {
   markSynced(projectId) {
     this.db.prepare("UPDATE projects SET last_synced_at = ? WHERE id = ?").run(Date.now(), 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
+    );
+  }
   /**
    * Write a batch of nodes in one transaction.
    *
@@ -955,6 +1000,62 @@ var MemoryStore = class _MemoryStore {
     this.db.prepare("DELETE FROM sync_state WHERE project_id = ?").run(projectId);
     return info.changes;
   }
+  /**
+   * 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());
+  }
+  /** 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);
+  }
+  /**
+   * Hydrate full content for a set of node ids, e.g. to pack a linked
+   * resolution alongside the failure node that points at it. Order is not
+   * guaranteed to match `ids`; ids with no matching row are silently omitted
+   * rather than erroring. `node_links` has `ON DELETE CASCADE` on both
+   * columns, so an individual node delete (e.g. `reconcile.ts` migrating a
+   * node to a freshly-computed id) removes any link pointing at the old id
+   * along with it -- correct as a safety default, though note that reconcile
+   * does not currently re-create the link under the migrated node's new id;
+   * that gap is not addressed here.
+   */
+  getNodesByIds(ids) {
+    if (ids.length === 0) return [];
+    return this.db.prepare(
+      `SELECT id, kind, project_id AS projectId, ts, title, body, signal
+         FROM nodes WHERE id IN (SELECT value FROM json_each(?))`
+    ).all(JSON.stringify(ids));
+  }
+  /**
+   * The most recently-remembered nodes for a project, newest event first --
+   * chronology, not relevance. No `body`: a listing (e.g. a sidebar) needs
+   * the title and enough metadata to label each row, not the full text.
+   * `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
+         FROM nodes
+         WHERE project_id = ?
+         ORDER BY ts_epoch DESC
+         LIMIT ?`
+    ).all(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;
+  }
   /**
    * Delete the nodes of one source that its latest full scan did not produce.
    *
@@ -1245,6 +1346,8 @@ function approxTokens(text) {
 var DEFAULT_SUMMARY_CHARS = 320;
 var NODE_OVERHEAD_TOKENS = 8;
 var CONVERSATION_ANSWER_MARKER = "\n\nA: ";
+var MAX_PER_FAMILY = 2;
+var CHUNKED_KINDS = /* @__PURE__ */ new Set(["conversation_turn", "doc_section"]);
 var HUNK_BOUNDARY = "\n@@ ";
 var STOPWORDS = /* @__PURE__ */ new Set([
   "the",
@@ -1363,7 +1466,14 @@ function packContext(ranked, tokensBudget, opts = {}) {
   const nodes = [];
   let tokensUsed = 0;
   let droppedForBudget = 0;
+  let droppedForDiversity = 0;
+  const familyCounts = /* @__PURE__ */ new Map();
   for (const hit of ranked) {
+    const familyKey = CHUNKED_KINDS.has(hit.kind) ? `${hit.kind}:${hit.ts}` : null;
+    if (familyKey && (familyCounts.get(familyKey) ?? 0) >= MAX_PER_FAMILY) {
+      droppedForDiversity += 1;
+      continue;
+    }
     const summary = summarize(hit, summaryChars, query);
     const tokens = approxTokens(hit.title) + approxTokens(summary) + NODE_OVERHEAD_TOKENS;
     if (tokensUsed + tokens > tokensBudget) {
@@ -1382,8 +1492,9 @@ function packContext(ranked, tokensBudget, opts = {}) {
       ...hit.project ? { project: hit.project } : {}
     });
     tokensUsed += tokens;
+    if (familyKey) familyCounts.set(familyKey, (familyCounts.get(familyKey) ?? 0) + 1);
   }
-  return { nodes, tokensUsed, tokensBudget, consideredNodes: ranked.length, droppedForBudget };
+  return { nodes, tokensUsed, tokensBudget, consideredNodes: ranked.length, droppedForBudget, droppedForDiversity };
 }
 function renderContextBlock(query, result) {
   if (result.nodes.length === 0) return `No remembered context matched "${query}".`;
@@ -1402,6 +1513,70 @@ function renderContextBlock(query, result) {
   return lines.join("\n");
 }
 
+// src/correlate/failure-fix.ts
+var DEFAULT_RETRY_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_DISCUSSION_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var RESOLVED_BY_RETRY = "resolved_by:retry";
+var RESOLVED_BY_DISCUSSION = "resolved_by:discussion";
+function normalizeCommand(command) {
+  return command.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function correlateFailures(store, projectId, opts = {}) {
+  const retryWindowMs = opts.retryWindowMs ?? DEFAULT_RETRY_WINDOW_MS;
+  const discussionWindowMs = opts.discussionWindowMs ?? DEFAULT_DISCUSSION_WINDOW_MS;
+  const db = store.raw;
+  const failures = db.prepare(
+    `SELECT id, ts_epoch, json_extract(meta, '$.command') AS command, json_extract(meta, '$.cwd') AS cwd
+       FROM nodes
+       WHERE project_id = ? AND kind = 'shell_command'
+         AND json_extract(meta, '$.exitCode') IS NOT NULL
+         AND json_extract(meta, '$.exitCode') != 0`
+  ).all(projectId);
+  const findRetry = db.prepare(
+    `SELECT id FROM nodes
+     WHERE project_id = ? AND kind = 'shell_command'
+       AND json_extract(meta, '$.exitCode') = 0
+       AND ts_epoch > ? AND ts_epoch <= ?
+       AND lower(trim(json_extract(meta, '$.command'))) = ?
+       AND (json_extract(meta, '$.cwd') IS ? OR json_extract(meta, '$.cwd') = ?)
+     ORDER BY ts_epoch ASC LIMIT 1`
+  );
+  const findDiscussion = db.prepare(
+    `SELECT n.id FROM nodes_fts
+     JOIN nodes n ON n.rowid = nodes_fts.rowid
+     WHERE nodes_fts MATCH ? AND n.project_id = ? AND n.kind IN ('conversation_turn', 'session_summary')
+       AND n.ts_epoch > ? AND n.ts_epoch <= ?
+     ORDER BY bm25(nodes_fts, 10.0, 1.0)
+     LIMIT 1`
+  );
+  let linkedByRetry = 0;
+  let linkedByDiscussion = 0;
+  for (const failure of failures) {
+    if (!failure.command) continue;
+    const retry = findRetry.get(
+      projectId,
+      failure.ts_epoch,
+      failure.ts_epoch + retryWindowMs,
+      normalizeCommand(failure.command),
+      failure.cwd,
+      failure.cwd
+    );
+    if (retry) {
+      store.linkNodes(failure.id, retry.id, RESOLVED_BY_RETRY);
+      linkedByRetry += 1;
+    }
+    const match = toStrictMatchQuery(failure.command);
+    if (match) {
+      const discussion = findDiscussion.get(match, projectId, failure.ts_epoch, failure.ts_epoch + discussionWindowMs);
+      if (discussion) {
+        store.linkNodes(failure.id, discussion.id, RESOLVED_BY_DISCUSSION);
+        linkedByDiscussion += 1;
+      }
+    }
+  }
+  return { failuresExamined: failures.length, linkedByRetry, linkedByDiscussion };
+}
+
 // src/retrieval/fuse.ts
 var RRF_K = 60;
 function reciprocalRankFusion(lists) {
@@ -1477,6 +1652,42 @@ function rankHits(hits, opts = {}) {
 }
 
 // src/retrieval/query-pipeline.ts
+var SURFACED_RELATIONS = [RESOLVED_BY_RETRY, RESOLVED_BY_DISCUSSION];
+function pullLinkedResolutions(resolveStore, ranked) {
+  const present = new Set(ranked.map((hit) => hit.id));
+  const withLinks = [];
+  for (const hit of ranked) {
+    withLinks.push(hit);
+    if (hit.kind !== "shell_command") continue;
+    const store = resolveStore(hit);
+    if (!store) continue;
+    for (const relation of SURFACED_RELATIONS) {
+      for (const linkedId of store.getLinkedNodeIds(hit.id, relation)) {
+        if (present.has(linkedId)) continue;
+        const [resolution] = store.getNodesByIds([linkedId]);
+        if (!resolution) continue;
+        present.add(linkedId);
+        withLinks.push({
+          id: resolution.id,
+          kind: resolution.kind,
+          ts: resolution.ts,
+          title: resolution.title,
+          body: resolution.body,
+          signal: resolution.signal,
+          rank: 0,
+          // no bm25/vector rank of its own -- never read again past this point
+          relevance: hit.relevance,
+          signalWeight: hit.signalWeight,
+          recencyFactor: hit.recencyFactor,
+          ageDays: hit.ageDays,
+          score: hit.score,
+          ...hit.project ? { project: hit.project } : {}
+        });
+      }
+    }
+  }
+  return withLinks;
+}
 async function runCrossProjectQuery(sources, query, opts) {
   const queryVector = opts.embeddingProvider ? await opts.embeddingProvider.embed(query) : null;
   const lists = [];
@@ -1497,8 +1708,12 @@ async function runCrossProjectQuery(sources, query, opts) {
     }
     hits.push(...mergeSearchAndVectorHits(bm25Hits, vectorHits).map(label));
   }
+  const storeByLabel = new Map(sources.map((source) => [source.label, source.store]));
   const relevanceScores = reciprocalRankFusion(lists);
-  const ranked = rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores });
+  const ranked = pullLinkedResolutions(
+    (hit) => hit.project ? storeByLabel.get(hit.project) : void 0,
+    rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores })
+  );
   const packed = packContext(ranked, opts.budget, { query });
   return { bm25Count, vectorCount, hits, packed, perProject };
 }
@@ -1511,7 +1726,10 @@ 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 ranked = pullLinkedResolutions(
+    () => store,
+    rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores })
+  );
   const packed = packContext(ranked, opts.budget, { query });
   return { bm25Count: bm25Hits.length, vectorCount: vectorHits.length, hits, packed };
 }
@@ -2425,6 +2643,7 @@ function sessionFallbackTitle(session) {
 }
 var MAX_TITLE_CHARS5 = 200;
 var GENERIC_TITLE = /^(a |the )?(session |conversation |project |work )?(summary|update|overview|recap|status)\b/i;
+var ROLE_PREAMBLE_TITLE = /^(role\s*[:：]|you\s*(?:'re|are)\s+(acting as|serving as|playing the role of|a\b)|i\s*(?:'m|am)\s+(acting as|a\b)|acting as\b|บทบาท\s*[:：]|ในฐานะ|คุณ(กำลัง)?(ทำหน้าที่เป็น|เป็น|รับบทบาทเป็น)|(ผม|ฉัน)(กำลัง)?(ทำหน้าที่เป็น|เป็น))/i;
 function cleanTitle(line) {
   return line.replace(/^[-*#>\s]+/, "").replace(/\*+/g, "").replace(/\s*:\s*$/, "").trim();
 }
@@ -2441,7 +2660,7 @@ function parseSummary(raw, fallbackTitle) {
   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,
+    title: candidate.length > 0 && !GENERIC_TITLE.test(candidate) && !ROLE_PREAMBLE_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
@@ -2921,6 +3140,100 @@ async function collectAvailableShellHistory(opts = {}) {
   return results;
 }
 
+// src/store/reconcile.ts
+function recomputeByNaturalKey(db, oldProjectId, newProjectId, kind, source, computeNaturalKey) {
+  const rows = source ? db.prepare("SELECT * FROM nodes WHERE project_id = ? AND kind = ? AND source = ?").all(oldProjectId, kind, source) : db.prepare("SELECT * FROM nodes WHERE project_id = ? AND kind = ?").all(oldProjectId, kind);
+  const nodeExists = db.prepare("SELECT 1 FROM nodes WHERE id = ?");
+  const insertNode = db.prepare(
+    `INSERT INTO nodes (id, kind, project_id, ts, ts_epoch, source, title, body, signal, meta, created_at)
+     VALUES (@id, @kind, @projectId, @ts, @tsEpoch, @source, @title, @body, @signal, @meta, @createdAt)`
+  );
+  const readFiles = db.prepare("SELECT path, previous_path, insertions, deletions, is_binary 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)`
+  );
+  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 = ?");
+  let migrated = 0;
+  let deduped = 0;
+  let skipped = 0;
+  for (const row of rows) {
+    let meta;
+    try {
+      meta = JSON.parse(row.meta);
+    } catch {
+      skipped += 1;
+      continue;
+    }
+    const naturalKey = computeNaturalKey(row, meta);
+    if (naturalKey === null) {
+      skipped += 1;
+      continue;
+    }
+    const newId = makeNodeId(newProjectId, kind, naturalKey);
+    if (nodeExists.get(newId)) {
+      deduped += 1;
+    } else {
+      insertNode.run({
+        id: newId,
+        kind: row.kind,
+        projectId: newProjectId,
+        ts: row.ts,
+        tsEpoch: row.ts_epoch,
+        source: row.source,
+        title: row.title,
+        body: row.body,
+        signal: row.signal,
+        meta: row.meta,
+        createdAt: row.created_at
+      });
+      for (const file of readFiles.all(row.id)) {
+        insertFile.run({
+          nodeId: newId,
+          path: file.path,
+          previousPath: file.previous_path,
+          insertions: file.insertions,
+          deletions: file.deletions,
+          isBinary: file.is_binary
+        });
+      }
+      migrated += 1;
+    }
+    dropEmbedding.run(row.id);
+    deleteNode.run(row.id);
+  }
+  return { migrated, deduped, skipped };
+}
+function reconcileProjectId(db, oldProjectId, newProjectId) {
+  return db.transaction(() => {
+    const sessions = recomputeByNaturalKey(
+      db,
+      oldProjectId,
+      newProjectId,
+      "session_summary",
+      null,
+      (_row, meta) => typeof meta.sessionKey === "string" ? meta.sessionKey : null
+    );
+    const hookShell = recomputeByNaturalKey(
+      db,
+      oldProjectId,
+      newProjectId,
+      "shell_command",
+      "shell:pwsh-hook",
+      (row, meta) => typeof meta.command === "string" ? `pwsh-hook:${row.ts}:${sha256Hex(meta.command).slice(0, 12)}` : null
+    );
+    const reassigned = db.prepare(`UPDATE nodes SET project_id = ? WHERE project_id = ? AND kind = 'conversation_turn'`).run(newProjectId, oldProjectId).changes;
+    return {
+      oldProjectId,
+      migrated: sessions.migrated + hookShell.migrated,
+      reassigned,
+      deduped: sessions.deduped + hookShell.deduped,
+      skipped: sessions.skipped + hookShell.skipped
+    };
+  })();
+}
+
 // src/vector/sync.ts
 var EMBEDDING_IDENTITY_KEY = "embedding.identity";
 var DEFAULT_BATCH_SIZE = 32;
@@ -3207,6 +3520,41 @@ async function syncDocs(store, projectId, repoRoot, config, log) {
   }
   return { totals, seen: nodes.length };
 }
+var STALE_SHELL_SOURCES = ["shell:pwsh", "shell:bash", "shell:zsh"];
+function collectPruneSources(opts) {
+  const sources = /* @__PURE__ */ new Set();
+  if (opts.pruneStaleShell) {
+    for (const source of STALE_SHELL_SOURCES) sources.add(source);
+  }
+  if (opts.pruneSource?.trim()) sources.add(opts.pruneSource.trim());
+  return [...sources];
+}
+function runPruneSources(store, projectId, otherProjectIds, sources, yes, out) {
+  const scopeIds = [projectId, ...otherProjectIds];
+  const counts = sources.flatMap((source) => scopeIds.map((id) => ({ source, id, count: store.countSourceNodes(id, source) })));
+  const total = counts.reduce((sum, c) => sum + c.count, 0);
+  if (total === 0) {
+    out(`${pc4.dim("prune-source")} no node(s) match ${sources.join(", ")} -- nothing to do
+`);
+    return 0;
+  }
+  const describe = (c) => `  ${pc4.dim(c.source)}${c.id !== projectId ? pc4.dim(` (prior identity ${c.id.slice(0, 8)})`) : ""}: ${c.count} node(s)`;
+  if (!yes) {
+    const lines = counts.filter((c) => c.count > 0).map(describe);
+    out(
+      [`${pc4.yellow("would remove")} ${total} node(s):`, ...lines, pc4.dim("re-run with --yes to actually delete these -- this cannot be undone"), ""].join(
+        "\n"
+      )
+    );
+    return 0;
+  }
+  let removed = 0;
+  for (const { source, id } of counts) removed += store.pruneSourceNodes(id, source, []);
+  const identityPart = otherProjectIds.length > 0 ? `, ${scopeIds.length} project identit${scopeIds.length === 1 ? "y" : "ies"}` : "";
+  out(`${pc4.green("pruned")} ${removed} node(s) across ${sources.length} source(s)${identityPart}
+`);
+  return 0;
+}
 async function runSync(opts) {
   const { repo, ws, projectId, config } = await loadContext(opts.cwd);
   const log = (line) => {
@@ -3218,11 +3566,37 @@ async function runSync(opts) {
   const started = Date.now();
   try {
     store.upsertProject({ id: projectId, root: repo.root, originUrl: repo.originUrl });
-    await recordProject({ projectId, root: repo.root, dbPath: ws.dbPath, originUrl: repo.originUrl });
     if (opts.rebuild) {
       const removed = store.clearProject(projectId);
       log(`${pc4.dim("rebuild")} dropped ${removed} existing node(s)`);
     }
+    const staleProjectIds = store.listOtherProjectIds(projectId);
+    for (const staleId of staleProjectIds) {
+      const result = reconcileProjectId(store.raw, staleId, projectId);
+      const parts = [
+        result.migrated > 0 ? `${result.migrated} migrated` : null,
+        result.reassigned > 0 ? `${result.reassigned} reassigned` : null,
+        result.deduped > 0 ? `${result.deduped} already up to date` : null,
+        result.skipped > 0 ? `${result.skipped} left behind (not reconstructable)` : null
+      ].filter((part) => part !== null);
+      if (parts.length > 0) {
+        log(
+          `${pc4.yellow("reconciled")} previous project identity ${pc4.dim(staleId)} (remote URL likely changed): ${parts.join(", ")}`
+        );
+      }
+    }
+    if (staleProjectIds.length > 0) {
+      if (opts.rebuild) {
+        for (const staleId of staleProjectIds) store.clearProject(staleId);
+      }
+      await forgetProjects(staleProjectIds);
+      if (config.projectId !== projectId) await writeConfig(ws, { ...config, projectId });
+    }
+    await recordProject({ projectId, root: repo.root, dbPath: ws.dbPath, originUrl: repo.originUrl });
+    const pruneSources = collectPruneSources(opts);
+    if (pruneSources.length > 0) {
+      return runPruneSources(store, projectId, staleProjectIds, pruneSources, opts.yes ?? false, out);
+    }
     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);
@@ -3252,6 +3626,12 @@ async function runSync(opts) {
         log(`${pc4.dim("vector")} embedding provider unavailable (is Ollama running with nomic-embed-text pulled?) -- BM25-only for now`);
       }
     }
+    let linkLine = "";
+    if (opts.linkFailures) {
+      const linkStats = correlateFailures(store, projectId);
+      linkLine = `  ${pc4.dim(`chains: ${linkStats.failuresExamined} failure(s) examined, ${linkStats.linkedByRetry} linked by retry, ${linkStats.linkedByDiscussion} by discussion`)}
+`;
+    }
     store.markSynced(projectId);
     const totals = { inserted: 0, updated: 0, unchanged: 0 };
     addStats(totals, git2.totals);
@@ -3272,7 +3652,7 @@ async function runSync(opts) {
         `  ${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
+      ].join("\n") + embedLine + linkLine
     );
     return 0;
   } finally {
@@ -3337,10 +3717,27 @@ async function syncProject(input) {
     rebuild: false,
     quiet: true,
     noEmbed: input.noEmbed,
+    pruneSource: input.pruneSource,
+    pruneStaleShell: input.pruneStaleShell,
+    yes: input.yes,
     out
   };
   await runSync(opts);
-  return { summary: chunks.join("").trim() };
+  return { summary: stripAnsi(chunks.join("").trim()) };
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+async function listRecentMemory(input) {
+  const repo = await readRepoInfo(input.projectRoot);
+  const ws = resolveWorkspace(repo.root);
+  const projectId = makeProjectId({ root: repo.root, originUrl: repo.originUrl });
+  const store = MemoryStore.open(ws.dbPath);
+  try {
+    return { items: store.listRecentNodes(projectId, input.limit) };
+  } finally {
+    store.close();
+  }
 }
 async function getStatus(input) {
   const repo = await readRepoInfo(input.projectRoot);
@@ -3392,13 +3789,16 @@ function createServer() {
     "sync_project",
     {
       title: "Sync remembered history",
-      description: "Ingest new git, diff, 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. Pass pruneSource or pruneStaleShell instead to delete a dead source's nodes (e.g. the pre-hook shell scrape) rather than syncing -- dry-run unless yes is also true, since this is an irreversible full wipe of that source.",
       inputSchema: {
-        projectRoot: z3.string().describe("Absolute path to the repository root")
+        projectRoot: z3.string().describe("Absolute path to the repository root"),
+        pruneSource: z3.string().optional().describe('Delete every node from this exact source (e.g. "shell:pwsh") instead of syncing'),
+        pruneStaleShell: z3.boolean().optional().describe("Shortcut for pruneSource on shell:pwsh, shell:bash and shell:zsh at once -- the dead pre-hook scrape sources"),
+        yes: z3.boolean().optional().describe("Confirms the delete. Without it, pruneSource/pruneStaleShell only report the matching count.")
       }
     },
-    async ({ projectRoot }) => {
-      const result = await syncProject({ projectRoot });
+    async ({ projectRoot, pruneSource, pruneStaleShell, yes }) => {
+      const result = await syncProject({ projectRoot, pruneSource, pruneStaleShell, yes });
       return { content: [{ type: "text", text: result.summary }] };
     }
   );
@@ -3419,6 +3819,24 @@ function createServer() {
       };
     }
   );
+  server.registerTool(
+    "list_recent_memory",
+    {
+      title: "List recently remembered items",
+      description: "List the most recently remembered items for a NexusMem-tracked repository -- git commits, code diffs, shell commands, tracked docs, and (if enabled) conversation transcripts and session summaries -- newest first. Chronological, not relevance-ranked: use search_memory instead for a specific question.",
+      inputSchema: {
+        projectRoot: z3.string().describe("Absolute path to the repository root"),
+        limit: z3.number().int().positive().optional().describe("Max items to return, newest first. Default 20.")
+      }
+    },
+    async ({ projectRoot, limit }) => {
+      const result = await listRecentMemory({ projectRoot, limit });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result.items, null, 2) }],
+        structuredContent: { items: result.items }
+      };
+    }
+  );
   return server;
 }
 async function runMcpServer() {
@@ -3477,7 +3895,8 @@ async function runQuery(opts) {
             packed: packed.nodes,
             tokensUsed: packed.tokensUsed,
             tokensBudget: packed.tokensBudget,
-            droppedForBudget: packed.droppedForBudget
+            droppedForBudget: packed.droppedForBudget,
+            droppedForDiversity: packed.droppedForDiversity
           },
           null,
           2
@@ -3494,7 +3913,7 @@ async function runQuery(opts) {
     process.stderr.write(
       [
         `${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)`) : ""),
+        `${pc5.dim("tokens ")} ${packed.tokensUsed}/${packed.tokensBudget}` + (packed.droppedForBudget ? pc5.dim(`  (${packed.droppedForBudget} dropped for budget)`) : "") + (packed.droppedForDiversity ? pc5.dim(`  (${packed.droppedForDiversity} dropped for diversity)`) : ""),
         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")
@@ -3938,6 +4357,14 @@ program.command("sync").description("Ingest new history into the local database"
   "--embed-limit <count>",
   "stop embedding after this many nodes (default: embed everything pending)",
   (v) => Number.parseInt(v, 10)
+).option("--prune-source <name>", "delete every node from this exact source (e.g. shell:pwsh) instead of syncing -- dry-run unless --yes is also given").option(
+  "--prune-stale-shell",
+  "shortcut for --prune-source on shell:pwsh, shell:bash and shell:zsh at once -- the dead pre-hook scrape sources -- dry-run unless --yes is also given",
+  false
+).option("--yes", "confirm an irreversible --prune-source/--prune-stale-shell delete", false).option(
+  "--link-failures",
+  "opt-in (experimental): after ingest, link failed shell commands to whatever later resolved them",
+  false
 ).option("-q, --quiet", "only print the final summary", false).action(
   (options) => guard(
     () => runSync({
@@ -3949,6 +4376,10 @@ program.command("sync").description("Ingest new history into the local database"
       conversationOverride: options.conversation ? true : void 0,
       noEmbed: !options.embed,
       embedLimit: options.embedLimit,
+      pruneSource: options.pruneSource,
+      pruneStaleShell: options.pruneStaleShell,
+      yes: options.yes,
+      linkFailures: options.linkFailures,
       quiet: options.quiet
     })
   )()