nexusmem 0.5.4 → 0.7.0

package/dist/cli/index.js

@@ -2,7 +2,7 @@
 
 // src/cli/index.ts
 import { Command } from "commander";
-import pc19 from "picocolors";
+import pc20 from "picocolors";
 
 // src/config/workspace.ts
 import { existsSync } from "fs";
@@ -1164,6 +1164,38 @@ function getSupersededIds(db, projectId) {
 function setSupersedes(db, newNodeId, staleNodeId) {
   db.prepare("UPDATE nodes SET supersedes = ? WHERE id = ?").run(staleNodeId, newNodeId);
 }
+function listStaleCandidates(db, projectId, opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const minAgeDays = opts.minAgeDays ?? 45;
+  const cutoff = now.getTime() - minAgeDays * 864e5;
+  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
+         AND id NOT IN (SELECT supersedes FROM nodes WHERE project_id = @projectId AND supersedes IS NOT NULL)
+       ORDER BY ts_epoch ASC
+       LIMIT @limit`
+  ).all({ projectId, cutoff, limit: opts.limit ?? 50 });
+  return rows.map((r) => ({
+    id: r.id,
+    kind: r.kind,
+    ts: r.ts,
+    source: r.source,
+    title: r.title,
+    ageDays: Math.round((now.getTime() - r.tsEpoch) / 864e5)
+  }));
+}
+function countStaleCandidates(db, projectId, opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const minAgeDays = opts.minAgeDays ?? 45;
+  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
+         AND id NOT IN (SELECT supersedes FROM nodes WHERE project_id = @projectId AND supersedes IS NOT NULL)`
+  ).get({ projectId, cutoff });
+  return row.count;
+}
 
 // src/store/links.ts
 function linkNodes(db, fromNodeId, toNodeId, relation) {
@@ -1606,6 +1638,14 @@ 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. */
+  listStaleCandidates(projectId, opts = {}) {
+    return listStaleCandidates(this.db, projectId, opts);
+  }
+  /** Same criteria as `listStaleCandidates`, but just the count -- for `status`'s summary line. */
+  countStaleCandidates(projectId, opts = {}) {
+    return countStaleCandidates(this.db, projectId, opts);
+  }
   /** Escape hatch for tests and future modules. */
   get raw() {
     return this.db;
@@ -2418,6 +2458,7 @@ 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 SUPERSEDED_PENALTY = 0.5;
 var MAX_PRIOR_OVERTURN = 2;
 var PRIOR_COUNT = 2;
@@ -2452,13 +2493,15 @@ 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 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 recencyFactor = RECENCY_FLOOR + (1 - RECENCY_FLOOR) * 2 ** (-ageDays / halfLife);
+    const effectiveHalfLife = hit.provenance === "inferred" ? inferredHalfLife : halfLife;
+    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;
     return { ...hit, relevance, signalWeight, ageDays, recencyFactor, score };
@@ -4124,6 +4167,100 @@ function extractImportSpecifiers(source) {
   return [...seen];
 }
 
+// src/structure/extract-go.ts
+var SINGLE_IMPORT = /\bimport\s+(?:[\w.]+\s+)?"([^"]+)"/g;
+var IMPORT_BLOCK = /\bimport\s*\(([\s\S]*?)\)/g;
+var BLOCK_LINE = /(?:^|\n)\s*(?:[\w.]+\s+)?"([^"]+)"/g;
+function extractGoImportSpecifiers(source) {
+  const seen = /* @__PURE__ */ new Set();
+  IMPORT_BLOCK.lastIndex = 0;
+  let block;
+  while ((block = IMPORT_BLOCK.exec(source)) !== null) {
+    BLOCK_LINE.lastIndex = 0;
+    let line;
+    while ((line = BLOCK_LINE.exec(block[1])) !== null) {
+      seen.add(line[1]);
+    }
+  }
+  SINGLE_IMPORT.lastIndex = 0;
+  let single;
+  while ((single = SINGLE_IMPORT.exec(source)) !== null) {
+    seen.add(single[1]);
+  }
+  return [...seen];
+}
+
+// src/structure/extract-java.ts
+var IMPORT_PATTERN = /\bimport\s+(?!static\b)([\w.]+(?:\.\*)?)\s*;/g;
+function extractJavaImportSpecifiers(source) {
+  const seen = /* @__PURE__ */ new Set();
+  IMPORT_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = IMPORT_PATTERN.exec(source)) !== null) {
+    seen.add(match[1]);
+  }
+  return [...seen];
+}
+
+// src/structure/extract-php.ts
+var ANCHORED_INCLUDE = /\b(?:require|include)(?:_once)?\b\s*\(?\s*(?:__DIR__|dirname\s*\(\s*__FILE__\s*\))\s*\.\s*['"]([^'"]+)['"]/g;
+function extractPhpIncludeSpecifiers(source) {
+  const seen = /* @__PURE__ */ new Set();
+  ANCHORED_INCLUDE.lastIndex = 0;
+  let match;
+  while ((match = ANCHORED_INCLUDE.exec(source)) !== null) {
+    seen.add(match[1]);
+  }
+  return [...seen];
+}
+
+// src/structure/extract-python.ts
+var RELATIVE_IMPORT_PATTERN = /\bfrom\s+(\.+)([\w.]*)\s+import\s+([^\n]+)/g;
+var BARE_FROM_IMPORT_PATTERN = /^[ \t]*from\s+([A-Za-z_]\w*)\s+import\b/gm;
+var BARE_IMPORT_PATTERN = /^[ \t]*import\s+([^\n]+)/gm;
+function cleanNames(raw) {
+  return raw.split("#")[0].replace(/[()]/g, "").split(",").map((token) => token.trim().split(/\s+as\s+/)[0].trim()).filter((name) => /^[A-Za-z_]\w*$/.test(name));
+}
+function extractPythonImportSpecifiers(source) {
+  const seen = /* @__PURE__ */ new Set();
+  RELATIVE_IMPORT_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = RELATIVE_IMPORT_PATTERN.exec(source)) !== null) {
+    const dots = match[1];
+    const module = match[2];
+    if (module) {
+      seen.add(dots + module);
+      continue;
+    }
+    for (const name of cleanNames(match[3])) {
+      seen.add(dots + name);
+    }
+  }
+  BARE_FROM_IMPORT_PATTERN.lastIndex = 0;
+  while ((match = BARE_FROM_IMPORT_PATTERN.exec(source)) !== null) {
+    seen.add(match[1]);
+  }
+  BARE_IMPORT_PATTERN.lastIndex = 0;
+  while ((match = BARE_IMPORT_PATTERN.exec(source)) !== null) {
+    for (const name of cleanNames(match[1])) {
+      seen.add(name);
+    }
+  }
+  return [...seen];
+}
+
+// src/structure/extract-rust.ts
+var MOD_DECLARATION = /\b(?:pub(?:\([^)]*\))?\s+)?mod\s+([A-Za-z_]\w*)\s*;/g;
+function extractRustModSpecifiers(source) {
+  const seen = /* @__PURE__ */ new Set();
+  MOD_DECLARATION.lastIndex = 0;
+  let match;
+  while ((match = MOD_DECLARATION.exec(source)) !== null) {
+    seen.add(match[1]);
+  }
+  return [...seen];
+}
+
 // src/structure/resolve.ts
 import { posix } from "path";
 var REWRITE_EXTENSIONS = {
@@ -4160,12 +4297,291 @@ function resolveSpecifier(fromPath, specifier, trackedPaths) {
   return null;
 }
 
+// src/structure/resolve-go.ts
+import { posix as posix2 } from "path";
+function parseGoModulePath(goModContent) {
+  const match = goModContent.match(/^module\s+(\S+)/m);
+  return match ? match[1] : null;
+}
+function resolveGoSpecifier(modulePath, importPath, trackedPaths) {
+  let relDir;
+  if (importPath === modulePath) {
+    relDir = ".";
+  } else if (importPath.startsWith(`${modulePath}/`)) {
+    relDir = importPath.slice(modulePath.length + 1);
+  } else {
+    return [];
+  }
+  return [...trackedPaths].filter((p) => p.endsWith(".go") && !p.endsWith("_test.go") && posix2.dirname(p) === relDir).sort();
+}
+
+// src/structure/resolve-java.ts
+import { posix as posix3 } from "path";
+function endsAtSegmentBoundary(path, suffix) {
+  return path === suffix || path.endsWith(`/${suffix}`);
+}
+function resolveJavaSpecifier(specifier, trackedPaths) {
+  const isWildcard = specifier.endsWith(".*");
+  const segments = (isWildcard ? specifier.slice(0, -2) : specifier).split(".").filter(Boolean);
+  if (segments.length === 0) return [];
+  if (isWildcard) {
+    const dirSuffix = segments.join("/");
+    const matches2 = [...trackedPaths].filter((p) => p.endsWith(".java") && endsAtSegmentBoundary(posix3.dirname(p), dirSuffix));
+    const dirs = new Set(matches2.map((p) => posix3.dirname(p)));
+    return dirs.size === 1 ? matches2.sort() : [];
+  }
+  const fileSuffix = `${segments.join("/")}.java`;
+  const matches = [...trackedPaths].filter((p) => endsAtSegmentBoundary(p, fileSuffix));
+  return matches.length === 1 ? matches : [];
+}
+
+// src/structure/resolve-php.ts
+import { posix as posix4 } from "path";
+function resolvePhpSpecifier(fromPath, specifier, trackedPaths) {
+  const fromDir = posix4.dirname(fromPath);
+  const relative2 = specifier.startsWith("/") ? specifier.slice(1) : specifier;
+  const joined = posix4.normalize(posix4.join(fromDir, relative2));
+  if (trackedPaths.has(joined)) return joined;
+  const withExt = joined.endsWith(".php") ? joined : `${joined}.php`;
+  if (trackedPaths.has(withExt)) return withExt;
+  return null;
+}
+
+// src/structure/resolve-python.ts
+import { posix as posix5 } from "path";
+var STDLIB_MODULES = /* @__PURE__ */ new Set([
+  "__future__",
+  "abc",
+  "argparse",
+  "array",
+  "ast",
+  "asyncio",
+  "base64",
+  "bisect",
+  "builtins",
+  "calendar",
+  "cgi",
+  "cgitb",
+  "cmd",
+  "codecs",
+  "collections",
+  "colorsys",
+  "compileall",
+  "concurrent",
+  "configparser",
+  "contextlib",
+  "contextvars",
+  "copy",
+  "copyreg",
+  "cProfile",
+  "csv",
+  "ctypes",
+  "curses",
+  "dataclasses",
+  "datetime",
+  "dbm",
+  "decimal",
+  "difflib",
+  "dis",
+  "doctest",
+  "email",
+  "encodings",
+  "ensurepip",
+  "enum",
+  "errno",
+  "faulthandler",
+  "fcntl",
+  "filecmp",
+  "fileinput",
+  "fnmatch",
+  "fractions",
+  "ftplib",
+  "functools",
+  "gc",
+  "getopt",
+  "getpass",
+  "gettext",
+  "glob",
+  "graphlib",
+  "grp",
+  "gzip",
+  "hashlib",
+  "heapq",
+  "hmac",
+  "html",
+  "http",
+  "imaplib",
+  "importlib",
+  "inspect",
+  "io",
+  "ipaddress",
+  "itertools",
+  "json",
+  "keyword",
+  "locale",
+  "logging",
+  "lzma",
+  "mailbox",
+  "marshal",
+  "math",
+  "mimetypes",
+  "mmap",
+  "msvcrt",
+  "multiprocessing",
+  "operator",
+  "os",
+  "pathlib",
+  "pdb",
+  "pickle",
+  "pickletools",
+  "pkgutil",
+  "platform",
+  "plistlib",
+  "poplib",
+  "posix",
+  "pprint",
+  "profile",
+  "pstats",
+  "pty",
+  "pwd",
+  "py_compile",
+  "pyclbr",
+  "pydoc",
+  "queue",
+  "quopri",
+  "random",
+  "re",
+  "readline",
+  "reprlib",
+  "resource",
+  "rlcompleter",
+  "runpy",
+  "sched",
+  "secrets",
+  "select",
+  "selectors",
+  "shelve",
+  "shlex",
+  "shutil",
+  "signal",
+  "site",
+  "smtplib",
+  "socket",
+  "socketserver",
+  "sqlite3",
+  "ssl",
+  "stat",
+  "statistics",
+  "string",
+  "stringprep",
+  "struct",
+  "subprocess",
+  "symtable",
+  "sys",
+  "sysconfig",
+  "syslog",
+  "tarfile",
+  "telnetlib",
+  "tempfile",
+  "termios",
+  "test",
+  "textwrap",
+  "threading",
+  "time",
+  "timeit",
+  "tkinter",
+  "token",
+  "tokenize",
+  "tomllib",
+  "trace",
+  "traceback",
+  "tracemalloc",
+  "tty",
+  "turtle",
+  "types",
+  "typing",
+  "unicodedata",
+  "unittest",
+  "urllib",
+  "uuid",
+  "venv",
+  "warnings",
+  "wave",
+  "weakref",
+  "webbrowser",
+  "winreg",
+  "winsound",
+  "wsgiref",
+  "xml",
+  "xmlrpc",
+  "zipapp",
+  "zipfile",
+  "zipimport",
+  "zlib",
+  "zoneinfo"
+]);
+function resolvePythonSpecifier(fromPath, specifier, trackedPaths) {
+  const dotsMatch = specifier.match(/^\.+/);
+  const level = dotsMatch ? dotsMatch[0].length : 0;
+  if (level === 0 && STDLIB_MODULES.has(specifier)) return null;
+  const segments = (level === 0 ? specifier : specifier.slice(level)).split(".").filter(Boolean);
+  if (segments.length === 0) return null;
+  let dir = posix5.dirname(fromPath);
+  for (let i = 1; i < level; i++) {
+    dir = posix5.dirname(dir);
+  }
+  const joined = posix5.join(dir, ...segments);
+  const moduleFile = `${joined}.py`;
+  if (trackedPaths.has(moduleFile)) return moduleFile;
+  const packageInit = posix5.join(joined, "__init__.py");
+  if (trackedPaths.has(packageInit)) return packageInit;
+  return null;
+}
+
+// src/structure/resolve-rust.ts
+import { posix as posix6 } from "path";
+function resolveRustModSpecifier(fromPath, name, trackedPaths) {
+  const dir = posix6.dirname(fromPath);
+  const base = posix6.basename(fromPath, ".rs");
+  const moduleDir = base === "mod" || base === "lib" || base === "main" ? dir : posix6.join(dir, base);
+  const sibling = posix6.join(moduleDir, `${name}.rs`);
+  if (trackedPaths.has(sibling)) return sibling;
+  const nested = posix6.join(moduleDir, name, "mod.rs");
+  if (trackedPaths.has(nested)) return nested;
+  return null;
+}
+
 // src/structure/collect.ts
-var TRACKED_PATHSPECS = ["*.ts", "*.tsx", "*.js", "*.jsx"];
+var TRACKED_PATHSPECS = ["*.ts", "*.tsx", "*.js", "*.jsx", "*.py", "*.go", "*.rs", "*.java", "*.php"];
+function resolveTargets(path, content, trackedPaths, goModulePath) {
+  if (path.endsWith(".py")) {
+    return extractPythonImportSpecifiers(content).map((s) => resolvePythonSpecifier(path, s, trackedPaths)).filter((t) => t !== null);
+  }
+  if (path.endsWith(".rs")) {
+    return extractRustModSpecifiers(content).map((s) => resolveRustModSpecifier(path, s, trackedPaths)).filter((t) => t !== null);
+  }
+  if (path.endsWith(".go")) {
+    if (!goModulePath) return [];
+    return extractGoImportSpecifiers(content).flatMap((imp) => resolveGoSpecifier(goModulePath, imp, trackedPaths));
+  }
+  if (path.endsWith(".java")) {
+    return extractJavaImportSpecifiers(content).flatMap((s) => resolveJavaSpecifier(s, trackedPaths));
+  }
+  if (path.endsWith(".php")) {
+    return extractPhpIncludeSpecifiers(content).map((s) => resolvePhpSpecifier(path, s, trackedPaths)).filter((t) => t !== null);
+  }
+  return extractImportSpecifiers(content).map((s) => resolveSpecifier(path, s, trackedPaths)).filter((t) => t !== null);
+}
 async function collectFileEdges(repoRoot) {
   const out = await git(repoRoot, ["ls-files", "--", ...TRACKED_PATHSPECS]);
   const paths = out.split("\n").map((line) => line.trim().replace(/\\/g, "/")).filter(Boolean);
   const trackedPaths = new Set(paths);
+  let goModulePath = null;
+  try {
+    goModulePath = parseGoModulePath(await readFile10(join8(repoRoot, "go.mod"), "utf8"));
+  } catch {
+    goModulePath = null;
+  }
   const edges = [];
   const seenEdges = /* @__PURE__ */ new Set();
   const unreadable = [];
@@ -4177,10 +4593,9 @@ async function collectFileEdges(repoRoot) {
       unreadable.push(path);
       continue;
     }
-    for (const specifier of extractImportSpecifiers(content)) {
-      const target = resolveSpecifier(path, specifier, trackedPaths);
-      if (!target || target === path) continue;
-      const key = `${path}\0${target}`;
+    for (const target of resolveTargets(path, content, trackedPaths, goModulePath)) {
+      if (target === path) continue;
+      const key = `${path} ${target}`;
       if (seenEdges.has(key)) continue;
       seenEdges.add(key);
       edges.push({ fromPath: path, toPath: target, kind: "import" });
@@ -5344,6 +5759,7 @@ function formatNode5(node) {
 
 // src/cli/commands/scan-structure.ts
 import pc17 from "picocolors";
+var TRACKED_EXTENSIONS = TRACKED_PATHSPECS.map((p) => p.replace("*", "")).join("/");
 async function runScanStructure(opts) {
   const repo = await readRepoInfo(opts.cwd);
   const { edges, filesScanned, unreadable } = await collectFileEdges(repo.root);
@@ -5363,16 +5779,134 @@ async function runScanStructure(opts) {
   }
   process.stderr.write(
     `
-${pc17.bold(String(edges.length))} edge(s) from ${filesScanned} tracked .ts/.tsx/.js/.jsx file(s)
+${pc17.bold(String(edges.length))} edge(s) from ${filesScanned} tracked ${TRACKED_EXTENSIONS} file(s)
 `
   );
   return 0;
 }
 
+// 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);
+  const out = opts.out ?? ((chunk2) => void process.stdout.write(chunk2));
+  const store = MemoryStore.open(ws.dbPath);
+  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
+`);
+      return 0;
+    }
+    let suggestions = [];
+    if (opts.checkContradictions) {
+      suggestions = await checkContradictions(
+        store,
+        new OllamaEmbeddingProvider(),
+        new OllamaChatProvider({ model: opts.model ?? DEFAULT_SLM_MODEL }),
+        projectId,
+        candidates
+      );
+    }
+    const byCandidateId = new Map(suggestions.map((s) => [s.candidateId, s]));
+    out(
+      [
+        `${pc18.bold(String(candidates.length))} stale candidate(s) -- oldest first, none of these were changed:`,
+        ...candidates.map((c) => {
+          const line = `  ${pc18.dim(c.id)} ${pc18.yellow(`${c.ageDays}d old`)} [${c.kind}] ${c.title}`;
+          const hit = byCandidateId.get(c.id);
+          return hit ? `${line}
+    ${pc18.red("likely superseded by")} ${pc18.dim(hit.againstId)} ${hit.againstTitle} -- ${hit.reason}` : line;
+        }),
+        "",
+        `run ${pc18.bold("nexusmem mark-stale <id> --supersedes <newId>")} on any that are actually wrong`
+      ].join("\n").concat("\n")
+    );
+    return 0;
+  } finally {
+    store.close();
+  }
+}
+
 // src/cli/commands/status.ts
 import { basename as basename4 } from "path";
 import { statSync } from "fs";
-import pc18 from "picocolors";
+import pc19 from "picocolors";
 function daySpan(oldest, newest) {
   const oldestDay = Date.parse(oldest.slice(0, 10));
   const newestDay = Date.parse(newest.slice(0, 10));
@@ -5428,34 +5962,36 @@ async function runStatus(opts) {
     const otherProjectIds = store.listOtherProjectIds(projectId);
     const otherProjectNodes = store.countProjectNodes(otherProjectIds);
     const structure = store.fileEdgeStats(projectId);
+    const staleCount = store.countStaleCandidates(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 ? `${pc18.yellow("stale   ")} ${otherProjectIds.length} prior project ${otherProjectIds.length === 1 ? "identity holds" : "identities hold"} ${otherProjectNodes} node(s) \u2014 run ${pc18.bold(
+    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(
       "nexusmem sync --prune-source <name>"
     )} to remove stale source data` : "";
     out(
       [
-        `${pc18.dim("repo    ")} ${repo.root}`,
-        `${pc18.dim("branch  ")} ${repo.branch ?? pc18.yellow("(detached)")}`,
-        `${pc18.dim("project ")} ${pc18.cyan(projectId)}`,
-        `${pc18.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc18.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
-        `${pc18.dim("database")} ${ws.dbPath} ${pc18.dim(`(${humanBytes(dbBytes)})`)}`,
+        `${pc19.dim("repo    ")} ${repo.root}`,
+        `${pc19.dim("branch  ")} ${repo.branch ?? pc19.yellow("(detached)")}`,
+        `${pc19.dim("project ")} ${pc19.cyan(projectId)}`,
+        `${pc19.dim("schema  ")} v${schema}${schema === LATEST_SCHEMA_VERSION ? "" : pc19.yellow(` (latest is v${LATEST_SCHEMA_VERSION})`)}`,
+        `${pc19.dim("database")} ${ws.dbPath} ${pc19.dim(`(${humanBytes(dbBytes)})`)}`,
         staleProjectWarning,
         "",
-        `${pc18.bold(String(stats2.total))} node(s)${stats2.total ? ` ${pc18.dim(`${stats2.oldest?.slice(0, 10)} .. ${stats2.newest?.slice(0, 10)}`)}` : ""}`,
+        `${pc19.bold(String(stats2.total))} node(s)${stats2.total ? ` ${pc19.dim(`${stats2.oldest?.slice(0, 10)} .. ${stats2.newest?.slice(0, 10)}`)}` : ""}`,
         ...kinds,
-        stats2.total ? `    ${pc18.dim(`${stats2.distinctFiles} distinct file path(s)`)}` : "",
+        stats2.total ? `    ${pc19.dim(`${stats2.distinctFiles} distinct file path(s)`)}` : "",
         "",
-        sources.length ? pc18.dim("sources") : pc18.yellow("no sources synced yet"),
+        sources.length ? pc19.dim("sources") : pc19.yellow("no sources synced yet"),
         ...sources.map((s) => {
           const when = s.lastRunAt ? new Date(s.lastRunAt).toISOString().slice(0, 16).replace("T", " ") : "never";
           const cursorLabel = s.source === "git" ? s.cursor?.slice(0, 7) ?? "-" : s.cursor ?? "-";
-          return `    ${s.source.padEnd(14)} ${pc18.dim(`last run ${when}`)}  ${pc18.dim(`cursor ${cursorLabel}`)}`;
+          return `    ${s.source.padEnd(14)} ${pc19.dim(`last run ${when}`)}  ${pc19.dim(`cursor ${cursorLabel}`)}`;
         }),
         "",
-        gitCursor && gitCursor !== repo.head ? `${pc18.yellow("git behind HEAD")} \u2014 run ${pc18.bold("nexusmem sync")}` : "",
-        chains.failuresTotal ? `${pc18.dim("chains  ")} ${pc18.bold(String(chains.resolvedTotal))}/${chains.failuresTotal} failure(s) resolved ${pc18.dim(`(${chains.resolvedByRetry} retry, ${chains.resolvedByDiscussion} discussion)`)}${chains.resolvedTotal < chains.failuresTotal ? ` \u2014 run ${pc18.bold("nexusmem sync --link-failures")} to link more` : ""}` : "",
-        structure.edges ? `${pc18.dim("structure")} ${pc18.bold(String(structure.edges))} import edge(s) across ${structure.files} file(s)` : ""
+        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")}` : ""
       ].filter((line) => line !== "").join("\n").concat("\n")
     );
     return 0;
@@ -5478,7 +6014,7 @@ function guard(run) {
       process.exitCode = await run();
     } catch (err) {
       if (isExpected(err)) {
-        process.stderr.write(`${pc19.red("error")} ${err.message}
+        process.stderr.write(`${pc20.red("error")} ${err.message}
 `);
         process.exitCode = 1;
         return;
@@ -5577,6 +6113,20 @@ 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(
+  "--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(
+  (options) => guard(
+    () => runStale({
+      cwd: options.cwd,
+      minAgeDays: options.minAgeDays,
+      limit: options.limit,
+      checkContradictions: options.checkContradictions,
+      model: options.model
+    })
+  )()
+);
 program.command("projects").description("List the repositories `query --all-projects` would search").option("--prune", "forget registered projects whose database is no longer on disk", false).option("--json", "emit the registry as JSON on stdout", false).action((options) => guard(() => runProjects({ prune: options.prune, json: options.json }))());
 program.command("scan-git").description("Preview the MemoryNodes git history would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--since <date>", "only commits newer than this git date expression, e.g. 90.days.ago").option("-n, --limit <count>", "stop after N commits", (v) => Number.parseInt(v, 10)).option("--no-merges", "skip merge commits").option("--min-signal <score>", "drop nodes below this signal", (v) => Number.parseFloat(v), 0).option("--json", "emit MemoryNodes as JSON on stdout", false).action(
   (options) => guard(
@@ -5633,11 +6183,11 @@ program.command("precheck").description("Warn about staged files with unresolved
     })
   )()
 );
-program.command("scan-structure").description("Preview the JS/TS import-graph edges a sync would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--json", "emit edges as JSON on stdout", false).action((options) => guard(() => runScanStructure({ cwd: options.cwd, json: options.json }))());
+program.command("scan-structure").description("Preview the JS/TS/Python/Go/Rust/Java/PHP import-graph edges a sync would produce (writes nothing)").option("-C, --cwd <path>", "repository path", process.cwd()).option("--json", "emit edges as JSON on stdout", false).action((options) => guard(() => runScanStructure({ cwd: options.cwd, json: options.json }))());
 program.command("mcp").description("Start the MCP server (stdio transport) for Claude Desktop, Cursor, Windsurf, etc.").action(() => guard(() => runMcpServer().then(() => 0))());
 program.parseAsync(process.argv).catch((err) => {
   const message = err instanceof Error ? err.message : String(err);
-  process.stderr.write(`${pc19.red("error")} ${message}
+  process.stderr.write(`${pc20.red("error")} ${message}
 `);
   process.exitCode = 1;
 });