nexusmem 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -11,6 +11,29 @@ built from, matched by publish timestamp: `v0.1.0` → `67a4776`, `v0.1.1` → `
 
 No unreleased changes yet.
 
+## [0.8.0] — 2026-08-22
+
+### Added
+
+- Provenance widened from 2 tiers to a 4-tier trust hierarchy: `observed` (commits, diffs, shell
+  exit codes) > `authored` (doc sections — human-written claims) > `recorded` (conversation turns —
+  verbatim discourse) > `derived` (session summaries — a model's distillation). Schema V7 backfills
+  existing databases by kind. The ranker decays each tier at its own rate (lower trust fades
+  faster); the ordering is the design claim, the exact ratios are documented judgment calls.
+- Contradiction checking now runs automatically during `sync`: at most 3 new SLM judgments per run
+  (`contradictions.maxPerSync`; `contradictions.autoCheck: false` turns it off), gated on the
+  embedding provider already being reachable. Every judgment — either verdict — is memoized in a new
+  `contradiction_checks` table (schema V8), so a judged pair is never sent to the model again and
+  repeat syncs converge to zero model calls. Measured live against this repo's own database: 5.4s
+  for the first 10 judgments, 0.5s for the identical re-run. Still suggest-only: nothing ever writes
+  `supersedes` automatically.
+- Standing suggestions now surface everywhere without a model in the loop: plain `nexusmem stale`
+  decorates flagged candidates from the memoized judgments (instant, offline), `nexusmem status`
+  gains a `flagged` line, and the sync summary reports new/open suggestion counts.
+- `stale --check-contradictions` reuses each candidate's stored embedding instead of re-embedding
+  it, and stops after two consecutive null SLM replies so a down provider costs at most two timeouts
+  rather than one per candidate.
+
 ## [0.7.0] — 2026-08-21
 
 ### Added
@@ -481,7 +504,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.7.0...HEAD
+[Unreleased]: https://github.com/yaminbkk/NexusMem/compare/v0.8.0...HEAD
+[0.8.0]: https://github.com/yaminbkk/NexusMem/compare/v0.7.0...v0.8.0
 [0.7.0]: https://github.com/yaminbkk/NexusMem/compare/v0.6.0...v0.7.0
 [0.6.0]: https://github.com/yaminbkk/NexusMem/compare/v0.5.4...v0.6.0
 [0.5.4]: https://github.com/yaminbkk/NexusMem/compare/v0.5.3...v0.5.4

package/README.md

@@ -24,7 +24,7 @@ exists nowhere else, and it disappears when your terminal scrollback rolls over.
 **Contents:** [Try it](#try-it) · [Exact shell capture](#optional-exact-shell-capture) ·
 [Failure → fix chains](#failure--fix-chains-opt-in) · [How retrieval works](#how-retrieval-works) ·
 [Session summaries](#session-summaries-optional-local-model) · [Use it from an agent](#use-it-from-an-agent)
-· [What it costs you](#what-it-costs-you) · [Manual staleness & provenance](#manual-staleness--provenance) ·
+· [What it costs you](#what-it-costs-you) · [Staleness & provenance](#staleness--provenance) ·
 [Where it breaks](#where-it-breaks) · [Commands](#commands) · [Cross-project recall](#recall-across-projects)
 · [On disk](#on-disk) · [Development](#development)
 
@@ -48,11 +48,11 @@ Relevant history for: windows spawn failure
   readRepoInfo collapsed three unrelated failures into one error: git running and reporting
   the path is not a work tree, git not being installed, and the process failing to spawn at
   all. Dogfooding hit the third case in two separate sessions...
-- 2026-08-09 [inferred] README.md — Before a tagged release
+- 2026-08-09 [authored] README.md — Before a tagged release
   - [ ] Retry on transient process-spawn failures on Windows
 ```
 
-`[observed]`/`[inferred]` is the provenance tag (see [Manual staleness & provenance](#manual-staleness--provenance))
+`[observed]`/`[authored]` is the provenance tag (see [Staleness & provenance](#staleness--provenance))
 — a commit is a directly observed event, a doc section is a written claim that could go stale.
 
 A commit and a docs section, ranked against each other, inside whatever token budget you gave it.
@@ -269,19 +269,23 @@ Two things a memory layer needs and this one only partly has: a way to tell an o
 guess, and a way to retire a conclusion once something contradicts it. This section is what exists
 and what doesn't.
 
-Every node carries a `provenance`: `observed` (a commit that landed, a shell command's real exit
-code) or `inferred` (a conversation turn, a session summary, a doc section — all readable as claims
-that could be wrong or go stale). Set once per collector at ingest time, shown as a `[observed]` /
-`[inferred]` tag on every query result, and now used to decay retrieval weight too — `inferred` nodes
-fade from ranking twice as fast as `observed` ones as they age.
+Every node carries a `provenance`, a four-tier trust hierarchy set once per collector at ingest
+time: `observed` (a commit that landed, a shell command's real exit code) > `authored` (a doc
+section — a human's own written claim) > `recorded` (a conversation turn — verbatim, but talk about
+events rather than the events) > `derived` (a session summary — a model's distillation). The tier is
+shown as a tag on every query result and decays retrieval weight — the lower the trust, the faster a
+node fades from ranking as it ages. The ordering is the design claim; the exact decay ratios are
+judgment calls, not measured optima.
 
 ```bash
 nexusmem stale
 ```
 
-Lists `inferred` nodes old enough (45+ days by default) that nothing has confirmed they still hold —
-a heuristic on age and provenance, not on content. It writes nothing; you decide which candidates are
-actually wrong.
+Lists non-`observed` nodes old enough (45+ days by default) that nothing has confirmed they still
+hold — a heuristic on age and provenance, not on content. It writes nothing; you decide which
+candidates are actually wrong. Any candidate the SLM has already flagged (see below) is decorated
+with its standing `likely superseded by` suggestion — reading those costs nothing, so the plain
+command stays instant and offline.
 
 ```bash
 nexusmem mark-stale <oldNodeId> --supersedes <newNodeId>
@@ -297,15 +301,20 @@ nexusmem stale --check-contradictions
 For each candidate, finds the most similar newer node (local embedding search) and asks a local SLM
 (Ollama, `qwen2.5:3b` by default) whether it actually contradicts the older one — real content
 comparison, not just age. A match is printed as `likely superseded by <id> <title> -- <reason>`
-under the candidate; nothing is written, same as plain `stale`. Needs Ollama running; costs one
-embedding call and, when a plausible newer node exists, one chat completion per candidate (capped at
-10 by default — pass `-n` to raise it).
+under the candidate. Every judgment (either verdict) is memoized, so a judged pair is never sent to
+the model again; nothing else is written — `supersedes` stays yours to set via `mark-stale`.
+
+**This also runs automatically during `sync`** — at most 3 new judgments per run (configurable via
+the `contradictions` block in `.nexusmem/config.json`; set `autoCheck: false` to turn it off), only
+when the embedding provider was reachable anyway, and free on repeat syncs thanks to the
+memoization. New and open suggestions show up in the sync summary, `nexusmem status` (a `flagged`
+line), and plain `nexusmem stale`.
 
 **What this doesn't do:** it is one small model's yes/no judgment on one older/newer pair, not a
 verified fact — treat a match as a lead to check, not a conclusion. It also only ever compares a
 candidate against nodes *found by embedding similarity*; a contradiction from an unrelated-sounding
-node would never surface. Real contradiction detection (comprehensively, not just for the pair the
-vector search happens to surface) is still an open problem.
+node would never surface. Comprehensive contradiction detection (not just for the pair the vector
+search happens to surface) is still an open problem, and nothing here supersedes a node on its own.
 
 ## Where it breaks
 

package/dist/cli/index.js

@@ -174,7 +174,20 @@ var ConfigSchema = z.object({
   limits: z.object({
     maxFilesPerNode: z.number().int().positive().default(40),
     maxBodyChars: z.number().int().positive().default(4e3)
-  }).default({ maxFilesPerNode: 40, maxBodyChars: 4e3 })
+  }).default({ maxFilesPerNode: 40, maxBodyChars: 4e3 }),
+  /**
+   * Automatic contradiction checking during sync. On by default -- unlike the
+   * opt-in transcript sources, this reads nothing new, writes only suggestions
+   * (never `supersedes`), and stays affordable by construction: at most
+   * `maxPerSync` new SLM judgments per run, judged pairs memoized and never
+   * re-asked, and an unreachable model degrades to skipping quietly.
+   */
+  contradictions: z.object({
+    autoCheck: z.boolean().default(true),
+    maxPerSync: z.number().int().nonnegative().default(3),
+    /** Ollama model tag. Must be pulled locally, same as `sources.session.model`. */
+    model: z.string().default(DEFAULT_SLM_MODEL)
+  }).default({ autoCheck: true, maxPerSync: 3, model: DEFAULT_SLM_MODEL })
 });
 function defaultConfig(projectId) {
   return ConfigSchema.parse({ version: 1, projectId });
@@ -944,13 +957,32 @@ UPDATE nodes SET provenance = 'observed' WHERE kind IN ('git_commit', 'code_diff
 
 CREATE INDEX idx_nodes_supersedes ON nodes (supersedes) WHERE supersedes IS NOT NULL;
 `;
+var V7 = `
+UPDATE nodes SET provenance = 'authored' WHERE kind IN ('doc_section', 'note');
+UPDATE nodes SET provenance = 'recorded' WHERE kind = 'conversation_turn';
+UPDATE nodes SET provenance = 'derived'  WHERE kind = 'session_summary';
+UPDATE nodes SET provenance = 'recorded' WHERE provenance = 'inferred';
+`;
+var V8 = `
+CREATE TABLE contradiction_checks (
+  candidate_id TEXT NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+  against_id   TEXT NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+  contradicts  INTEGER NOT NULL,
+  reason       TEXT,
+  model        TEXT NOT NULL,
+  checked_at   INTEGER NOT NULL,
+  PRIMARY KEY (candidate_id, against_id)
+);
+`;
 var MIGRATIONS = [
   { version: 1, up: (db) => db.exec(V1) },
   { version: 2, up: (db) => db.exec(V2) },
   { version: 3, up: (db) => db.exec(V3) },
   { version: 4, up: (db) => db.exec(V4) },
   { version: 5, up: (db) => db.exec(V5) },
-  { version: 6, up: (db) => db.exec(V6) }
+  { version: 6, up: (db) => db.exec(V6) },
+  { version: 7, up: (db) => db.exec(V7) },
+  { version: 8, up: (db) => db.exec(V8) }
 ];
 var LATEST_SCHEMA_VERSION = MIGRATIONS[MIGRATIONS.length - 1]?.version ?? 0;
 function currentSchemaVersion(db) {
@@ -1012,11 +1044,13 @@ function defaultProvenanceForKind(kind) {
     case "code_diff":
     case "shell_command":
       return "observed";
-    case "conversation_turn":
-    case "session_summary":
     case "doc_section":
     case "note":
-      return "inferred";
+      return "authored";
+    case "conversation_turn":
+      return "recorded";
+    case "session_summary":
+      return "derived";
   }
 }
 
@@ -1171,7 +1205,7 @@ function listStaleCandidates(db, projectId, opts = {}) {
   const rows = db.prepare(
     `SELECT id, kind, ts, ts_epoch AS tsEpoch, source, title
        FROM nodes
-       WHERE project_id = @projectId AND provenance = 'inferred' AND ts_epoch < @cutoff
+       WHERE project_id = @projectId AND provenance != 'observed' AND ts_epoch < @cutoff
          AND id NOT IN (SELECT supersedes FROM nodes WHERE project_id = @projectId AND supersedes IS NOT NULL)
        ORDER BY ts_epoch ASC
        LIMIT @limit`
@@ -1191,7 +1225,7 @@ function countStaleCandidates(db, projectId, opts = {}) {
   const cutoff = now.getTime() - minAgeDays * 864e5;
   const row = db.prepare(
     `SELECT COUNT(*) AS count FROM nodes
-       WHERE project_id = @projectId AND provenance = 'inferred' AND ts_epoch < @cutoff
+       WHERE project_id = @projectId AND provenance != 'observed' AND ts_epoch < @cutoff
          AND id NOT IN (SELECT supersedes FROM nodes WHERE project_id = @projectId AND supersedes IS NOT NULL)`
   ).get({ projectId, cutoff });
   return row.count;
@@ -1372,6 +1406,11 @@ function countNodesNeedingEmbedding(db, projectId) {
   ).get(projectId);
   return row.n;
 }
+function getEmbedding(db, nodeId) {
+  const row = db.prepare("SELECT v.embedding AS embedding FROM nodes_vec v JOIN nodes n ON n.rowid = v.rowid WHERE n.id = ?").get(nodeId);
+  if (!row) return null;
+  return new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.embedding.byteLength / 4);
+}
 function upsertEmbedding(db, rowid, embedding) {
   db.prepare("INSERT OR REPLACE INTO nodes_vec (rowid, embedding) VALUES (?, ?)").run(BigInt(rowid), embedding);
 }
@@ -1449,6 +1488,49 @@ function setMeta(db, key, value) {
   );
 }
 
+// src/store/contradictions.ts
+function recordContradictionCheck(db, input) {
+  db.prepare(
+    `INSERT OR REPLACE INTO contradiction_checks (candidate_id, against_id, contradicts, reason, model, checked_at)
+     VALUES (@candidateId, @againstId, @contradicts, @reason, @model, @now)`
+  ).run({
+    candidateId: input.candidateId,
+    againstId: input.againstId,
+    contradicts: input.contradicts ? 1 : 0,
+    reason: input.reason,
+    model: input.model,
+    now: Date.now()
+  });
+}
+function hasContradictionCheck(db, candidateId, againstId) {
+  const row = db.prepare("SELECT 1 FROM contradiction_checks WHERE candidate_id = ? AND against_id = ?").get(candidateId, againstId);
+  return row !== void 0;
+}
+function listContradictionSuggestions(db, projectId, opts = {}) {
+  return db.prepare(
+    `SELECT c.candidate_id AS candidateId, n.title AS candidateTitle,
+              c.against_id AS againstId, a.title AS againstTitle,
+              c.reason AS reason, c.checked_at AS checkedAt
+       FROM contradiction_checks c
+       JOIN nodes n ON n.id = c.candidate_id
+       JOIN nodes a ON a.id = c.against_id
+       WHERE n.project_id = @projectId AND c.contradicts = 1
+         AND c.candidate_id NOT IN (SELECT supersedes FROM nodes WHERE project_id = @projectId AND supersedes IS NOT NULL)
+       ORDER BY c.checked_at DESC
+       LIMIT @limit`
+  ).all({ projectId, limit: opts.limit ?? 50 });
+}
+function countContradictionSuggestions(db, projectId) {
+  const row = db.prepare(
+    `SELECT COUNT(*) AS count
+       FROM contradiction_checks c
+       JOIN nodes n ON n.id = c.candidate_id
+       WHERE n.project_id = @projectId AND c.contradicts = 1
+         AND c.candidate_id NOT IN (SELECT supersedes FROM nodes WHERE project_id = @projectId AND supersedes IS NOT NULL)`
+  ).get({ projectId });
+  return row.count;
+}
+
 // src/store/store.ts
 var MemoryStore = class _MemoryStore {
   constructor(db) {
@@ -1608,6 +1690,10 @@ var MemoryStore = class _MemoryStore {
   upsertEmbedding(rowid, embedding) {
     upsertEmbedding(this.db, rowid, embedding);
   }
+  /** The stored vector for one node, or null if it has not been embedded yet. */
+  getEmbedding(nodeId) {
+    return getEmbedding(this.db, nodeId);
+  }
   dropAllEmbeddings() {
     return dropAllEmbeddings(this.db);
   }
@@ -1638,7 +1724,7 @@ var MemoryStore = class _MemoryStore {
   setSupersedes(newNodeId, staleNodeId) {
     setSupersedes(this.db, newNodeId, staleNodeId);
   }
-  /** Aging `inferred` nodes nothing supersedes yet -- candidates for `nexusmem mark-stale`, not auto-applied. */
+  /** Aging non-`observed` nodes nothing supersedes yet -- candidates for `nexusmem mark-stale`, not auto-applied. */
   listStaleCandidates(projectId, opts = {}) {
     return listStaleCandidates(this.db, projectId, opts);
   }
@@ -1646,6 +1732,20 @@ var MemoryStore = class _MemoryStore {
   countStaleCandidates(projectId, opts = {}) {
     return countStaleCandidates(this.db, projectId, opts);
   }
+  /** Memoize one SLM contradiction judgment (either verdict). Suggest-only: never writes `supersedes`. */
+  recordContradictionCheck(input) {
+    recordContradictionCheck(this.db, input);
+  }
+  hasContradictionCheck(candidateId, againstId) {
+    return hasContradictionCheck(this.db, candidateId, againstId);
+  }
+  /** Open YES verdicts awaiting a human's `mark-stale`, newest judgment first. */
+  listContradictionSuggestions(projectId, opts = {}) {
+    return listContradictionSuggestions(this.db, projectId, opts);
+  }
+  countContradictionSuggestions(projectId) {
+    return countContradictionSuggestions(this.db, projectId);
+  }
   /** Escape hatch for tests and future modules. */
   get raw() {
     return this.db;
@@ -2458,7 +2558,12 @@ var SIGNAL_FLOOR = 0.2;
 var RECENCY_FLOOR = 0.3;
 var DEFAULT_HALF_LIFE_DAYS = 30;
 var MS_PER_DAY = 864e5;
-var INFERRED_HALF_LIFE_RATIO = 0.5;
+var HALF_LIFE_RATIO = {
+  observed: 1,
+  authored: 0.75,
+  recorded: 0.5,
+  derived: 0.35
+};
 var SUPERSEDED_PENALTY = 0.5;
 var MAX_PRIOR_OVERTURN = 2;
 var PRIOR_COUNT = 2;
@@ -2493,14 +2598,14 @@ function ageDaysOf(ts, now) {
 function rankHits(hits, opts = {}) {
   if (hits.length === 0) return [];
   const halfLife = opts.halfLifeDays ?? DEFAULT_HALF_LIFE_DAYS;
-  const inferredHalfLife = opts.inferredHalfLifeDays ?? halfLife * INFERRED_HALF_LIFE_RATIO;
+  const ratios = { ...HALF_LIFE_RATIO, ...opts.halfLifeRatios };
   const now = opts.now ?? /* @__PURE__ */ new Date();
   const relevances = opts.relevanceScores ? normalizeExternalRelevance(hits, opts.relevanceScores) : normalizeRelevance(hits);
   const ranked = hits.map((hit, i) => {
     const relevance = relevances[i] ?? RELEVANCE_FLOOR;
     const signalWeight = SIGNAL_FLOOR + (1 - SIGNAL_FLOOR) * hit.signal;
     const ageDays = ageDaysOf(hit.ts, now);
-    const effectiveHalfLife = hit.provenance === "inferred" ? inferredHalfLife : halfLife;
+    const effectiveHalfLife = halfLife * (ratios[hit.provenance] ?? 1);
     const recencyFactor = RECENCY_FLOOR + (1 - RECENCY_FLOOR) * 2 ** (-ageDays / effectiveHalfLife);
     const rawScore = relevance * signalWeight ** SIGNAL_EXPONENT * recencyFactor ** RECENCY_EXPONENT;
     const score = opts.supersededIds?.has(hit.id) ? rawScore * SUPERSEDED_PENALTY : rawScore;
@@ -2830,8 +2935,8 @@ function toMemoryNodes(turn, projectId, opts = {}) {
       files: extractMentionedFiles(`${userRedacted.text}
 ${chunk2.text}`),
       signal: scoreConversationTurn(userRedacted.text, chunk2.text),
-      provenance: "inferred",
-      // discourse about what happened, not the event itself
+      provenance: "recorded",
+      // verbatim discourse about what happened, not the event itself
       meta: {
         cwd: turn.cwd,
         source: turn.source,
@@ -3403,8 +3508,8 @@ function toMemoryNodes3(file, projectId, opts = {}) {
       body: truncate(chunk2.text, maxBody),
       files: [{ path: file.path, insertions: null, deletions: null, binary: false }],
       signal: scoreDocSection(file.path, chunk2.heading, chunk2.text),
-      provenance: "inferred",
-      // a written claim, and the kind of content most likely to go stale
+      provenance: "authored",
+      // a human's own written claim -- deliberate, but can still go stale
       meta: {
         path: file.path,
         heading: chunk2.heading,
@@ -3566,7 +3671,7 @@ ${summary.body}`;
     files: extractMentionedFiles(session.turns.map((t) => `${t.userText}
 ${t.assistantText}`).join("\n")),
     signal: scoreSession(session.turns.length),
-    provenance: "inferred",
+    provenance: "derived",
     // a model's distillation, not a directly observed event
     meta: {
       sessionKey: session.sessionKey,
@@ -3820,6 +3925,97 @@ async function readDocFiles(repoRoot, opts = {}) {
   return { files, unreadable };
 }
 
+// src/slm/contradiction.ts
+var MAX_BODY_CHARS = 1500;
+var MAX_REASON_CHARS = 200;
+var CONTRADICTION_INSTRUCTIONS = `You are checking whether a NEWER memory replaces or contradicts an OLDER one, for an AI coding assistant's memory index.
+
+Answer in exactly this shape:
+VERDICT: YES or NO
+REASON: <one line, under 20 words>
+
+Say YES only if the NEWER memory states something that makes the OLDER one factually wrong or obsolete -- a decision reversed, a bug fixed, a plan abandoned. Say NO if they are about different things, or the newer one only adds detail without contradicting the older one. When unsure, say NO.`;
+function buildContradictionPrompt(older, newer) {
+  const body = [
+    `OLDER (${older.title}):`,
+    truncate(older.body, MAX_BODY_CHARS),
+    "",
+    `NEWER (${newer.title}):`,
+    truncate(newer.body, MAX_BODY_CHARS)
+  ].join("\n");
+  return `${CONTRADICTION_INSTRUCTIONS}
+
+---
+
+${body}
+
+---
+
+Answer:`;
+}
+function parseContradictionVerdict(raw) {
+  const lines = raw.trim().split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
+  const verdictLine = lines.find((l) => /^VERDICT:/i.test(l));
+  if (!verdictLine) return null;
+  const verdict = /^VERDICT:\s*(YES|NO)\b/i.exec(verdictLine);
+  if (!verdict) return null;
+  const reasonLine = lines.find((l) => /^REASON:/i.test(l));
+  const reason = reasonLine ? reasonLine.replace(/^REASON:\s*/i, "").trim() : "";
+  return {
+    contradicts: verdict[1].toUpperCase() === "YES",
+    reason: truncate(reason, MAX_REASON_CHARS)
+  };
+}
+
+// src/retrieval/contradiction.ts
+var DEFAULT_LIMIT = 10;
+var DEFAULT_NEIGHBOR_LIMIT = 25;
+async function checkContradictions(store, embeddingProvider, slmProvider, projectId, candidates, opts = {}) {
+  const limit = opts.limit ?? DEFAULT_LIMIT;
+  const neighborLimit = opts.neighborLimit ?? DEFAULT_NEIGHBOR_LIMIT;
+  const model = opts.model ?? DEFAULT_SLM_MODEL;
+  const suggestions = [];
+  let judgments = 0;
+  let consecutiveNullReplies = 0;
+  for (const candidate of candidates.slice(0, limit)) {
+    if (opts.maxJudgments !== void 0 && judgments >= opts.maxJudgments) break;
+    const full = store.getNodesByIds([candidate.id])[0];
+    if (!full) continue;
+    const embedding = store.getEmbedding(candidate.id) ?? await embeddingProvider.embed(`${full.title}
+${full.body}`);
+    if (!embedding) continue;
+    const candidateEpoch = Date.parse(candidate.ts);
+    const nearest = store.vectorSearch(projectId, embedding, neighborLimit + 1).find((hit) => hit.id !== candidate.id && Date.parse(hit.ts) > candidateEpoch);
+    if (!nearest) continue;
+    if (store.hasContradictionCheck(candidate.id, nearest.id)) continue;
+    const reply = await slmProvider.complete(buildContradictionPrompt(full, nearest));
+    if (!reply) {
+      consecutiveNullReplies += 1;
+      if (consecutiveNullReplies >= 2) break;
+      continue;
+    }
+    consecutiveNullReplies = 0;
+    const verdict = parseContradictionVerdict(reply);
+    if (!verdict) continue;
+    judgments += 1;
+    store.recordContradictionCheck({
+      candidateId: candidate.id,
+      againstId: nearest.id,
+      contradicts: verdict.contradicts,
+      reason: verdict.contradicts ? verdict.reason : null,
+      model
+    });
+    if (!verdict.contradicts) continue;
+    suggestions.push({
+      candidateId: candidate.id,
+      againstId: nearest.id,
+      againstTitle: nearest.title,
+      reason: verdict.reason
+    });
+  }
+  return suggestions;
+}
+
 // src/shell/detect.ts
 import { existsSync as existsSync4 } from "fs";
 import { readFile as readFile9, stat as stat2 } from "fs/promises";
@@ -4929,6 +5125,21 @@ function runPruneSources(store, projectId, otherProjectIds, sources, yes, out) {
 `);
   return 0;
 }
+async function runAutoContradictionCheck(store, config, projectId, providers) {
+  if (!config.contradictions.autoCheck) return "";
+  const candidates = store.listStaleCandidates(projectId);
+  if (candidates.length === 0) return "";
+  const fresh = await checkContradictions(store, providers.embedder, providers.slm, projectId, candidates, {
+    limit: candidates.length,
+    maxJudgments: config.contradictions.maxPerSync,
+    model: config.contradictions.model
+  });
+  const open = store.countContradictionSuggestions(projectId);
+  if (fresh.length === 0 && open === 0) return "";
+  const freshPart = fresh.length > 0 ? pc7.yellow(`${fresh.length} new`) : `${fresh.length} new`;
+  return `  ${pc7.dim("contradictions:")} ${freshPart}${pc7.dim(`, ${open} open suggestion(s) -- run`)} ${pc7.bold("nexusmem stale")} ${pc7.dim("for detail")}
+`;
+}
 async function runSync(opts) {
   const { repo, ws, projectId, config } = await loadContext(opts.cwd);
   const log = (line) => {
@@ -4982,6 +5193,7 @@ async function runSync(opts) {
     const docs = await syncDocs(store, projectId, repo.root, config, log);
     const structure = await syncStructure(store, projectId, repo.root, config, log);
     let embedLine = "";
+    let embeddingAvailable = false;
     if (!opts.noEmbed) {
       let lastLogged = 0;
       const result = await embedPendingNodes(store, new OllamaEmbeddingProvider(), projectId, {
@@ -4993,6 +5205,7 @@ async function runSync(opts) {
           log(`  ${pc7.dim(`vector: ${attempted}/${total} embedded`)}`);
         }
       });
+      embeddingAvailable = !result.providerUnavailable;
       if (result.embedded > 0) {
         const skippedPart = result.skipped > 0 ? pc7.dim(`, ${result.skipped} skipped`) : "";
         const remainingPart = result.remaining > 0 ? pc7.yellow(`, ${result.remaining} still pending`) : "";
@@ -5002,6 +5215,10 @@ async function runSync(opts) {
         log(`${pc7.dim("vector")} embedding provider unavailable (is Ollama running with nomic-embed-text pulled?) -- BM25-only for now`);
       }
     }
+    const contradictionLine = !opts.noEmbed && embeddingAvailable ? await runAutoContradictionCheck(store, config, projectId, {
+      embedder: new OllamaEmbeddingProvider(),
+      slm: new OllamaChatProvider({ model: config.contradictions.model })
+    }) : "";
     let linkLine = "";
     if (opts.linkFailures) {
       const linkStats = correlateFailures(store, projectId);
@@ -5030,7 +5247,7 @@ async function runSync(opts) {
         `  ${pc7.green(`+${totals.inserted} new`)}  ${pc7.yellow(`~${totals.updated} updated`)}  ${pc7.dim(`=${totals.unchanged} unchanged`)}${deniedPart}`,
         `  ${pc7.dim(`${stats2.total} node(s) total across ${stats2.distinctFiles} file path(s)`)}`,
         ""
-      ].join("\n") + embedLine + linkLine
+      ].join("\n") + embedLine + linkLine + contradictionLine
     );
     return 0;
   } finally {
@@ -5787,80 +6004,6 @@ ${pc17.bold(String(edges.length))} edge(s) from ${filesScanned} tracked ${TRACKE
 
 // src/cli/commands/stale.ts
 import pc18 from "picocolors";
-
-// src/slm/contradiction.ts
-var MAX_BODY_CHARS = 1500;
-var MAX_REASON_CHARS = 200;
-var CONTRADICTION_INSTRUCTIONS = `You are checking whether a NEWER memory replaces or contradicts an OLDER one, for an AI coding assistant's memory index.
-
-Answer in exactly this shape:
-VERDICT: YES or NO
-REASON: <one line, under 20 words>
-
-Say YES only if the NEWER memory states something that makes the OLDER one factually wrong or obsolete -- a decision reversed, a bug fixed, a plan abandoned. Say NO if they are about different things, or the newer one only adds detail without contradicting the older one. When unsure, say NO.`;
-function buildContradictionPrompt(older, newer) {
-  const body = [
-    `OLDER (${older.title}):`,
-    truncate(older.body, MAX_BODY_CHARS),
-    "",
-    `NEWER (${newer.title}):`,
-    truncate(newer.body, MAX_BODY_CHARS)
-  ].join("\n");
-  return `${CONTRADICTION_INSTRUCTIONS}
-
----
-
-${body}
-
----
-
-Answer:`;
-}
-function parseContradictionVerdict(raw) {
-  const lines = raw.trim().split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
-  const verdictLine = lines.find((l) => /^VERDICT:/i.test(l));
-  if (!verdictLine) return null;
-  const verdict = /^VERDICT:\s*(YES|NO)\b/i.exec(verdictLine);
-  if (!verdict) return null;
-  const reasonLine = lines.find((l) => /^REASON:/i.test(l));
-  const reason = reasonLine ? reasonLine.replace(/^REASON:\s*/i, "").trim() : "";
-  return {
-    contradicts: verdict[1].toUpperCase() === "YES",
-    reason: truncate(reason, MAX_REASON_CHARS)
-  };
-}
-
-// src/retrieval/contradiction.ts
-var DEFAULT_LIMIT = 10;
-var DEFAULT_NEIGHBOR_LIMIT = 25;
-async function checkContradictions(store, embeddingProvider, slmProvider, projectId, candidates, opts = {}) {
-  const limit = opts.limit ?? DEFAULT_LIMIT;
-  const neighborLimit = opts.neighborLimit ?? DEFAULT_NEIGHBOR_LIMIT;
-  const suggestions = [];
-  for (const candidate of candidates.slice(0, limit)) {
-    const full = store.getNodesByIds([candidate.id])[0];
-    if (!full) continue;
-    const embedding = await embeddingProvider.embed(`${full.title}
-${full.body}`);
-    if (!embedding) continue;
-    const candidateEpoch = Date.parse(candidate.ts);
-    const nearest = store.vectorSearch(projectId, embedding, neighborLimit + 1).find((hit) => hit.id !== candidate.id && Date.parse(hit.ts) > candidateEpoch);
-    if (!nearest) continue;
-    const reply = await slmProvider.complete(buildContradictionPrompt(full, nearest));
-    if (!reply) continue;
-    const verdict = parseContradictionVerdict(reply);
-    if (!verdict?.contradicts) continue;
-    suggestions.push({
-      candidateId: candidate.id,
-      againstId: nearest.id,
-      againstTitle: nearest.title,
-      reason: verdict.reason
-    });
-  }
-  return suggestions;
-}
-
-// src/cli/commands/stale.ts
 var STALE_DEFAULT_MODEL = DEFAULT_SLM_MODEL;
 async function runStale(opts) {
   const { projectId, ws } = await loadContext(opts.cwd);
@@ -5869,7 +6012,7 @@ async function runStale(opts) {
   try {
     const candidates = store.listStaleCandidates(projectId, { minAgeDays: opts.minAgeDays, limit: opts.limit });
     if (candidates.length === 0) {
-      out(`${pc18.dim("no stale candidates")} -- no inferred node older than the threshold lacks a successor
+      out(`${pc18.dim("no stale candidates")} -- no unconfirmed node older than the threshold lacks a successor
 `);
       return 0;
     }
@@ -5880,10 +6023,15 @@ async function runStale(opts) {
         new OllamaEmbeddingProvider(),
         new OllamaChatProvider({ model: opts.model ?? DEFAULT_SLM_MODEL }),
         projectId,
-        candidates
+        candidates,
+        { model: opts.model ?? DEFAULT_SLM_MODEL }
       );
     }
-    const byCandidateId = new Map(suggestions.map((s) => [s.candidateId, s]));
+    const byCandidateId = /* @__PURE__ */ new Map();
+    for (const s of store.listContradictionSuggestions(projectId)) {
+      byCandidateId.set(s.candidateId, { againstId: s.againstId, againstTitle: s.againstTitle, reason: s.reason ?? "" });
+    }
+    for (const s of suggestions) byCandidateId.set(s.candidateId, s);
     out(
       [
         `${pc18.bold(String(candidates.length))} stale candidate(s) -- oldest first, none of these were changed:`,
@@ -5963,6 +6111,7 @@ async function runStatus(opts) {
     const otherProjectNodes = store.countProjectNodes(otherProjectIds);
     const structure = store.fileEdgeStats(projectId);
     const staleCount = store.countStaleCandidates(projectId);
+    const flaggedCount = store.countContradictionSuggestions(projectId);
     const dbBytes = fileSize(ws.dbPath) + fileSize(`${ws.dbPath}-wal`);
     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 ? `${pc19.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc19.bold(
@@ -5991,7 +6140,8 @@ async function runStatus(opts) {
         gitCursor && gitCursor !== repo.head ? `${pc19.yellow("git behind HEAD")} \u2014 run ${pc19.bold("nexusmem sync")}` : "",
         chains.failuresTotal ? `${pc19.dim("chains  ")} ${pc19.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc19.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc19.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
         structure.edges ? `${pc19.dim("structure")} ${pc19.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : "",
-        staleCount ? `${pc19.dim("aging   ")} ${pc19.bold(String(staleCount))} inferred node(s) worth a look \u2014 run ${pc19.bold("nexusmem stale")}` : ""
+        staleCount ? `${pc19.dim("aging   ")} ${pc19.bold(String(staleCount))} unconfirmed node(s) worth a look \u2014 run ${pc19.bold("nexusmem stale")}` : "",
+        flaggedCount ? `${pc19.dim("flagged ")} ${pc19.bold(String(flaggedCount))} likely-superseded node(s) awaiting review \u2014 run ${pc19.bold("nexusmem stale")} for detail` : ""
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
     return 0;
@@ -6113,7 +6263,7 @@ program.command("mark-stale").description(
 ).argument("<nodeId>", "id of the node to mark stale").requiredOption("--supersedes <newNodeId>", "id of the node that supersedes it").option("-C, --cwd <path>", "repository path", process.cwd()).action(
   (nodeId, options) => guard(() => runMarkStale({ cwd: options.cwd, nodeId, supersedesId: options.supersedes }))()
 );
-program.command("stale").description("List inferred nodes old enough to be worth double-checking (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-age-days <days>", "only nodes at least this old", (v) => Number.parseFloat(v)).option("-n, --limit <count>", "stop after N candidates", (v) => Number.parseInt(v, 10)).option(
+program.command("stale").description("List unconfirmed (non-observed) nodes old enough to be worth double-checking (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--min-age-days <days>", "only nodes at least this old", (v) => Number.parseFloat(v)).option("-n, --limit <count>", "stop after N candidates", (v) => Number.parseInt(v, 10)).option(
   "--check-contradictions",
   "ask the local SLM whether a similar newer node actually contradicts each candidate (needs Ollama)"
 ).option("--model <name>", "Ollama chat model for --check-contradictions", STALE_DEFAULT_MODEL).action(