nexusmem 0.3.1 → 0.3.3

package/CHANGELOG.md

@@ -9,6 +9,72 @@ built from, matched by publish timestamp: `v0.1.0` → `67a4776`, `v0.1.1` → `
 
 ## [Unreleased]
 
+## [0.3.3] — 2026-08-16
+
+### Added
+
+- **`nexusmem status` now shows failure→fix chain counts** — `N/M failure(s) resolved (X retry, Y
+  discussion)`, plus a hint to run `sync --link-failures` when failures remain unresolved. The
+  chain feature is this project's most distinctive capability, but was previously invisible to
+  anyone who didn't already know to query `node_links` directly. Backed by the new
+  `getChainStats` in `src/correlate/failure-fix.ts`, which dedupes failures resolved by both
+  heuristics rather than double-counting them.
+
+### Fixed
+
+- **Discussion-bridge heuristic (`sync --link-failures`): corpus-relative boilerplate tokens no
+  longer produce false-positive failure→fix links.** Re-dogfooded at larger scale against a second
+  real project's history: a command made entirely of words that saturate a project's own corpus
+  (e.g. this repo's own name/verbs) could AND-match an unrelated turn that just happened to mention
+  the same words, and bm25 score alone could not separate that from a true positive (measured: the
+  false positive scored *stronger* than two real true positives). `filterBoilerplateTokens` in
+  `src/correlate/failure-fix.ts` drops any token that appears in over 20% of a project's own
+  `conversation_turn`/`session_summary` history before building the match query — measured against
+  real data, not guessed — and skips the discussion-match attempt entirely (rather than falling back
+  unfiltered) when every token turns out to be boilerplate, since a missed link is preferred over a
+  false one for this heuristic. Below 10 discussable nodes the filter is skipped, since frequency
+  isn't a meaningful signal yet on a young project.
+
+## [0.3.2] — 2026-08-16
+
+### Added
+
+- **`mcpName` field in `package.json`**, required by the official MCP registry
+  (registry.modelcontextprotocol.io) to verify that whoever publishes `server.json` under
+  `io.github.yaminbkk/nexusmem` also controls the `nexusmem` npm package itself — the registry
+  rejects a publish attempt otherwise. No behavior change for CLI/MCP users; this is purely a
+  registry-ownership proof.
+- **`list_recent_memory` MCP tool** — chronological listing of a repository's most recently
+  remembered nodes (git commits, diffs, shell commands, docs, conversation, session summaries),
+  newest first. Distinct from `search_memory`: no query, just "what has this project's memory
+  recorded lately" — built for the VS Code extension's sidebar view, which lists rather than
+  searches. Backed by `MemoryStore.listRecentNodes`, reusing the existing `idx_nodes_project_ts`
+  index.
+- **`sync --prune-source <name>` and `sync --prune-stale-shell`** — drop one source's nodes without a
+  full `--rebuild`, which loses history that can't be re-read from disk (the shell tail window, older
+  conversation turns). `--prune-stale-shell` is a shortcut for the three dead pre-hook shell-scrape
+  sources (`shell:pwsh`, `shell:bash`, `shell:zsh`) at once. Dry-run by default — prints the matching
+  count and does nothing until `--yes` is also given, since this is an irreversible full wipe of the
+  named source(s), unlike `--rebuild`'s no-prompt full-project reset. Also sweeps any prior project
+  identity of this same repo (the id a renamed git remote leaves behind after
+  `fix(store): reconcile memory stranded by a changed git remote URL` migrates what it can) — a
+  live-id-only prune could not reach nodes reconciliation deliberately left in place. Exposed on both
+  the CLI and the MCP `sync_project` tool.
+- **Discussion-heuristic failure→fix chains now surface**, tightened to an AND-joined significant-
+  token match instead of the original OR match. Re-verified against this repo's own real database:
+  5/5 discussion links correct (was ~half wrong when it shipped unsurfaced in 0.3.0). Chains now
+  follow across projects in `query --all-projects` too.
+
+### Fixed
+
+- **`sync_project`'s summary no longer contains raw ANSI color codes on Windows.** `runInit`/`runSync`
+  format their output with picocolors for terminal display, and picocolors treats `platform ===
+  'win32'` as sufficient evidence of color support on its own, without checking `isTTY` — correct for
+  a real terminal, wrong for the MCP JSON-RPC channel, which is piped on every platform. Found live: a
+  real MCP client (the VS Code extension's Output channel) rendered the raw escape codes as literal
+  text instead of color. Stripped at the MCP boundary in `syncProject`, leaving the CLI's own terminal
+  output untouched.
+
 ## [0.3.1] — 2026-08-15
 
 ### Added
@@ -210,7 +276,10 @@ First public release.
   there is no local-model summarization pass, and the conversation collector has never been audited
   for the stale-node bug that was found and fixed in the docs collector.
 
-[Unreleased]: https://github.com/yaminbkk/NexusMem/compare/v0.3.0...HEAD
+[Unreleased]: https://github.com/yaminbkk/NexusMem/compare/v0.3.3...HEAD
+[0.3.3]: https://github.com/yaminbkk/NexusMem/compare/v0.3.2...v0.3.3
+[0.3.2]: https://github.com/yaminbkk/NexusMem/compare/v0.3.1...v0.3.2
+[0.3.1]: https://github.com/yaminbkk/NexusMem/compare/v0.3.0...v0.3.1
 [0.3.0]: https://github.com/yaminbkk/NexusMem/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/yaminbkk/NexusMem/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/yaminbkk/NexusMem/compare/v0.1.1...v0.1.2

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 NexusMem Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 NexusMem Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -87,6 +87,40 @@ It wraps your existing PowerShell prompt rather than replacing it, is idempotent
 Exit codes are what make this worth installing. A failed command is a stronger signal than a
 successful one, and without the hook there is no way to tell them apart.
 
+## Failure → fix chains (opt-in)
+
+```bash
+nexusmem sync --link-failures
+```
+
+After a normal sync, this walks every failed `shell_command` (non-zero exit code) and looks for
+whatever later resolved it, using two independent heuristics: a later command in the same project
+and working directory, exact same normalized text, that exited `0` within 24h (**same-command
+retry**); and, separately, the best full-text match among nearby conversation turns or session
+summaries, requiring every significant word of the failing command to appear, not just one
+(**conversation bridge**). A failure can be linked by either, both, or neither.
+
+Both links are surfaced in query results. The conversation-bridge heuristic originally matched on
+any shared word, and dogfooding against this repo's own real history found it wrong on roughly half
+its links — a shared word as generic as "npm" was enough to link an unrelated discussion. Requiring
+every significant word fixed that: re-dogfooded against the same corpus, every resulting link (the
+full set produced, not a sample) checked out correct on manual review of the full text, not just the
+summary.
+
+When a linked failure appears in a result set, its fix rides along immediately after it, inheriting
+the failure's own relevance score rather than needing to match the query on its own merits. That is
+the point: a query about why something failed shouldn't need to separately guess the words used in
+whatever fixed it. This works across projects too — `query --all-projects` chains a failure to its
+fix using whichever project's own database recorded the link, since links are always local to the
+project they were found in.
+
+```
+$ nexusmem query "why did npm whoami fail"
+
+- 2026-08-12 shell: npm whoami  (exit 1)
+- 2026-08-12 shell: npm login   (exit 0)  -- linked as the fix
+```
+
 ## How retrieval works
 
 Every source normalizes to the same `MemoryNode` shape, so a commit, a shell command and a docs
@@ -293,8 +327,9 @@ is the intended way to tune scoring against a real repository before committing
 `--json` to pipe them somewhere.
 
 Every command takes `-C <path>` to target another repository. On `sync`, `--conversation` opts the
-transcript source in for one run without persisting it, `--no-embed` skips the vector pass, and
-`--rebuild` drops the project's nodes and re-ingests from scratch.
+transcript source in for one run without persisting it, `--no-embed` skips the vector pass,
+`--link-failures` builds the failure → fix chains described above, and `--rebuild` drops the
+project's nodes and re-ingests from scratch.
 
 ## Recall across projects
 

package/dist/cli/index.js

@@ -699,11 +699,15 @@ import * as sqliteVec from "sqlite-vec";
 // src/store/fts.ts
 var FTS_SYNTAX = /["'()*:^{}[\]-]/g;
 var LOW_SIGNAL_TOKENS = /* @__PURE__ */ new Set(["id"]);
-function toMatchQuery(input) {
+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;
+  if (tokens.length === 0) return [];
   const signal = tokens.filter((t) => !LOW_SIGNAL_TOKENS.has(t.toLowerCase()));
-  const kept = signal.length > 0 ? signal : tokens;
+  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 ");
 }
 
@@ -798,9 +802,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) {
@@ -972,6 +995,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.
    *
@@ -1429,6 +1508,105 @@ 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();
+}
+var MAX_TOKEN_DOC_FREQUENCY = 0.2;
+var MIN_CORPUS_FOR_FREQUENCY_FILTER = 10;
+function filterBoilerplateTokens(db, projectId, tokens) {
+  if (tokens.length === 0) return tokens;
+  const total = db.prepare(`SELECT COUNT(*) AS c FROM nodes WHERE project_id = ? AND kind IN ('conversation_turn', 'session_summary')`).get(projectId).c;
+  if (total < MIN_CORPUS_FOR_FREQUENCY_FILTER) return tokens;
+  const countMatching = db.prepare(
+    `SELECT COUNT(*) AS c 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')`
+  );
+  return tokens.filter((t) => {
+    const matching = countMatching.get(`"${t}"*`, projectId).c;
+    return matching / total <= MAX_TOKEN_DOC_FREQUENCY;
+  });
+}
+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 tokens = filterBoilerplateTokens(db, projectId, significantTokens(failure.command));
+    const match = tokens.length > 0 ? tokens.map((t) => `"${t}"*`).join(" AND ") : null;
+    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 };
+}
+function getChainStats(store, projectId) {
+  const db = store.raw;
+  const failuresTotal = db.prepare(
+    `SELECT COUNT(*) AS c FROM nodes
+         WHERE project_id = ? AND kind = 'shell_command'
+           AND json_extract(meta, '$.exitCode') IS NOT NULL AND json_extract(meta, '$.exitCode') != 0`
+  ).get(projectId).c;
+  const countDistinctLinked = (relations) => db.prepare(
+    `SELECT COUNT(DISTINCT nl.from_node_id) AS c
+           FROM node_links nl JOIN nodes n ON n.id = nl.from_node_id
+           WHERE n.project_id = ? AND nl.relation IN (${relations.map(() => "?").join(", ")})`
+  ).get(projectId, ...relations).c;
+  return {
+    failuresTotal,
+    resolvedByRetry: countDistinctLinked([RESOLVED_BY_RETRY]),
+    resolvedByDiscussion: countDistinctLinked([RESOLVED_BY_DISCUSSION]),
+    resolvedTotal: countDistinctLinked([RESOLVED_BY_RETRY, RESOLVED_BY_DISCUSSION])
+  };
+}
+
 // src/retrieval/fuse.ts
 var RRF_K = 60;
 function reciprocalRankFusion(lists) {
@@ -1504,6 +1682,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 = [];
@@ -1524,8 +1738,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 };
 }
@@ -1538,7 +1756,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 };
 }
@@ -3329,6 +3550,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) => {
@@ -3367,6 +3623,10 @@ async function runSync(opts) {
       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);
@@ -3396,6 +3656,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);
@@ -3416,7 +3682,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 {
@@ -3481,10 +3747,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);
@@ -3536,13 +3819,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 }] };
     }
   );
@@ -3563,6 +3849,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() {
@@ -4019,6 +4323,7 @@ async function runStatus(opts) {
     const sources = store.listSyncState(projectId);
     const gitCursor = sources.find((s) => s.source === "git")?.cursor ?? null;
     const schema = currentSchemaVersion(store.raw);
+    const chains = getChainStats(store, 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}`);
     process.stdout.write(
@@ -4040,7 +4345,8 @@ async function runStatus(opts) {
           return `    ${s.source.padEnd(14)} ${pc13.dim(`last run ${when}`)}  ${pc13.dim(`cursor ${cursorLabel}`)}`;
         }),
         gitCursor && gitCursor !== repo.head ? `${pc13.yellow("git behind HEAD")} \u2014 run ${pc13.bold("nexusmem sync")}` : "",
-        ""
+        "",
+        chains.failuresTotal ? `${pc13.dim("chains  ")} ${pc13.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc13.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc13.bold("nexusmem sync --link-failures")} to link more` : ""}` : ""
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
     return 0;
@@ -4083,6 +4389,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({
@@ -4094,6 +4408,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
     })
   )()