nexusmem 0.10.0 → 0.10.2

package/CHANGELOG.md

@@ -11,6 +11,41 @@ built from, matched by publish timestamp: `v0.1.0` → `67a4776`, `v0.1.1` → `
 
 No unreleased changes yet.
 
+## [0.10.2] — 2026-08-30
+
+### Security
+
+- `shell_command` nodes never ran through the same secret-redaction pass `conversation_turn` and
+  `code_diff` nodes already get: a command like `export API_KEY=...` landed verbatim in `title`/`body`,
+  which is exactly what the FTS index and vector embeddings are built from — a secret typed at a
+  prompt could resurface later through `search_memory`/`nexusmem query`. Fixed by running `redact()`
+  over the command before it reaches those fields. `meta.command` is kept raw on purpose: project-id
+  reconciliation and failure/fix correlation both hash or exact-match against the real command text,
+  and redacting that copy too would have silently orphaned nodes on a project-id migration.
+
+## [0.10.1] — 2026-08-30
+
+### Added
+
+- `nodes.retrieved_count`/`nodes.last_retrieved_at` (schema V12): retrieval outcomes are now recorded
+  instead of silently discarded. Bumped once per completed `nexusmem query`/MCP `search_memory` call,
+  for every node actually packed into the returned context (both CLI and MCP share one pipeline, so
+  both are covered from a single call site). Not yet folded into `rank.ts`'s score formula — every
+  existing ranking factor was tuned against real dogfooded queries and validated with `npm run eval`
+  before being trusted, and a new factor needs the same treatment. This release is the instrumentation
+  half only; confirmed eval-neutral (MRR 0.943 / Recall@5 0.964, unchanged).
+
+### Fixed
+
+- `nexusmem precheck`'s "What already failed here" warning implied the failure was located in the
+  flagged file, but the match is against basename word-tokens (`tokensForFile`) — a failing `npm run
+  precheck` flagged every file whose name contained that word, not just the one actually responsible.
+  Reworded to state what's actually true ("commands naming this file failed").
+- The high-churn warning in `nexusmem precheck` was rendered as a `WARN`, the same severity as the
+  dogfooded failure-correlation warning, despite `HIGH_CHURN_THRESHOLD` being an admitted, untuned
+  guess. Demoted to a lower-severity `note`, explicitly labeled as an untuned heuristic, so it no
+  longer reads as equally trustworthy.
+
 ## [0.10.0] — 2026-08-29
 
 ### Added
@@ -575,7 +610,8 @@ 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.10.0...HEAD
+[Unreleased]: https://github.com/yaminbkk/NexusMem/compare/v0.10.1...HEAD
+[0.10.1]: https://github.com/yaminbkk/NexusMem/compare/v0.10.0...v0.10.1
 [0.10.0]: https://github.com/yaminbkk/NexusMem/compare/v0.9.1...v0.10.0
 [0.9.1]: https://github.com/yaminbkk/NexusMem/compare/v0.9.0...v0.9.1
 [0.9.0]: https://github.com/yaminbkk/NexusMem/compare/v0.8.0...v0.9.0

package/README.md

@@ -6,7 +6,7 @@
 [![License: MIT](https://img.shields.io/badge/license-MIT-informational)](LICENSE)
 ![Node](https://img.shields.io/badge/node-%3E%3D22-brightgreen)
 
-![NexusMem: init, sync, status, and a query against this repo's own history](docs/demo.gif)
+![NexusMem: init, sync --github, and a query against this repo's own history — surfacing a real issue, the PR that closed it, and the commits it shipped](docs/demo.gif)
 
 Your coding agent can read `git log`. It cannot read the four things you tried last Tuesday that
 didn't work.

package/dist/cli/index.js

@@ -1033,6 +1033,10 @@ INSERT INTO nodes_vec (rowid, project_id, embedding)
 
 DROP TABLE nodes_vec_stage;
 `;
+var V12 = `
+ALTER TABLE nodes ADD COLUMN retrieved_count INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE nodes ADD COLUMN last_retrieved_at INTEGER;
+`;
 var MIGRATIONS = [
   { version: 1, up: (db) => db.exec(V1) },
   { version: 2, up: (db) => db.exec(V2) },
@@ -1044,7 +1048,8 @@ var MIGRATIONS = [
   { version: 8, up: (db) => db.exec(V8) },
   { version: 9, up: (db) => db.exec(V9) },
   { version: 10, up: (db) => db.exec(V10) },
-  { version: 11, up: (db) => db.exec(V11) }
+  { version: 11, up: (db) => db.exec(V11) },
+  { version: 12, up: (db) => db.exec(V12) }
 ];
 var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
 function currentSchemaVersion(db) {
@@ -1316,6 +1321,19 @@ function listStaleCandidates(db, projectId, opts = {}) {
     ageDays: Math.round((now.getTime() - r.tsEpoch) / 864e5)
   }));
 }
+function recordRetrievals(db, ids) {
+  if (ids.length === 0) return;
+  db.prepare(
+    `UPDATE nodes SET retrieved_count = retrieved_count + 1, last_retrieved_at = @now
+     WHERE id IN (SELECT value FROM json_each(@ids))`
+  ).run({ now: Date.now(), ids: JSON.stringify(ids) });
+}
+function getRetrievalStats(db, id) {
+  const row = db.prepare("SELECT retrieved_count AS retrievedCount, last_retrieved_at AS lastRetrievedAt FROM nodes WHERE id = ?").get(
+    id
+  );
+  return row ?? null;
+}
 function countStaleCandidates(db, projectId, opts = {}) {
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const minAgeDays = opts.minAgeDays ?? 45;
@@ -1845,6 +1863,14 @@ var MemoryStore = class _MemoryStore {
   countStaleCandidates(projectId, opts = {}) {
     return countStaleCandidates(this.db, projectId, opts);
   }
+  /** Bump retrieval bookkeeping for nodes actually packed into a query result. See `nodes.ts`'s `recordRetrievals` for why this doesn't touch ranking. */
+  recordRetrievals(ids) {
+    recordRetrievals(this.db, ids);
+  }
+  /** Retrieval bookkeeping for one node, or null if it doesn't exist. Mainly for tests. */
+  getRetrievalStats(id) {
+    return getRetrievalStats(this.db, id);
+  }
   /** Memoize one SLM contradiction judgment (either verdict). Suggest-only: never writes `supersedes`. */
   recordContradictionCheck(input) {
     recordContradictionCheck(this.db, input);
@@ -2812,8 +2838,21 @@ async function runCrossProjectQuery(sources, query, opts) {
     rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores, supersededIds })
   );
   const packed = packContext(ranked, opts.budget, { query });
+  recordRetrievalsByProject(storeByLabel, packed.nodes);
   return { bm25Count, vectorCount, hits, packed, perProject };
 }
+function recordRetrievalsByProject(storeByLabel, nodes) {
+  const idsByLabel = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    if (!node.project) continue;
+    const ids = idsByLabel.get(node.project) ?? [];
+    ids.push(node.id);
+    idsByLabel.set(node.project, ids);
+  }
+  for (const [label, ids] of idsByLabel) {
+    storeByLabel.get(label)?.recordRetrievals(ids);
+  }
+}
 async function runHybridQuery(store, projectId, query, opts) {
   const bm25Hits = store.search(projectId, query, opts.candidates, { asOfEpoch: opts.asOfEpoch });
   let vectorHits = [];
@@ -2829,6 +2868,7 @@ async function runHybridQuery(store, projectId, query, opts) {
     rankHits(hits, { halfLifeDays: opts.halfLifeDays, relevanceScores, supersededIds })
   );
   const packed = packContext(ranked, opts.budget, { query });
+  store.recordRetrievals(packed.nodes.map((n) => n.id));
   return { bm25Count: bm25Hits.length, vectorCount: vectorHits.length, hits, packed };
 }
 
@@ -3949,8 +3989,8 @@ function scoreShellCommand(entry) {
   else if (cmd.length <= 3) score -= 0.05;
   return Number(Math.min(1, Math.max(0.05, score)).toFixed(3));
 }
-function renderBody2(entry, maxChars) {
-  const parts = [`$ ${entry.command}`];
+function renderBody2(entry, command, maxChars) {
+  const parts = [`$ ${command}`];
   const metaLine = [];
   if (entry.cwd) metaLine.push(`cwd: ${entry.cwd}`);
   if (entry.exitCode !== null) metaLine.push(`exit: ${entry.exitCode}`);
@@ -3960,7 +4000,8 @@ function renderBody2(entry, maxChars) {
 }
 function toMemoryNode3(entry, projectId, opts = {}) {
   const maxBody = opts.maxBodyChars ?? DEFAULT_MAX_BODY_CHARS5;
-  const titleLine = entry.command.split(/\r?\n/)[0] ?? entry.command;
+  const { text: redactedCommand } = redact(entry.command);
+  const titleLine = redactedCommand.split(/\r?\n/)[0] ?? redactedCommand;
   return {
     id: makeNodeId(projectId, "shell_command", entry.naturalKey),
     kind: "shell_command",
@@ -3968,7 +4009,7 @@ function toMemoryNode3(entry, projectId, opts = {}) {
     ts: entry.ts,
     source: `shell:${entry.shell}`,
     title: truncate(titleLine, MAX_TITLE_CHARS7),
-    body: renderBody2(entry, maxBody),
+    body: renderBody2(entry, redactedCommand, maxBody),
     files: [],
     signal: scoreShellCommand(entry),
     provenance: "observed",
@@ -5695,6 +5736,44 @@ async function getStatus(input) {
     store.close();
   }
 }
+async function listStaleSuggestions(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 { suggestions: store.listContradictionSuggestions(projectId, { limit: input.limit }) };
+  } finally {
+    store.close();
+  }
+}
+async function resolveStaleSuggestion(input) {
+  if (input.action === "dismiss") {
+    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 {
+      const dismissed = store.dismissContradictionSuggestion(projectId, input.candidateId);
+      return {
+        summary: dismissed > 0 ? `dismissed the contradiction suggestion for ${input.candidateId}` : `no open contradiction suggestion for ${input.candidateId}`
+      };
+    } finally {
+      store.close();
+    }
+  }
+  if (!input.againstId) {
+    throw new Error("againstId is required to accept a stale suggestion");
+  }
+  const chunks = [];
+  await runMarkStale({
+    cwd: input.projectRoot,
+    nodeId: input.candidateId,
+    supersedesId: input.againstId,
+    out: (chunk2) => chunks.push(chunk2)
+  });
+  return { summary: stripAnsi(chunks.join("").trim()) };
+}
 
 // src/mcp/server.ts
 function createServer() {
@@ -5784,6 +5863,41 @@ function createServer() {
       };
     }
   );
+  server.registerTool(
+    "list_stale_suggestions",
+    {
+      title: "List open contradiction suggestions",
+      description: 'List open contradiction verdicts for a NexusMem-tracked repository -- candidates flagged by "nexusmem stale --check-contradictions" (or automatically during sync) as likely superseded by a newer, similar node. Nothing has been written yet; use resolve_stale_suggestion to act on one.',
+      inputSchema: {
+        projectRoot: z4.string().describe("Absolute path to the repository root"),
+        limit: z4.number().int().positive().optional().describe("Max suggestions to return, most recently judged first. Default 50.")
+      }
+    },
+    async ({ projectRoot, limit }) => {
+      const result = await listStaleSuggestions({ projectRoot, limit });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result.suggestions, null, 2) }],
+        structuredContent: { suggestions: result.suggestions }
+      };
+    }
+  );
+  server.registerTool(
+    "resolve_stale_suggestion",
+    {
+      title: "Accept or dismiss a contradiction suggestion",
+      description: '"accept" writes a supersede link from candidateId to againstId (the same effect as "nexusmem mark-stale") -- the ranker down-weights candidateId from then on but never deletes it. "dismiss" silences the suggestion without changing ranking, so it stops resurfacing on future stale/sync runs.',
+      inputSchema: {
+        projectRoot: z4.string().describe("Absolute path to the repository root"),
+        candidateId: z4.string().describe("Id of the stale/superseded node"),
+        action: z4.enum(["accept", "dismiss"]).describe("Whether to write the supersede link or silence the suggestion"),
+        againstId: z4.string().optional().describe('Id of the superseding node. Required for "accept", ignored for "dismiss".')
+      }
+    },
+    async ({ projectRoot, candidateId, action, againstId }) => {
+      const result = await resolveStaleSuggestion({ projectRoot, candidateId, action, againstId });
+      return { content: [{ type: "text", text: result.summary }] };
+    }
+  );
   return server;
 }
 async function runMcpServer() {
@@ -5876,7 +5990,7 @@ ${pc8.dim("-".repeat(40))}
     out(`  ${pc8.bold(risk.path)}
 `);
     if (risk.unresolvedFailures.length > 0) {
-      out(`    ${pc8.yellow("WARN")}  What already failed here (${risk.unresolvedFailures.length} unresolved):
+      out(`    ${pc8.yellow("WARN")}  commands naming this file failed, still unresolved (${risk.unresolvedFailures.length}):
 `);
       for (const f of risk.unresolvedFailures.slice(0, 3)) {
         out(`           ${pc8.dim(`${f.ts.slice(0, 10)}  ${f.command.slice(0, 90)}`)}
@@ -5888,7 +6002,7 @@ ${pc8.dim("-".repeat(40))}
       }
     }
     if (risk.commitsRecent >= HIGH_CHURN_THRESHOLD) {
-      out(`    ${pc8.yellow("WARN")}  high churn: ${risk.commitsRecent} commits touched this file recently
+      out(`    ${pc8.dim("note")}  high churn (untuned heuristic): ${risk.commitsRecent} commits touched this file recently
 `);
     }
     out("\n");