ruvnet-brain 4.5.1 → 4.5.3

package/plugin/scripts/brain-confirmation.mjs

@@ -15,6 +15,7 @@ import crypto from 'node:crypto';
 import { cmpVersion, footprintRoots, physical } from './brain-footprint.mjs';
 import { readAll as readReadiness } from './mcp-readiness.mjs';
 import { volumeOf } from './brain-location.mjs';
+import { AUTO_UPDATE_LOCK_STALE_MS, autoUpdatePaths, newerCorpusPending } from './session-start-health.mjs';
 
 export const KNOWLEDGE_MAX_AGE_HOURS = 48;
 export const SIGNATURE_RECORD = 'knowledge-signature.json';
@@ -84,7 +85,7 @@ const line = (id, label, state, detail, fix = null) => ({ id, label, state, deta
  * @param installedVersion the package version the caller runs, used when no spine is active
  */
 export function confirm({ footprint, env = process.env, home = os.homedir(), now = Date.now(), npmLatest = null,
-  installedVersion = null, readiness = null } = {}) {
+  installedVersion = null, readiness = null, coverageIntegrity = null } = {}) {
   const roots = footprint?.roots || footprintRoots({ env, home });
   const lines = [];
   const active = readJson(path.join(roots.brainHome, 'active.json'));
@@ -135,12 +136,27 @@ export function confirm({ footprint, env = process.env, home = os.homedir(), now
   if (footprint.kbCopies !== 1) knowledgeProblems.push([`${footprint.kbCopies} copies on disk (must be exactly 1)`, footprint.kbCopyFix || (footprint.kbCopies ? CLEAN : 'npx ruvnet-brain@latest')]);
   if (!recorded) knowledgeAdvice.push([`installed or updated without a recorded signature verification — run ${UPDATE} to verify`, UPDATE]);
   else if (!signed) knowledgeProblems.push([signature ? 'signature record does not match the live COVERAGE.json' : 'signature record is unreadable', UPDATE]);
+  // The record binds COVERAGE.json's bytes only. The doctor passes the release-coverage check (every store's bytes
+  // against the release projection, ~0.3 s on a 1.4 GB KB): a projection that fails it is ✗; a directory without one
+  // (an older corpus) cannot be checked, and the line then claims only what the record proves (4.5.2).
+  const integrity = signed && coverageIntegrity ? coverageIntegrity(roots.kbDir) : null;
+  const checkable = Boolean(integrity) && fs.existsSync(path.join(roots.kbDir, 'CORPUS-COVERAGE.json'));
+  if (checkable && !integrity.valid) knowledgeProblems.push([`the bytes on disk fail the release-coverage check (${integrity.failures?.[0] || 'unknown'})`, UPDATE]);
+  // A newer corpus is published and not yet installed (identity, not age): advisory, never a gate.
+  const pending = newerCorpusPending({ source, corpusCheck: readJson(autoUpdatePaths(roots.brainHome).checkFile) });
+  if (pending) {
+    const lockAt = readJson(autoUpdatePaths(roots.brainHome).lockFile)?.at;
+    const running = Number.isFinite(Date.parse(lockAt || '')) && now - Date.parse(lockAt) < AUTO_UPDATE_LOCK_STALE_MS;
+    const short = pending.tag.length > 28 ? `${pending.tag.slice(0, 26)}…` : pending.tag;
+    knowledgeAdvice.push([`newer corpus ${short} published (checked ${iso(Date.parse(pending.checkedAt || ''))}); automatic update ${running ? 'running now' : 'pending'}`, UPDATE]);
+  }
   if (!Number.isFinite(builtMs) || (now - builtMs) / 3_600_000 >= KNOWLEDGE_MAX_AGE_HOURS) knowledgeAdvice.push([`built ${Number.isFinite(builtMs) ? ago(builtMs, now) : 'at an unknown time'} (limit ${KNOWLEDGE_MAX_AGE_HOURS}h)`, UPDATE]);
   const where = roots.location?.state === 'linked'
     ? `at ${roots.kbDir} (moved to ${volumeOf(roots.location.real)}, mounted)` : `at ${roots.kbDir}`;
   const moved = footprint.moveLeftovers || { copies: 0, bytes: 0 };
   const knowledgeDetail = [`${footprint.kbCopies} copy ${where}${moved.copies ? ` (not counted: ${moved.copies} interrupted-move cop${moved.copies === 1 ? 'y' : 'ies'} (${formatBytes(moved.bytes)}) — see the Move lines)` : ''}`, `built ${iso(builtMs)}${Number.isFinite(builtMs) ? ` (${ago(builtMs, now)})` : ''}`,
-    signed ? `signature verified ${iso(Date.parse(signature.verifiedAt))}` : 'signature NOT verified', `corpus ${tag ? (tag.length > 28 ? `${tag.slice(0, 26)}…` : tag) : 'unknown'}`].join(' · ');
+    !signed ? 'signature NOT verified' : integrity && !checkable ? `install record matches COVERAGE.json ${iso(Date.parse(signature.verifiedAt))}`
+      : `signature verified ${iso(Date.parse(signature.verifiedAt))}`, `corpus ${tag ? (tag.length > 28 ? `${tag.slice(0, 26)}…` : tag) : 'unknown'}`].join(' · ');
   const knowledgeIssues = [...knowledgeProblems, ...knowledgeAdvice];
   lines.push(line('knowledge', 'Knowledge', knowledgeProblems.length ? 'fail' : knowledgeAdvice.length ? 'warn' : 'ok',
     knowledgeIssues.length ? `${knowledgeDetail} — ${knowledgeIssues.map(([p]) => p).join('; ')}` : knowledgeDetail, knowledgeIssues[0]?.[1]));

package/plugin/scripts/brain-footprint.mjs

@@ -52,7 +52,8 @@ export const kbCopyPrefixes = (base) => [
   `${base}-pre-gap-rebuild-backup-`, `${base}.install-preserved-`, `${base}.install-prior-`,
   `${base}.pre-update-`, `${base}.next-`, `${base}.rollback-`, `${base}.failed-`,
 ];
-const TRANSACTION_KINDS = { next: 'candidate', rollback: 'rollback', failed: 'failed' };
+const BRAIN_BACKUP_STAMP = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}(?:-\d{3})?Z$/; // the updater's stamp(); other kb.bak-* are the customer's
+const TRANSACTION_KINDS ={ next: 'candidate', rollback: 'rollback', failed: 'failed' };
 export const LOG_FILES = Object.freeze(['evidence.jsonl', 'token-ledger.jsonl', 'detached-jobs.jsonl',
   'update-receipts.jsonl', 'gate-blocks.jsonl', 'distill-receipts.jsonl', 'assertion-gate-shadow.jsonl',
   'capability-live-evidence.jsonl', 'design-grades.jsonl', 'grounding-overrides.jsonl']);
@@ -184,6 +185,10 @@ export function inventoryFootprint({ env = process.env, home = os.homedir(), now
   const classifySibling = (name, full, st) => {
     {
       const prefix = kbCopyPrefixes(base).find((p) => name.startsWith(p));
+      if (prefix === `${base}.bak-` && !BRAIN_BACKUP_STAMP.test(name.slice(prefix.length))) {
+        return void add({ id: 'foreign', path: full, class: 'unowned', kind: 'hand-made-backup', action: 'report', bytes: bytes(full),
+          reason: 'a hand-made KB backup (not the Brain\'s own kb.bak-<stamp> name): reported, never deleted' });
+      }
       if (prefix) {
         if (st.isSymbolicLink() || !st.isDirectory()) { add({ id: 'kb-copy', path: full, class: 'unowned', kind: 'kb-copy-link', action: 'report', reason: 'a link or file under a KB-copy name; never followed or removed' }); return; }
         const kind = Object.entries(TRANSACTION_KINDS).find(([k]) => prefix === `${base}.${k}-`)?.[1] || null;
@@ -392,10 +397,10 @@ function summarize({ roots, items, policy, kbCopyDirs, lockHeld }) {
     breakdown[group] = (breakdown[group] || 0) + (i.bytes || 0);
   }
   const cruft = items.filter((i) => i.class === 'must-not-exist');
-  // When every extra KB copy is one no command can remove, the copy-count fix is the honest remedy, not --clean.
-  const extra = items.filter((i) => i.kind === 'kb-copy' || i.kind === 'quarantine');
-  const onlyCopy = items.find((i) => i.kind === 'move-leftover' && i.onlyCopy);
-  const kbCopyFix = onlyCopy ? onlyCopy.fix : extra.length && extra.every((i) => i.keptUnique) ? extra[0].fix : null;
+  // Every extra copy unremovable → its own fix, not --clean; all owned by an update transaction → --update (4.5.2).
+  const extra = items.filter((i) => i.kind === 'kb-copy' || i.kind === 'quarantine'), onlyCopy = items.find((i) => i.kind === 'move-leftover' && i.onlyCopy);
+  const inTransaction = items.some((i) => /^transaction-/.test(i.kind)), kbCopyFix = onlyCopy ? onlyCopy.fix : extra.length && extra.every((i) => i.keptUnique) ? extra[0].fix
+    : !extra.length && inTransaction ? 'npx ruvnet-brain@latest --update' : null;
   const moved = items.filter((i) => i.kind === 'move-leftover');
   return { schemaVersion: 1, kind: 'ruvnet-brain-footprint', roots, items, policy, lockHeld, kbCopyFix,
     liveKb: items.find((i) => i.kind === 'live-kb'),

package/plugin/scripts/continuity-journal.mjs

@@ -26,7 +26,8 @@
  *   • BOUNDED. A failure is ONE record per event (attempt count, last error), never a line per attempt;
  *     compact() rewrites the file atomically (lock + size re-check, so a concurrent append is never
  *     lost): committed events older than RETAIN_COMMITTED_MS leave (the store keeps them and dedupes),
- *     corrupt lines become one notice, and a hard cap of MAX_EVENT_RECORDS drops the oldest, reported.
+ *     corrupt lines become one notice; MAX_EVENT_RECORDS bounds committed history, never pending events.
+ *     A prolonged outage can grow the pending file beyond that soft cap; status reports capacity pressure.
  */
 import fs from 'node:fs';
 import os from 'node:os';
@@ -54,7 +55,7 @@ export const STUCK_AFTER_MS = 10 * 60_000;
 export const QUARANTINE_REPORT_MS = 7 * 86_400_000;
 export const RETAIN_COMMITTED_MS = 7 * 86_400_000;
 export const MAX_EVENT_RECORDS = 2_000;
-const [COMPACT_AT_BYTES, LOCK_STALE_MS, APPEND_LOCK_WAIT_MS, APPEND_LOCK_STALE_MS] = [256 * 1024, 3 * 60_000, 1_000, 30_000];
+const [LOCK_STALE_MS, APPEND_LOCK_WAIT_MS, APPEND_LOCK_STALE_MS] = [3 * 60_000, 1_000, 30_000];
 const WAL_REFUSAL = /refusing an unsafe sql\.js|active native WAL|database is locked|SQLITE_BUSY/i;
 export const CLEAR_COMMAND = `node "${path.join(path.dirname(fileURLToPath(import.meta.url)), 'continuity-brief.mjs')}" --clear`;
 
@@ -192,11 +193,14 @@ export class ContinuityJournal {
   /** Does the file carry anything compact() would remove? (cheap: from one scan) */
   needsCompaction(scan = this.scan()) {
     const now = this.now();
-    if (scan.corrupt || scan.bytes > COMPACT_AT_BYTES || scan.events.size > MAX_EVENT_RECORDS) return true;
+    if (scan.corrupt) return true;
     const failureLines = scan.lines - scan.events.size - scan.committed.size - scan.quarantined.size - scan.notices.length - (scan.clearedAt ? 1 : 0) - scan.corrupt;
     if (failureLines > scan.failures.size) return true;
     for (const c of scan.committed.values()) if (now - ms(c.committedAt) > RETAIN_COMMITTED_MS) return true;
-    return false;
+    if (scan.notices.some((n) => now - ms(n.at) > QUARANTINE_REPORT_MS || ms(n.at) <= scan.clearedAt)) return true;
+    if ([...scan.quarantined.values()].some((q) => now - ms(q.at) > QUARANTINE_REPORT_MS)) return true;
+    // An unshrinkable pending backlog must not be rewritten on every capture boundary.
+    return scan.events.size > MAX_EVENT_RECORDS && [...scan.events.keys()].some((key) => scan.committed.has(key));
   }
 
   /**
@@ -210,7 +214,6 @@ export class ContinuityJournal {
       try { before = fs.statSync(this.path); } catch { return { compacted: false, reason: 'no outbox' }; }
       const scan = this.scan();
       const out = [];
-      let dropped = 0;
       const quarantineLive = (q) => now - ms(q.at) <= QUARANTINE_REPORT_MS;
       const keep = [...scan.events.values()].filter((rec) => {
         const c = scan.committed.get(rec.key);
@@ -218,16 +221,9 @@ export class ContinuityJournal {
         const q = scan.quarantined.get(rec.key);
         return q ? quarantineLive(q) : true;
       }).sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
-      // The hard cap: committed events go first (the store holds them), then the oldest pending.
-      let over = keep.length - MAX_EVENT_RECORDS;
-      if (over > 0) {
-        const committedFirst = keep.filter((r) => scan.committed.has(r.key)).slice(0, over);
-        over -= committedFirst.length;
-        const pendingDrop = over > 0 ? keep.filter((r) => !scan.committed.has(r.key)).slice(0, over) : [];
-        dropped = pendingDrop.length;
-        const gone = new Set([...committedFirst, ...pendingDrop]);
-        keep.splice(0, keep.length, ...keep.filter((r) => !gone.has(r)));
-      }
+      // Only read-back committed events may leave at the cap. Pending bytes are the recovery copy.
+      const gone = new Set(keep.filter((r) => scan.committed.has(r.key)).slice(0, Math.max(0, keep.length - MAX_EVENT_RECORDS)));
+      keep.splice(0, keep.length, ...keep.filter((r) => !gone.has(r)));
       const kept = new Set(keep.map((r) => r.key));
       for (const rec of keep) {
         out.push(rec);
@@ -241,8 +237,8 @@ export class ContinuityJournal {
         notice.corrupt += Number(n.corrupt) || 0; notice.dropped += Number(n.dropped) || 0;
         notice.at = notice.at && notice.at < n.at ? notice.at : n.at;
       }
-      if (scan.corrupt || dropped) {
-        notice.corrupt += scan.corrupt; notice.dropped += dropped;
+      if (scan.corrupt) {
+        notice.corrupt += scan.corrupt;
         notice.at = notice.at || new Date(now).toISOString();
       }
       if (notice.corrupt || notice.dropped) out.push({ type: 'notice', ...notice });
@@ -258,7 +254,7 @@ export class ContinuityJournal {
         return { compacted: false, reason: 'the outbox changed during compaction; left as is' };
       }
       fs.renameSync(tmp, this.path);
-      return { compacted: true, lines: out.length, kept: kept.size, dropped };
+      return { compacted: true, lines: out.length, kept: kept.size, dropped: 0 };
     });
   }
 
@@ -279,14 +275,15 @@ export class ContinuityJournal {
     const ready = storeReady(this.db);
     const notApplicable = !ready ? 'no AgentDB store in this project (.swarm/memory.db is not initialized)'
       : !this.ruflo ? 'ruflo is not installed' : null;
+    const capacityPressure = pending.length > MAX_EVENT_RECORDS;
     const problem = quarantined.length ? 'quarantined' : corrupt ? 'corrupt' : dropped ? 'dropped'
-      : !notApplicable && oldest !== null && now - oldest > STUCK_AFTER_MS ? 'stuck-pending' : null;
+      : !notApplicable && capacityPressure ? 'capacity-pressure' : !notApplicable && oldest !== null && now - oldest > STUCK_AFTER_MS ? 'stuck-pending' : null;
     return {
       outbox: this.path, db: this.db, storeReady: ready, rufloPresent: Boolean(this.ruflo),
       applicable: !notApplicable, notApplicable,
       pending: pending.length, oldestPendingAt: oldest, lastCommitAt, eventsToday,
       lastFailure: lastFailure && (!lastCommitAt || ms(lastFailure.at) > lastCommitAt) ? lastFailure : null,
-      quarantined, corrupt, dropped, problem, stuck: Boolean(problem),
+      quarantined, corrupt, dropped, capacityPressure, problem, stuck: Boolean(problem),
     };
   }
 }
@@ -301,12 +298,14 @@ export function recordingLine(status, now = Date.now()) {
     const why = status.problem === 'quarantined' ? `${status.quarantined.length} quarantined (a different row holds its key; never retried — ${clears})`
       : status.problem === 'corrupt' ? `${status.corrupt} corrupt outbox line(s) removed (${clears})`
         : status.problem === 'dropped' ? `${status.dropped} uncommitted event(s) dropped at the outbox cap (${clears})`
+          : status.problem === 'capacity-pressure' ? `pending backlog exceeds soft limit ${MAX_EVENT_RECORDS}; no pending events discarded`
           : status.lastFailure ? `last error: ${status.lastFailure.reason || status.lastFailure.error}` : 'not committing';
     return `AgentDB: recording stuck — ${status.pending} event(s) pending${status.oldestPendingAt && status.problem === 'stuck-pending' ? ` for ${ago(now - status.oldestPendingAt)}` : ''}, ${why}.`
       + ` Pending events are durable in ${status.outbox} and retry at every capture boundary.`;
   }
   if (status.notApplicable) {
-    return `AgentDB: recording n/a — ${status.notApplicable}; ${status.pending} event(s) wait in the outbox (not a failure).`;
+    return `AgentDB: recording n/a — ${status.notApplicable}; ${status.pending} event(s) wait in the outbox (not a failure).`
+      + (status.capacityPressure ? ` Capacity pressure: pending backlog exceeds soft limit ${MAX_EVENT_RECORDS}; no pending events discarded.` : '');
   }
   // ✓ only on evidence: a committed, read-back event. "Nothing failed yet" is not proof of recording.
   if (!status.lastCommitAt) return `AgentDB: recording not yet proven — no event committed and read back yet (outbox ${status.pending} pending)`;

package/plugin/scripts/footprint-io.mjs

@@ -77,8 +77,8 @@ export function findMoveLeftovers({ brainHome, location = null, isAlive = pidAli
 // has no control character (or, on Windows, no double quote); otherwise the advice is to inspect it by hand.
 const shQuote = (p) => `'${String(p).replace(/'/g, `'\\''`)}'`;
 const COMMANDS = {
-  posix: { rmTree: (p) => `rm -rf -- ${shQuote(p)}`, rmLink: (p) => `rm -- ${shQuote(p)}`, mv: (a, b) => `mv -- ${shQuote(a)} ${shQuote(b)}` },
-  win32: { rmTree: (p) => `rmdir /s /q "${p}"`, rmLink: (p) => `rmdir "${p}"`, mv: (a, b) => `move "${a}" "${b}"` },
+  posix: { rmTree: (p) => `rm -rf -- ${shQuote(p)}`, rmLink: (p) => `rm -- ${shQuote(p)}`, mv: (a, b) => `mv -- ${shQuote(a)} ${shQuote(b)}`, rmdir: (p) => `rmdir -- ${shQuote(p)}` },
+  win32: { rmTree: (p) => `rmdir /s /q "${p}"`, rmLink: (p) => `rmdir "${p}"`, mv: (a, b) => `move "${a}" "${b}"`, rmdir: (p) => `rmdir "${p}"` },
 };
 const holdsBrain = (dir) => ['SOURCE.json', path.join('kb', 'SOURCE.json')].some((f) => Boolean(lstat(path.join(dir, f))));
 
@@ -93,7 +93,11 @@ export function assessMoveLeftovers({ brainHome, location = null, isAlive = pidA
   const safe = (p, dir) => physical(path.dirname(p)) === physical(dir) && !/[\u0000-\u001f\u007f]/.test(p)
     && !(platform === 'win32' && p.includes('"')) && !/[\u0000-\u001f\u007f]/.test(brainHome);
   const inspect = (p) => `inspect it by hand: ${JSON.stringify(p)} (no command is suggested for this path)`;
-  const homeMissing = !lstat(brainHome);
+  // A real directory with no Brain in it counts as missing: a hook or the search server recreates the home on a
+  // failure path (health.json, a notice file) after an interrupted move (4.5.2). A link is judged by `location`.
+  const homeSt = lstat(brainHome);
+  const homeMissing = !homeSt || (!homeSt.isSymbolicLink() && !holdsBrain(brainHome));
+  const homeEmpty = Boolean(homeSt) && homeMissing && !names(brainHome).length;
   const found = findMoveLeftovers({ brainHome, location, isAlive }).map((lo) => {
     const link = Boolean(lstat(lo.path)?.isSymbolicLink());
     let target = null;
@@ -104,7 +108,10 @@ export function assessMoveLeftovers({ brainHome, location = null, isAlive = pidA
   const restore = homeMissing ? found.filter((f) => f.brain).sort((a, b) => order.indexOf(a.what) - order.indexOf(b.what))[0] : null;
   return found.map((f) => {
     const ok = safe(f.path, f.dir);
-    if (f === restore) return { ...f, onlyCopy: true, fix: ok ? cmd.mv(f.path, brainHome) : inspect(f.path) };
+    // The recreated home is cleared out of the way first: removed if empty (rmdir refuses anything else), set aside
+    // under a name of its own otherwise — never deleted with its contents, and the leftover is never deleted.
+    const clear = !homeSt ? null : homeEmpty ? cmd.rmdir(brainHome) : cmd.mv(brainHome, `${brainHome}.recreated-${f.pid}`);
+    if (f === restore) return { ...f, onlyCopy: true, fix: ok ? [clear, cmd.mv(f.path, brainHome)].filter(Boolean).join(' && ') : inspect(f.path) };
     if (restore) return { ...f, onlyCopy: false, fix: `keep it until the Brain is restored at ${JSON.stringify(brainHome)} and --doctor is green` };
     return { ...f, onlyCopy: false, fix: ok ? (f.link ? cmd.rmLink(f.path) : cmd.rmTree(f.path)) : inspect(f.path) };
   });

package/plugin/scripts/ground-ruvnet.sh

@@ -67,6 +67,13 @@ if printf '%s' "$TEXT" | grep -qiE '\[Your previous response|\[Request interrupt
   exit 0
 fi
 
+# Read canonical memory before the quiet path; useful evidence may exist even
+# for a worktree with no local .swarm. Acks/off/no-match keep the cheap return.
+_ADB_OUT=""
+if [ "${RUVNET_AGENTDB_FIRST:-on}" != "off" ]; then
+  _ADB_OUT=$(printf '%s' "$INPUT" | "${RUVNET_NODE_BIN:-node}" "$(dirname "$0")/agentdb-recall.mjs" 2>/dev/null)
+fi
+
 # ── QUIET-PROMPT FAST PATH. ────────────────────────────────────────────────────────────────────
 # A hook whose output contract is silence must not pay the full stack-currency/project-state scan
 # before discovering that nothing can fire. This mattered on a packed Windows install: immediately
@@ -83,7 +90,7 @@ QUICK_RELEVANT=0
 if printf '%s' "$TEXT" | grep -qiE 'ruvnet|ruflo|ruvector|rvf|agentdb|agenticow|rulake|ruview|rupixel|ruv-fann|agentic-flow|synthlang|dspy|qudag|safla|metaharness|cve-bench|sparc|swarm|claude-flow|pinecone|pgvector|chroma|weaviate|faiss|milvus|qdrant|hnswlib|annoy|vector|langchain|llama|autogen|crew-ai|semantic-kernel|embedding|retrieval|prompt compression|token cost|post-quantum|quantum-resistant|adr|decision|architect|design|plan|spec|refactor|migrat|implement|build|write|add|change|fix|update|deploy|create|enhance|set up|setup|wire|integrate|test|coverage|audit|review|benchmark|lint|scan|debug|optimi|app|feature|service|system|backend|frontend|api|module|pipeline|infra|database|schema|workflow|roadmap|milestone|autonomous|unattended|do not stop|keep working|keep going|soak run|harness|quality|readiness|evolve|self-improv|hardening|cheaper|cheap|lower cost|compute arbitrage|cascade|scorecard|score .*repo'; then
   QUICK_RELEVANT=1
 fi
-if [ "$QUICK_RUFLO" -eq 0 ] && [ "$QUICK_RELEVANT" -eq 0 ] && [ "${RUVNET_AUTONOMOUS:-0}" != "1" ]; then
+if [ "$QUICK_RUFLO" -eq 0 ] && [ "$QUICK_RELEVANT" -eq 0 ] && [ "${RUVNET_AUTONOMOUS:-0}" != "1" ] && [ -z "$_ADB_OUT" ]; then
   exit 0
 fi
 
@@ -138,6 +145,13 @@ inj_seen() {
 }
 inj_mark() { [ -n "$INJ_DIR" ] && mkdir -p "$INJ_DIR" 2>/dev/null && : > "$INJ_DIR/$1" 2>/dev/null; return 0; }
 
+# ── Canonical AgentDB recall (ADR-101): every nontrivial human prompt. ──────────────
+# Priority 0 and digest dedupe preserve safety output and avoid re-sending evidence.
+if [ -n "$_ADB_OUT" ]; then
+  _ADB_ID=$(printf '%s\n' "$_ADB_OUT" | head -n 1 | tr -cd 'A-Za-z0-9' | cut -c1-12)
+  [ -n "$_ADB_ID" ] && printf '%s\n' "$_ADB_OUT" | sed '1d' | out_to "0-0-agentdb-recall-$_ADB_ID"
+fi
+
 # ── Gate 0: STACK WATCHDOG (always fires) — filesystem ground truth, not impressions. ───────────
 # Runs in the project's cwd every prompt, FROM the loaded plugin's own dir — so $CLAUDE_PLUGIN_ROOT
 # is the RUNNING (in-memory) version by construction, never the staged disk copy. Checks what's

package/plugin/scripts/host-update.mjs

@@ -37,7 +37,8 @@ if (process.argv.includes('--check')) {
 
 const npx = process.platform === 'win32' ? 'npx.cmd' : 'npx';
 
-// --knowledge <attemptFile> <lockFile>: the SessionStart knowledge self-heal worker (launched by
+// --knowledge <attemptFile> <lockFile> [--if-newer <kbDir> <checkFile> <resultFile>]: the SessionStart
+// (and MCP server timer) knowledge self-heal worker (launched by
 // session-start-update-plane.mjs under detach.mjs's TTL). Unlike the default mode below it DOES
 // update knowledge: the same argv bin/nightly-refresh.mjs runs, through the same env boundary.
 // Offline (registry unreachable) is recorded as 'offline' so the next session retries in 30 min
@@ -56,6 +57,61 @@ if (knowledgeAt >= 0) {
     } catch { /* the next session reports a launch with no outcome as a failure */ }
   };
   try {
+    // --if-newer <kbDir> <checkFile> <resultFile>: the newer-published identity check (2026-10-02). Run the
+    // INSTALLED updater's --check (one GET of the canonical releases/latest pointer, no download) and only a
+    // newer identity proceeds to the update below. Exit codes are forge-update.mjs's own: 0 current (or
+    // REFUSED: the published corpus is older — never downgrade), 10 newer, 2 network, 5 incompatible.
+    const ifNewerAt = process.argv.indexOf('--if-newer');
+    if (ifNewerAt >= 0) {
+      const path = await import('node:path');
+      const [kbDir, checkFile, resultFile] = process.argv.slice(ifNewerAt + 1);
+      const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+      const note = (fields) => {
+        try {
+          const tmp = `${checkFile}.tmp-${process.pid}`;
+          fs.writeFileSync(tmp, `${JSON.stringify({ ...(readJson(checkFile) || {}), schemaVersion: 1, ...fields, checkedAt: new Date().toISOString() })}\n`);
+          fs.renameSync(tmp, checkFile);
+        } catch { /* the next tick re-checks */ }
+      };
+      // process.exit() skips finally{}, so every early stop releases the shared lock itself.
+      const stop = () => { try { fs.rmSync(lockFile, { force: true }); } catch { /* stale-lock rule reclaims it */ } process.exit(0); };
+      const started = Date.now();
+      const check = spawnSync(process.execPath, [path.join(kbDir, 'forge-update.mjs'), '--check', '--result-file', resultFile], {
+        env: childEnvironment(), encoding: 'utf8', timeout: Number(process.env.RUVNET_CORPUS_CHECK_TIMEOUT_MS || 90_000),
+      });
+      const out = `${check.stdout || ''}\n${check.stderr || ''}`;
+      const result = readJson(resultFile);
+      const fresh = result && Date.parse(result.recordedAt || '') >= started - 1000 ? result : null;
+      const candidateTag = fresh?.candidateTag || /canonical built:\s+(\S+)/.exec(out)?.[1] || null;
+      const verdict = fresh?.currencyVerdict || /currency verdict:\s+([A-Z_]+)/.exec(out)?.[1] || null;
+      const reason = (out.split('\n').map((l) => l.trim()).filter(Boolean).find((l) => /error|refus|incompatible|fail/i.test(l)) || '').slice(0, 200);
+      // Decide by the recorded IDENTITY verdict whenever this run wrote one; the exit code only when it did
+      // not (a network failure or an incompatible release dies before recording). Measured against the real
+      // API: an install whose profile selects no stores exits 0 on UPDATE_AVAILABLE ("All stores current").
+      const newer = verdict ? ['UPDATE_AVAILABLE', 'UNKNOWN'].includes(verdict) : check.status === 10;
+      if (!newer && (verdict || check.status === 0)) {
+        note({ outcome: verdict === 'REFUSED' ? 'refused' : 'current', verdict: verdict || 'CURRENT', candidateTag, reason: '' });
+        stop();
+      }
+      if (!newer) {
+        note({ outcome: check.status === 2 ? 'offline' : check.status === 5 ? 'incompatible' : 'failed',
+          verdict: null, candidateTag, reason: reason || `check exited ${check.error ? check.error.message : check.status}` });
+        stop();
+      }
+      // Newer. Loop guard: the same target already "succeeded" within 6h yet is still not installed — do
+      // not download it again every hour; a DIFFERENT newer corpus proceeds at once.
+      const prior = readJson(attemptFile);
+      if (prior?.outcome === 'succeeded' && candidateTag && prior.targetTag === candidateTag
+        && Date.now() - Date.parse(prior.launchedAt || '') < 6 * 3_600_000) {
+        note({ outcome: 'not-converged', verdict, candidateTag, reason: 'the last automatic update to this corpus finished without installing it' });
+        stop();
+      }
+      note({ outcome: 'updating', verdict, candidateTag, reason: '' });
+      const tmp = `${attemptFile}.tmp-${process.pid}`;
+      fs.writeFileSync(tmp, `${JSON.stringify({ schemaVersion: 1, launchedAt: new Date().toISOString(), outcome: 'launched',
+        trigger: 'newer-corpus-published', targetTag: candidateTag })}\n`);
+      fs.renameSync(tmp, attemptFile);
+    }
     const probe = process.env.RUVNET_AUTO_UPDATE_PROBE_URL || 'https://registry.npmjs.org/ruvnet-brain/latest';
     let online = false;
     try { online = (await fetch(probe, { signal: AbortSignal.timeout(5_000) })).ok; } catch { /* offline */ }

package/plugin/scripts/project-progression-outbox.mjs

@@ -23,10 +23,22 @@ export class ProgressionOutbox {
   appendRecord(record) {
     fs.mkdirSync(path.dirname(this.path), { recursive: true, mode: 0o700 });
     const noFollow = fs.constants.O_NOFOLLOW ?? 0;
-    const fd = fs.openSync(this.path, fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_WRONLY | noFollow, 0o600);
+    const fd = fs.openSync(this.path, fs.constants.O_APPEND | fs.constants.O_CREAT | fs.constants.O_RDWR | noFollow, 0o600);
     try {
+      let separator = '';
+      const size = fs.fstatSync(fd).size;
+      if (size) {
+        const last = Buffer.alloc(1);
+        fs.readSync(fd, last, 0, 1, size - 1);
+        if (last[0] !== 10) {
+          const content = fs.readFileSync(fd, 'utf8');
+          try { JSON.parse(content.slice(content.lastIndexOf('\n') + 1)); }
+          catch { throw new Error('incomplete outbox final record; preserve and recover the torn tail before appending'); }
+          separator = '\n';
+        }
+      }
       fs.fchmodSync(fd, 0o600);
-      writeAll(fd, `${JSON.stringify(record)}\n`);
+      writeAll(fd, `${separator}${JSON.stringify(record)}\n`);
       this.fsync(fd);
     } finally {
       fs.closeSync(fd);
@@ -58,8 +70,11 @@ export class ProgressionOutbox {
     if (!fs.existsSync(this.path)) return [];
     const content = fs.readFileSync(this.path, 'utf8');
     const lines = content.split('\n');
-    if (lines.at(-1) !== '') lines.pop();
-    else lines.pop();
+    if (lines.at(-1) === '') lines.pop();
+    else {
+      // A missing delimiter is not a missing record; only a crash-torn JSON suffix is incomplete.
+      try { JSON.parse(lines.at(-1)); } catch { lines.pop(); }
+    }
     return lines.filter(Boolean).map((line, index) => {
       try { return JSON.parse(line); } catch { throw new Error(`malformed outbox record at line ${index + 1}`); }
     });

package/plugin/scripts/project-store-resolver.mjs

@@ -40,21 +40,24 @@ function isWithin(root, candidate) {
   return relative === '' || (!path.isAbsolute(relative) && relative !== '..' && !relative.startsWith(`..${path.sep}`));
 }
 
-function gitValue(cwd, args) {
+function gitValue(cwd, args, gitTimeoutMs) {
   try {
     return execFileSync('git', args, {
       cwd,
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],
+      ...(gitTimeoutMs ? { timeout: gitTimeoutMs, killSignal: 'SIGKILL' } : {}),
     }).trim();
-  } catch {
+  } catch (error) {
+    // A timed-out Git identity check is not evidence for a non-git project.
+    if (error.code === 'ETIMEDOUT') throw new Error('Git project identity timed out');
     return null;
   }
 }
 
-function gitProject(projectDir) {
-  const commonValue = gitValue(projectDir, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
-  const checkoutValue = gitValue(projectDir, ['rev-parse', '--show-toplevel']);
+function gitProject(projectDir, gitTimeoutMs) {
+  const commonValue = gitValue(projectDir, ['rev-parse', '--path-format=absolute', '--git-common-dir'], gitTimeoutMs);
+  const checkoutValue = gitValue(projectDir, ['rev-parse', '--show-toplevel'], gitTimeoutMs);
   if (!commonValue || !checkoutValue) return null;
   const gitCommonDir = canonicalDirectory(commonValue, 'Git common directory');
   const checkoutRoot = canonicalDirectory(checkoutValue, 'Git checkout root');
@@ -68,9 +71,10 @@ function gitProject(projectDir) {
   };
 }
 
-export function resolveProjectStore({ projectDir = process.cwd(), requestedStorePath } = {}) {
+export function resolveProjectStore({ projectDir = process.cwd(), requestedStorePath, gitTimeoutMs } = {}) {
   const canonicalInput = canonicalDirectory(projectDir, 'projectDir');
-  const git = gitProject(canonicalInput);
+  if (gitTimeoutMs !== undefined && (!Number.isSafeInteger(gitTimeoutMs) || gitTimeoutMs <= 0)) throw new TypeError('gitTimeoutMs must be a positive integer');
+  const git = gitProject(canonicalInput, gitTimeoutMs);
   const resolved = git ?? {
     gitCommonDir: null,
     checkoutRoot: canonicalInput,
@@ -82,6 +86,11 @@ export function resolveProjectStore({ projectDir = process.cwd(), requestedStore
   if (!isWithin(resolved.projectRoot, resolvedAgentDbPath)) {
     throw new Error('store symlink escape rejected');
   }
+  // A hard link passes every path check yet writes into a foreign inode (ADR-0102 G-053, measured: the
+  // Stop boundary's progression/continuity writers changed a hard-linked foreign store).
+  let storeStat = null;
+  try { storeStat = fs.statSync(resolvedAgentDbPath); } catch { /* not created yet */ }
+  if (storeStat && storeStat.nlink > 1) throw new Error('store hard link rejected');
   if (requestedStorePath !== undefined) {
     if (typeof requestedStorePath !== 'string' || !requestedStorePath.trim()) {
       throw new TypeError('requestedStorePath must be a non-empty path');

package/plugin/scripts/session-snapshot-hook.mjs

@@ -129,8 +129,8 @@ export function runSessionSnapshotHook(projectDir, event, {
   const metadataWritten = writeMetadata ? writeSessionSnapshot(projectDir, event) : false;
   let payload;
   try { payload = rawInput ? JSON.parse(rawInput) : {}; } catch { payload = {}; }
-  // TURN OUTCOMES FIRST, and independent of `.swarm`: every turn in every repository is recorded
-  // (a project without `.swarm` records to the machine-wide db outside it — turn-outcome-capture.mjs).
+  // TURN OUTCOMES FIRST: consent and canonical store availability govern whether a turn is queued
+  // (a project without a store requires persisted opt-in — turn-outcome-capture.mjs).
   // It only reads and spawns a detached writer, so it costs the progression budget below nothing.
   let turn;
   try { turn = captureTurn({ projectDir, event, payload, host }); } catch (error) {

package/plugin/scripts/session-start-core.mjs

@@ -27,6 +27,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { restoreWithBrief } from './continuity-brief.mjs';
+import { turnRecordingStatus } from './turn-outcome-capture.mjs';
 import {
   read, json, exists, mkdir, write, runNode,
 } from './session-start-fsutil.mjs';
@@ -120,6 +121,7 @@ export async function runSessionStart({
       || s.startsWith('[RuvNet Brain v')
       || s.startsWith('USER-LEVEL:')
       || s.startsWith('[ASCII→SVG]')
+      || s.startsWith('[RuvNet Brain — TURN RECORDING]')
       || s.startsWith('[RuvNet Brain — PROJECT CONTINUITY UNKNOWN]')
       || s.startsWith('[RuvNet Brain — PROJECT CONTINUITY RESTORED]')
       || s.startsWith('[RuvNet Brain — COME UP TO SPEED')
@@ -183,6 +185,9 @@ export async function runSessionStart({
     emit('[RuvNet Brain — PROJECT CONTINUITY UNKNOWN]');
     emit('The SessionStart restore boundary failed unexpectedly. Do not claim project state was restored; verify the canonical store before relying on remembered state.');
   }
+  // Turn health remains visible even when the separate progression restore fails.
+  const turnStatus = turnRecordingStatus({ projectDir: cwd, env, home });
+  if (turnStatus.state === 'warn') emit(`[RuvNet Brain — TURN RECORDING] ${turnStatus.line}`);
   // Opt-in, matching the pre-existing `trace()` convention below: several other tests assert
   // SessionStart's stderr is EMPTY in the clean case (hook-battery.test.mjs, hook-hardening.test.mjs
   // — a real contract, not incidental), so this must never write unconditionally. `restore` shares

package/plugin/scripts/session-start-health.mjs

@@ -12,6 +12,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { json, exists, mtimeMs, read } from './session-start-fsutil.mjs';
 import { unmountedNotice } from './brain-location.mjs';
+import { assessMoveLeftovers } from './footprint-io.mjs';
 import {
   describeFailedRefreshRun, readNightlyRegistration, refreshHistory, updateOwnedByAgenticKit,
 } from './nightly-scheduler.mjs';
@@ -33,6 +34,15 @@ export const brainState = (env, home) => {
   return { off, since, stateDir, file };
 };
 
+// An interrupted --move-brain may hold the ONLY Brain at <home>.old-<pid>: "reinstall" there would build a
+// second, public-only Brain beside it (4.5.2). Names only; consulted only when the KB is missing or empty.
+const restoreNotice = (home) => {
+  try {
+    const lo = assessMoveLeftovers({ brainHome: path.join(home, '.cache', 'ruvnet-brain') }).find((l) => l.onlyCopy);
+    return lo ? `the Brain is not at its path — an interrupted move left the ONLY copy at ${lo.path}; restore it, do NOT reinstall: ${lo.fix}` : '';
+  } catch { return ''; }
+};
+
 export const health = (home, off) => {
   // Moved to another disk that is not plugged in: say exactly that — not "MISSING, reinstall", which
   // would re-create a fresh brain in ~/.cache over the link. A problem also stands the self-heal down.
@@ -45,8 +55,8 @@ export const health = (home, off) => {
   catch { /* absent */ }
   const absentByChoice = off && (!exists(kb) || !rvf);
   if (absentByChoice) return { problem: '', absentByChoice };
-  if (!exists(kb)) return { problem: `the brain cache directory is MISSING (${kb}) — reinstall: npx github:stuinfla/ruvnet-brain`, absentByChoice };
-  if (!rvf) return { problem: `NO vector stores (.rvf) found in ${kb} — the brain is empty; reinstall: npx github:stuinfla/ruvnet-brain --force`, absentByChoice };
+  if (!exists(kb)) return { problem: restoreNotice(home) || `the brain cache directory is MISSING (${kb}) — reinstall: npx github:stuinfla/ruvnet-brain`, absentByChoice };
+  if (!rvf) return { problem: restoreNotice(home) || `NO vector stores (.rvf) found in ${kb} — the brain is empty; reinstall: npx github:stuinfla/ruvnet-brain --force`, absentByChoice };
   if (!exists(path.join(kb, 'node_modules', '@xenova', 'transformers', 'package.json'))) {
     return { problem: `reader dependencies are MISSING (node_modules gone) — every search WILL fail. Fix: cd ${kb} && npm i`, absentByChoice };
   }
@@ -78,6 +88,10 @@ export const autoUpdatePaths = (brainHome) => ({
   attemptFile: path.join(brainHome, 'auto-update.json'),
   lockFile: path.join(brainHome, 'auto-update.lock'),
   logFile: path.join(brainHome, '.last-auto-update-knowledge.log'),
+  // The newer-published identity check (2026-10-02): its own throttle + outcome record, never the update
+  // attempt file (a check is not an update; it must not reset the 6h retry or read as an abandoned launch).
+  checkFile: path.join(brainHome, 'corpus-check.json'),
+  checkResultFile: path.join(brainHome, '.last-kb-check-result.json'),
 });
 export const AUTO_UPDATE_LOCK_STALE_MS = 35 * 60_000; // detach TTL (30 min) + slack
 
@@ -95,7 +109,7 @@ export const knowledgeFacts = ({ env = process.env, home, now = Date.now() } = {
   const provenWithin = (h) => Boolean((history.lastSuccess && hours(history.lastSuccess.at) <= h)
     || (check?.currencyVerdict === 'CURRENT' && Number.isFinite(checkMs) && hours(checkMs) <= h));
   return { brainHome, kbDir, source, builtMs, history, hours, provenWithin, auto,
-    attempt: json(auto.attemptFile),
+    attempt: json(auto.attemptFile), corpusCheck: json(auto.checkFile),
     lockMs: Date.parse(json(auto.lockFile)?.at || '') || mtimeMs(auto.lockFile) };
 };
 
@@ -126,6 +140,21 @@ export const autoUpdateOptOut = ({ env = process.env, home, facts }) => {
   return '';
 };
 
+/**
+ * A newer corpus is PUBLISHED and not yet installed — decided by identity, never by age: the last
+ * recorded --if-newer check found a release whose tag is newer (UPDATE_AVAILABLE, or UNKNOWN when the
+ * installed tree carries no generation stamp) and that tag is not what SOURCE.json now names. A check
+ * recorded before the update landed therefore stops reading as pending the moment B is installed.
+ */
+export const newerCorpusPending = (facts) => {
+  const c = facts.corpusCheck;
+  if (!c?.candidateTag || !['UPDATE_AVAILABLE', 'UNKNOWN'].includes(c.verdict)) return null;
+  const installed = [facts.source?.corpusReleaseTag, facts.source?.releaseTag].filter(Boolean);
+  if (installed.includes(c.candidateTag)) return null;
+  return { tag: c.candidateTag, installed: installed[0] || null, checkedAt: c.checkedAt || c.launchedAt || null, outcome: c.outcome };
+};
+const shortTag = (tag) => (tag && tag.length > 28 ? `${tag.slice(0, 26)}…` : tag || 'unknown');
+
 export const knowledgeCurrency = ({ env = process.env, home, now = Date.now(), windowHours = 48 } = {}) => {
   const facts = knowledgeFacts({ env, home, now });
   const { brainHome, builtMs, history, hours, attempt } = facts;
@@ -142,6 +171,16 @@ export const knowledgeCurrency = ({ env = process.env, home, now = Date.now(), w
     && !(history.latest && history.latest.at >= launchedMs);
   const failing = latest?.status === 'FAILED' || autoFailed;
   const ageKnown = Number.isFinite(builtMs);
+  const pending = newerCorpusPending(facts);
+  if (!failing && pending && (proven || (ageKnown && hours(builtMs) <= windowHours))) {
+    const optOut = autoUpdateOptOut({ env, home, facts });
+    const what = autoRunning ? 'the automatic update is installing it now'
+      : optOut ? `automatic update is off (${optOut}). Fix: npx ruvnet-brain@latest --update`
+        : pending.outcome === 'not-converged' ? 'an automatic update to it finished without installing it; it retries within 6h'
+          : 'the automatic update installs it in the background';
+    return `${KNOWLEDGE_LINE_PREFIX}UPDATE PENDING] a newer corpus ${shortTag(pending.tag)} is published `
+      + `(this machine has ${shortTag(pending.installed)}, built ${ageKnown ? age(builtMs) : 'at an UNKNOWN time'}); ${what}.`;
+  }
   if (!failing && proven) return '';
   if (!failing && ageKnown && hours(builtMs) <= windowHours) return '';
   const kit = agenticKitUpdates({ home, facts });