ruvnet-brain 4.5.5 → 4.5.7

package/plugin/mcp/managed-cli-generation.mjs

@@ -0,0 +1,91 @@
+// DISTINCT-FROM hook-shim.mjs: managed execution fails closed; advisory hook fallback cannot
+// authorize a command. The protocol shell owns declarations, each request owns one generation.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const LOCAL_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const digest = (value) => createHash('sha256').update(value).digest('hex');
+const contained = (root, file) => file.startsWith(`${root}${path.sep}`);
+
+export function managedGenerationIdentity(root, { version, generation = 'source' } = {}) {
+  root = fs.realpathSync(root);
+  const manifestPath = path.join(root, '.claude-plugin', 'plugin.json');
+  const handlerPath = path.join(root, 'mcp', 'managed-cli-interface.mjs');
+  for (const file of [manifestPath, handlerPath]) {
+    if (!fs.lstatSync(file).isFile() || !contained(root, fs.realpathSync(file))) {
+      throw new Error('managed generation resource is not a contained regular file');
+    }
+  }
+  const manifestBytes = fs.readFileSync(manifestPath);
+  const manifest = JSON.parse(manifestBytes);
+  if (manifest.name !== 'ruvnet-brain' || typeof manifest.version !== 'string'
+    || !/^\d+\.\d+\.\d+(?:[-+][a-zA-Z0-9.+-]+)?$/.test(manifest.version)
+    || (version !== undefined && manifest.version !== version)) {
+    throw new Error('managed generation manifest name/version mismatch');
+  }
+  const sourceDigest = digest(Buffer.concat([manifestBytes, fs.readFileSync(handlerPath)]));
+  return Object.freeze({ root, handlerPath, version: manifest.version, generation, sourceDigest,
+    binding: digest(JSON.stringify([root, manifest.version, generation, sourceDigest])) });
+}
+
+function selectGeneration(env, fallbackRoot) {
+  const home = env.HOME || os.homedir();
+  const brainHome = env.RUVNET_BRAIN_HOME || path.join(home, '.cache', 'ruvnet-brain');
+  let activeBytes;
+  try { activeBytes = fs.readFileSync(path.join(brainHome, 'active.json'), 'utf8'); }
+  catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+    // A copied persistent shell must never manufacture an active generation from its resources.
+    if (path.resolve(fallbackRoot) === path.join(home, '.claude', 'ruvnet-brain')) {
+      throw new Error('managed active generation unavailable');
+    }
+    return { ...managedGenerationIdentity(fallbackRoot), brainHome, leased: false };
+  }
+  const active = JSON.parse(activeBytes);
+  if (typeof active.codeRoot !== 'string' || typeof active.version !== 'string'
+    || !Number.isSafeInteger(active.generation) || active.generation < 0) {
+    throw new Error('managed active generation descriptor invalid');
+  }
+  const versions = fs.realpathSync(path.join(brainHome, 'versions'));
+  const root = fs.realpathSync(path.resolve(brainHome, active.codeRoot));
+  if (!contained(versions, root) || path.basename(root) !== active.version) {
+    throw new Error('managed active generation escapes its version tree');
+  }
+  return { ...managedGenerationIdentity(root, active), brainHome, leased: true };
+}
+
+export function createManagedCliDispatcher({ fallbackRoot = LOCAL_ROOT,
+  importModule = (url) => import(url) } = {}) {
+  const pins = new Map();
+  return async function dispatchManagedCli(toolName, args, env = process.env,
+    fetchImpl = globalThis.fetch, lifecycle = {}) {
+    let lease;
+    try {
+      const selected = selectGeneration(env, fallbackRoot);
+      // ESM caches by URL. A changed file at the same immutable path must never be blessed as
+      // new code while execution still uses the old cached module (nor can query strings fix dependencies).
+      const pinned = pins.get(selected.root);
+      if (pinned && pinned !== selected.sourceDigest) throw new Error('managed immutable generation changed; restart required');
+      pins.set(selected.root, selected.sourceDigest);
+      if (selected.leased) {
+        const dir = path.join(selected.brainHome, 'leases');
+        fs.mkdirSync(dir, { recursive: true });
+        lease = path.join(dir, `mcp-managed-${process.pid}-${randomUUID()}.json`);
+        fs.writeFileSync(lease, JSON.stringify({ pid: process.pid, version: selected.version, at: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
+      }
+      const handler = await importModule(pathToFileURL(selected.handlerPath).href);
+      if (typeof handler.callManagedCli !== 'function') throw new Error('managed generation handler unavailable');
+      return await handler.callManagedCli(toolName, args, env, fetchImpl,
+        { ...lifecycle, generationBinding: selected.binding });
+    } catch (error) {
+      return { content: [{ type: 'text', text: `managed generation unavailable: ${error.message}` }], isError: true };
+    } finally {
+      if (lease) { try { fs.unlinkSync(lease); } catch { /* lease expiry preserves interrupted calls */ } }
+    }
+  };
+}
+
+export const dispatchManagedCli = createManagedCliDispatcher();

package/plugin/mcp/managed-cli-interface.mjs

@@ -2,11 +2,14 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { managedGenerationIdentity } from './managed-cli-generation.mjs';
 import { loadRuntimePreferences, runtimeChildEnv } from '../scripts/runtime-preferences.mjs';
 import { projectDirectory } from '../scripts/project-identity.mjs';
 import { recordManagedCliObservation, recordRegistryLatestObservation } from '../scripts/capability-claim-evidence.mjs';
 import { runSessionSnapshotHook } from '../scripts/session-snapshot-hook.mjs';
 import { resolveProjectStore } from '../scripts/project-store-resolver.mjs';
+import { isAutomaticProgressionSuspension } from '../scripts/project-progression-suspension.mjs';
 
 export const MANAGED_EXECUTABLES = Object.freeze([
   'ruflo',
@@ -34,6 +37,12 @@ const MAX_ARG_BYTES = 8192;
 const DEFAULT_FRESH_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_OUTPUT_BYTES = 1024 * 1024;
+// Bind direct calls to the module loaded at process start, too. Missing shell resources do not
+// prevent declarations from loading; the active dispatcher supplies the execution binding.
+const LOCAL_BINDING = (() => {
+  try { return managedGenerationIdentity(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')).binding; }
+  catch { return null; }
+})();
 
 const executableSchema = {
   type: 'string',
@@ -139,27 +148,32 @@ function stateDir(env) {
   return env.RUVNET_BRAIN_HELP_READ_DIR || path.join(brainHome, 'help-read');
 }
 
-function freshStamp(executable, argv, env, now = Date.now()) {
+function freshStamp(executable, argv, env, binding, now = Date.now()) {
   const stamp = path.join(stateDir(env), helpKey(executable, argv));
-  let stat;
+  let stat; let readAt;
   try {
-    stat = fs.statSync(stamp);
+    stat = fs.lstatSync(stamp);
+    if (!stat.isFile()) return false;
+    const receipt = JSON.parse(fs.readFileSync(stamp, 'utf8'));
+    if (receipt.schemaVersion !== 1 || receipt.generation !== binding
+      || !Number.isFinite(receipt.readAt) || receipt.readAt > now) return false;
+    readAt = receipt.readAt;
   } catch {
     return false;
   }
   const configured = Number(env.RUVNET_BRAIN_HELP_MAX_AGE_MS);
   const maxAge = Number.isFinite(configured) && configured > 0 ? configured : DEFAULT_FRESH_MS;
-  return now - stat.mtimeMs < maxAge;
+  return now - stat.mtimeMs < maxAge && now - readAt < maxAge;
 }
 
-function writeStamps(executable, argv, env) {
+function writeStamps(executable, argv, env, binding) {
   const dir = stateDir(env);
   fs.mkdirSync(dir, { recursive: true });
   for (const key of stampKeysForHelp(executable, argv)) {
     const stamp = path.join(dir, key);
     const temporary = path.join(dir, `.${key}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`);
     try {
-      fs.writeFileSync(temporary, '', { flag: 'wx', mode: 0o600 });
+      fs.writeFileSync(temporary, JSON.stringify({ schemaVersion: 1, generation: binding, readAt: Date.now() }), { flag: 'wx', mode: 0o600 });
       fs.renameSync(temporary, stamp);
     } finally {
       try { fs.unlinkSync(temporary); } catch { /* renamed or never created */ }
@@ -253,9 +267,10 @@ export function normalizeManagedExecution(execution) {
   const output = [execution?.stdout, execution?.stderr].filter(Boolean)
     .join(execution?.stdout && execution?.stderr ? '\n' : '');
   const contradictoryFailure = /(?:^|\n)\s*(?:❌|\[ERROR\])|invalid pragma command|key not found/i.test(output);
+  if (execution?.error) return { outcome: 'failure', output, contradictoryFailure };
   if (execution?.signal) return { outcome: 'interrupted', output, signal: execution.signal, contradictoryFailure };
-  if (execution?.error || contradictoryFailure || execution?.code === null || execution?.code === undefined) {
-    return { outcome: execution?.error || contradictoryFailure ? 'failure' : 'unknown', output, contradictoryFailure };
+  if (contradictoryFailure || execution?.code === null || execution?.code === undefined) {
+    return { outcome: contradictoryFailure ? 'failure' : 'unknown', output, contradictoryFailure };
   }
   return { outcome: execution.code === 0 ? 'success' : 'failure', output, contradictoryFailure };
 }
@@ -290,27 +305,34 @@ function managedProgressionCapture({ executable, argv, projectRoot, env, event,
       },
     } : {}),
   };
-  return { adopted: true, ...runSessionSnapshotHook(projectRoot, event, { rawInput: JSON.stringify(payload), host }) };
+  const result = runSessionSnapshotHook(projectRoot, event, { rawInput: JSON.stringify(payload), host, env });
+  return isAutomaticProgressionSuspension(result) ? result : { adopted: true, ...result };
 }
 
 function resultOf(executable, argv, result) {
   const output = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? '\n' : '');
   const normalized = normalizeManagedExecution(result);
+  const terminal = { outcome: normalized.outcome, code: result.code ?? null, signal: result.signal ?? null,
+    error: result.error ?? null, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
   if (normalized.outcome !== 'success') {
-    const reason = result.error || (normalized.contradictoryFailure ? 'fatal output despite exit 0' : result.code == null ? 'no terminal exit status' : `exit ${result.code}`);
+    const reason = result.error || (result.signal ? `signal ${result.signal}` : result.code != null && result.code !== 0 ? `exit ${result.code}` : normalized.contradictoryFailure ? 'fatal output without successful completion' : 'no terminal exit status');
     return {
-      content: [{ type: 'text', text: output || `${executable} ${argv.join(' ')} failed: ${reason}` }],
+      content: [{ type: 'text', text: [output, `${executable} ${argv.join(' ')} failed: ${reason}`].filter(Boolean).join('\n') }],
+      structuredContent: terminal,
       isError: true,
     };
   }
   return {
     content: [{ type: 'text', text: output || `${executable} ${argv.join(' ')} completed successfully` }],
+    structuredContent: terminal,
     isError: false,
   };
 }
 
 export async function callManagedCli(toolName, args, env = process.env, fetchImpl = globalThis.fetch, lifecycle = {}) {
   try {
+    const binding = lifecycle.generationBinding || LOCAL_BINDING;
+    if (!binding) throw new Error('managed generation identity unavailable');
     const executable = assertExecutable(args?.executable);
     const argv = literalArgv(args?.argv ?? []);
     const projectRoot = env.RUVNET_BRAIN_PROJECT_DIR || projectDirectory({ env });
@@ -339,13 +361,13 @@ export async function callManagedCli(toolName, args, env = process.env, fetchImp
       stampKeysForHelp(executable, argv);
       const commandArgv = [...argv, '--help'];
       const execution = await execute(executable, commandArgv, env);
-      if (execution.code === 0 && !execution.error) writeStamps(executable, argv, env);
+      if (normalizeManagedExecution(execution).outcome === 'success') writeStamps(executable, argv, env, binding);
       recordManagedCliObservation({ toolName, executable, argv: commandArgv, execution, env });
       return resultOf(executable, commandArgv, execution);
     }
 
     if (toolName === 'ruvnet_cli_run') {
-      if (!freshStamp(executable, argv, env)) {
+      if (!freshStamp(executable, argv, env, binding)) {
         const key = helpKey(executable, argv).replaceAll('.', ' ');
         return {
           content: [{ type: 'text', text: `Read the interface first with ruvnet_cli_help for: ${key}` }],
@@ -386,7 +408,8 @@ export async function callManagedCli(toolName, args, env = process.env, fetchImp
         : env;
       const capture = typeof lifecycle.capture === 'function' ? lifecycle.capture : managedProgressionCapture;
       const beforeCapture = await capture({ executable, argv, projectRoot, env: childEnv, event: 'PreToolUse' });
-      if (beforeCapture?.error || (beforeCapture?.adopted && beforeCapture.progressionCaptured !== true)) {
+      if (beforeCapture?.error || (beforeCapture?.adopted && beforeCapture.progressionCaptured !== true
+        && !isAutomaticProgressionSuspension(beforeCapture))) {
         const reason = beforeCapture.error || beforeCapture.skipped || 'pre-execution progression was not durably captured';
         return { content: [{ type: 'text', text: `managed execution refused: ${reason}` }], isError: true };
       }
@@ -400,13 +423,19 @@ export async function callManagedCli(toolName, args, env = process.env, fetchImp
         await lifecycle.afterExecute({ executable, argv, projectRoot, env: childEnv, execution, normalized });
       }
       recordManagedCliObservation({ toolName, executable, argv, execution, env });
-      if (afterCapture?.adopted && afterCapture.progressionCaptured !== true) {
+      if (afterCapture?.adopted && afterCapture.progressionCaptured !== true
+        && !isAutomaticProgressionSuspension(afterCapture)) {
         return {
           content: [{ type: 'text', text: `managed command ${normalized.outcome}; continuity result was not durably captured: ${afterCapture.skipped || 'unknown reason'}` }],
           isError: true,
         };
       }
-      return resultOf(executable, argv, execution);
+      const result = resultOf(executable, argv, execution);
+      if (isAutomaticProgressionSuspension(beforeCapture) || isAutomaticProgressionSuspension(afterCapture)) {
+        result.content.push({ type: 'text', text: 'Automatic project progression is operator-suspended; suspended captures produced no progression receipt. Ordinary AgentDB memory and explicit checkpoints remain available.' });
+        result.structuredContent.continuity = 'operator-suspended';
+      }
+      return result;
     }
 
     return {

package/plugin/mcp/server.mjs

@@ -35,7 +35,8 @@ import os from 'node:os';
 import readline from 'node:readline';
 import { fileURLToPath } from 'node:url';
 import { writeOwn as writeOwnReadiness } from '../scripts/mcp-readiness.mjs';
-import { callManagedCli, MANAGED_CLI_TOOLS } from './managed-cli-interface.mjs';
+import { MANAGED_CLI_TOOLS } from './managed-cli-interface.mjs';
+import { dispatchManagedCli } from './managed-cli-generation.mjs';
 import { unmountedNotice } from '../scripts/brain-location.mjs';
 
 const BRAIN_HOME = process.env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain');
@@ -362,7 +363,7 @@ async function handleClient(msg) {
     case 'tools/call': {
       if (params?.name === 'ruvnet_cli_help' || params?.name === 'ruvnet_cli_run'
         || params?.name === 'ruvnet_registry_latest') {
-        return clientOk(id, await callManagedCli(params.name, params.arguments || {}));
+        return clientOk(id, await dispatchManagedCli(params.name, params.arguments || {}));
       }
       if (params?.name !== 'search_ruvnet') return clientErr(id, -32602, `unknown tool: ${params?.name}`);
       refreshLease();

package/plugin/scripts/capability-claim-evidence.mjs

@@ -3,6 +3,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { redactText } from './continuity-events.mjs';
 
 const HEX40 = /^[a-f0-9]{40}$/;
 const HEX64 = /^[a-f0-9]{64}$/;
@@ -157,7 +158,13 @@ export function recordManagedCliObservation({ toolName, executable, argv, execut
   observedAt = new Date().toISOString() } = {}) {
   try {
     const output = [execution?.stdout, execution?.stderr].filter(Boolean).join('\n');
-    const reachable = execution?.code === 0 && !execution?.error;
+    const contradictoryFailure = /(?:^|\n)\s*(?:❌|\[ERROR\])|invalid pragma command|key not found/i.test(output);
+    const reachable = execution?.code === 0 && !execution?.error && !execution?.signal && !contradictoryFailure;
+    const outcome = execution?.error ? 'failure' : execution?.signal ? 'interrupted' : contradictoryFailure ? 'failure'
+      : Number.isSafeInteger(execution?.code) ? execution.code === 0 ? 'success' : 'failure' : 'unknown';
+    const terminal = { outcome, exitCode: Number.isSafeInteger(execution?.code) ? execution.code : null,
+      error: typeof execution?.error === 'string' ? redactText(execution.error).slice(0, 4096) : null,
+      signal: typeof execution?.signal === 'string' ? redactText(execution.signal).slice(0, 100) : null };
     const version = VERSION.exec(output)?.[1] || null;
     let observationClass = null;
     let fields = {};
@@ -169,7 +176,7 @@ export function recordManagedCliObservation({ toolName, executable, argv, execut
       observationClass = 'health';
       const negative = /\b(?:critical|degraded|error|failed|failure|unhealthy)\b/i.test(output);
       const positive = /\b(?:all checks passed|healthy|overall\s*[:=-]?\s*(?:ok|pass)|status\s*[:=-]\s*(?:ok|pass|healthy))\b/i.test(output);
-      fields = { healthVerdict: negative ? 'FAIL' : reachable && positive ? 'PASS' : 'UNKNOWN', reachable };
+      fields = { healthVerdict: negative || ['failure', 'interrupted'].includes(outcome) ? 'FAIL' : reachable && positive ? 'PASS' : 'UNKNOWN', reachable, terminal };
     }
     if (!observationClass) return null;
     const payload = {

package/plugin/scripts/continuation-gate.mjs

@@ -385,7 +385,9 @@ function promiseBookkeeping() {
       }
     }
     const openKeys = new Set(led.items.filter((i) => i?.kind === PROMISE_KIND && !i.done && i.projectId === pid).map((i) => i.key));
-    for (const promise of extractCommitments(hookInput.last_assistant_message)) {
+    // Owner preference suppresses only new capture; verified closure above and integrity audits stay active.
+    const newPromises = process.env.RUVNET_PROMISE_CAPTURE === 'off' ? [] : extractCommitments(hookInput.last_assistant_message);
+    for (const promise of newPromises) {
       if (openKeys.has(promise.key) || openKeys.size >= PROMISE_CAP_OPEN) continue;
       openKeys.add(promise.key);
       led.items.push({ schemaVersion: 1, kind: PROMISE_KIND, text: promise.text, key: promise.key, done: false, at,

package/plugin/scripts/continuity-journal.mjs

@@ -303,24 +303,24 @@ export function recordingLine(status, now = Date.now()) {
   return `AgentDB: recording ✓ (last write ${ago(now - status.lastCommitAt)} ago, ${status.eventsToday} event(s) today, outbox ${status.pending} pending)`;
 }
 
-/**
- * The Claude Stop line, at most ONCE per session per condition (review S3: it repeated at every turn).
- * State is a tiny file in the project's own .swarm, bounded to the last 20 sessions.
- */
-export function stopNotice({ journal, status, session }) {
-  if (!status?.stuck || !status.problem) return '';
-  const file = path.join(journal.swarm, NOTICE_STATE);
+/** Shared notices: once per session/condition, bounded to the last twenty sessions in .swarm. */
+export function conditionNotice({ swarm, session, condition, message, now = Date.now }) {
+  const file = path.join(swarm, NOTICE_STATE);
   let state = {};
   try { state = JSON.parse(fs.readFileSync(file, 'utf8')) || {}; } catch { /* first notice */ }
   const id = String(session || 'unknown');
   const shown = Array.isArray(state[id]?.conditions) ? state[id].conditions : [];
-  if (shown.includes(status.problem)) return '';
-  state[id] = { at: new Date(journal.now()).toISOString(), conditions: [...shown, status.problem] };
+  if (shown.includes(condition)) return '';
+  state[id] = { at: new Date(now()).toISOString(), conditions: [...shown, condition] };
   const recent = Object.entries(state).sort((a, b) => String(b[1]?.at).localeCompare(String(a[1]?.at))).slice(0, 20);
   try { fs.writeFileSync(file, JSON.stringify(Object.fromEntries(recent)), { mode: 0o600 }); } catch { /* still show it once */ }
-  return `[RuvNet Brain] ${recordingLine(status, journal.now())}`;
+  return message;
+}
+export function stopNotice({ journal, status, session }) {
+  if (!status?.stuck || !status.problem) return '';
+  return conditionNotice({ swarm: journal.swarm, session, condition: status.problem, now: () => journal.now(),
+    message: `[RuvNet Brain] ${recordingLine(status, journal.now())}` });
 }
-
 function defaultStore({ ruflo, db, key, value }) {
   const cwd = rufloRunDir(db);
   try {

package/plugin/scripts/hook-shim.mjs

@@ -86,7 +86,8 @@ catch (e) { BRAIN_OFF = !(e && (e.code === 'ENOENT' || e.code === 'ENOTDIR')); }
 const TABLE = {
   'session-start':    { file: 'session-start-core.mjs', interpreter: 'node', mode: 'advisory', offBehavior: 'partial' },
   'ground-ruvnet':    { file: 'ground-ruvnet.sh',    interpreter: 'bash', mode: 'advisory', offBehavior: 'silence', stdinBytes: 32768 },
-  'capacity-aware-parallel-work': { file: 'capacity-aware-parallel-work.mjs', interpreter: 'node', mode: 'advisory', offBehavior: 'run', stdinBytes: 32768 },
+  // Capacity advice is a Brain prompt hint; OFF must not execute its resource probes or steer work.
+  'capacity-aware-parallel-work': { file: 'capacity-aware-parallel-work.mjs', interpreter: 'node', mode: 'advisory', offBehavior: 'silence', stdinBytes: 32768 },
   // ADR-063 / issue #103: `blocking` so an opt-in refusal can actually reach the host. The hook
   // still exits 0 for every user at the shipped default (managedMemoryBoundary=advise), so this
   // changes the CEILING of what it may do, not what it does.

package/plugin/scripts/kb-copy-proof.mjs

@@ -46,10 +46,11 @@ const storeList = (source) => {
   return stores && typeof stores === 'object' ? Object.entries(stores).map(([kbName, value]) => ({ kbName, ...value })) : [];
 };
 const stemOf = (file) => path.basename(String(file)).replace(/(?:\.big)?\.rvf$/i, '').toLowerCase();
-// The store a sidecar belongs to: <store>.big.rvf[.embed|.idmap].json, <store>.meta.json, <store>.passages.jsonl,
-// <store>.symbols.json, <store>-primer.md.
+// The store a sidecar belongs to: <store>.big.rvf[.embed|.idmap].json, <store>[.big].meta.json,
+// <store>[.big].passages.jsonl, <store>[.big].symbols.json, <store>-primer.md.
 const storeStem = (file) => path.basename(String(file)).toLowerCase()
-  .replace(/-primer\.md$/, '').replace(/(?:\.big)?\.rvf(?:\.[a-z]+\.json)?$/, '').replace(/\.(?:meta|symbols)\.json$|\.passages\.jsonl$/, '');
+  .replace(/-primer\.md$/, '').replace(/(?:\.big)?\.rvf(?:\.[a-z]+\.json)?$/, '')
+  .replace(/(?:\.big)?(?:\.(?:meta|symbols)\.json|\.passages\.jsonl)$/, '');
 // Files the installer/updater writes into a KB that no bundle ships (bin/install.mjs placeUpdater,
 // placeTrustedCoverageValidator, ensureVerifier; the updater's snapshot receipt). Re-created on every install.
 const INSTALLER_WRITTEN = new Set(['coverage-integrity.mjs', 'RUNTIME-IDENTITY.json', '.refresh-snapshot.json',

package/plugin/scripts/nightly-scheduler.mjs

@@ -101,8 +101,12 @@ export function describeFailedRefreshRun(receipt, { reasonLimit = 200 } = {}) {
   const ledger = receipt.phases.map((entry) => entry?.phase);
   if (ledger.length > declared.length || ledger.some((phase, index) => phase !== declared[index])) return null;
   if (ledger.length === 0) return `failed before its first phase (${receipt.terminalVerdict || 'unknown'})`;
-  const failing = [...receipt.phases].reverse().find((entry) => entry?.status !== 'PASS') || receipt.phases[receipt.phases.length - 1];
-  const reason = String(failing.evidence?.updateResult?.reason ?? failing.evidence?.reason ?? '').split('\n')[0].trim();
+  const failing = receipt.phases.find((entry) => entry?.required !== false && entry?.status === 'FAIL')
+    || receipt.phases.find((entry) => entry?.status === 'FAIL')
+    || [...receipt.phases].reverse().find((entry) => entry?.status !== 'PASS')
+    || receipt.phases[receipt.phases.length - 1];
+  const reason = String(failing.evidence?.updateResult?.reason ?? failing.evidence?.error
+    ?? failing.evidence?.reason ?? '').split('\n')[0].trim();
   return reason ? `failed at ${failing.phase}: ${reason.slice(0, reasonLimit)}` : `failed at ${failing.phase}`;
 }
 

package/plugin/scripts/project-capture-queue.mjs

@@ -6,12 +6,14 @@ import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { developmentHooksSuspended } from './development-maintenance.mjs';
 import { resolveTurnDb } from './turn-outcome-capture.mjs';
+import { enrichStateWithObservation } from './project-progression-hook.mjs';
 import { buildProjectProgression } from './project-progression-producer.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { redactProgression } from './project-progression-contract.mjs';
 import { ProgressionOutbox } from './project-progression-outbox.mjs';
 import { captureNormalizedTransition } from './project-transition-hook.mjs';
 import { boundedStoreFactory, runSessionSnapshotHook } from './session-snapshot-hook.mjs';
+import { operatorProgressionSuspension } from './project-progression-suspension.mjs';
 
 /**
  * How long the detached worker may spend per step. The lock is refreshed between steps and goes stale
@@ -48,6 +50,7 @@ const mtimeOf = (projectDir, name) => { try { return fs.statSync(path.join(proje
  */
 export function queueCapture({ projectDir, originProjectDir = projectDir, event, host, payload, env = process.env }) {
   try {
+    if (operatorProgressionSuspension(env)) return null;
     const consent = resolveTurnDb({ projectDir: originProjectDir, requestedStorePath: path.join(projectDir, '.swarm', 'memory.db'),
       brainHome: env.RUVNET_BRAIN_HOME || path.join(env.HOME || os.homedir(), '.cache', 'ruvnet-brain') });
     if (consent.skipped) return null;
@@ -57,6 +60,10 @@ export function queueCapture({ projectDir, originProjectDir = projectDir, event,
   if (!progression && !payload?.normalizedTransition) {
     try { progression = buildProjectProgression({ resolution: resolveProjectStore({ projectDir: originProjectDir }), projectDir: originProjectDir, payload, host, trigger: event }).projectProgression; } catch { return null; }
   }
+  // Freeze the bounded native observation before discarding raw host input. Replay receives no
+  // tool fields, so the native writer cannot append it twice.
+  if (progression && (payload?.tool_name || payload?.tool_input)) progression = { ...progression,
+    completeProjectState: enrichStateWithObservation(progression.completeProjectState, { ...payload, hook_event_name: event }) };
   // This queue is durable: never serialize arbitrary host prompts, tool input or output.
   const minimized = { session_id: payload?.session_id, hook_event_name: event,
     ...(progression ? { projectProgression: progression } : {}),
@@ -227,13 +234,16 @@ export function releaseReplayLock(projectDir, token) {
 }
 
 /** Hand the lock (or take it, if free) to a detached worker. Returns whether one was started. Never throws. */
-export function replayOutboxDetached({ projectDir, token = null, spawnFn = spawn } = {}) {
+export function replayOutboxDetached({ projectDir, token = null, spawnFn = spawn, env = process.env } = {}) {
+  try {
+    if (operatorProgressionSuspension(env)) { if (token) releaseReplayLock(projectDir, token); return false; }
+  } catch { if (token) releaseReplayLock(projectDir, token); return false; }
   const held = token || takeReplayLock(projectDir);
   if (!held) return false;
   try {
     const child = spawnFn(process.execPath, [path.join(path.dirname(fileURLToPath(import.meta.url)), 'session-snapshot-hook.mjs'), '--replay-outbox'], {
       cwd: projectDir, detached: true, stdio: 'ignore', windowsHide: true,
-      env: { ...process.env, RUVNET_REPLAY_LOCK_TOKEN: held },
+      env: { ...env, RUVNET_REPLAY_LOCK_TOKEN: held },
     });
     child.unref?.();
     return true;
@@ -254,10 +264,11 @@ export function replayOutboxDetached({ projectDir, token = null, spawnFn = spawn
  */
 export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_LOCK_TOKEN || null, budgetMs = DETACHED_REPLAY_BUDGET_MS,
   makeStoreFactory = boundedStoreFactory, now = Date.now, runCapture = runSessionSnapshotHook, onClaim = null,
-  captureNormalized = captureNormalizedTransition, onCaptured = null } = {}) {
+  captureNormalized = captureNormalizedTransition, onCaptured = null, env = process.env } = {}) {
   const deadlineAt = now() + budgetMs;
   if (developmentHooksSuspended(projectDir)) return 0;
-  const brainHome = process.env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain');
+  if (operatorProgressionSuspension(env)) { if (token) releaseReplayLock(projectDir, token); return 0; }
+  const brainHome = env.RUVNET_BRAIN_HOME || path.join(env.HOME || os.homedir(), '.cache', 'ruvnet-brain');
   try {
     const consent = resolveTurnDb({ projectDir, brainHome });
     if (consent.skipped && !consent.skipped.startsWith('no project memory db')) return 0;
@@ -269,14 +280,17 @@ export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_
       if (!adoptReplayLock(projectDir, held)) return replayed;
       reclaimOrphans(projectDir);
       const resolution = resolveProjectStore({ projectDir });
-      const store = makeStoreFactory(deadlineAt)({ projectDir, requestedStorePath: resolution.canonicalAgentDbPath });
+      const store = makeStoreFactory(deadlineAt)({ projectDir, env, requestedStorePath: resolution.canonicalAgentDbPath });
       for (const snapshot of store.outbox.pendingSnapshots()) {
+        if (operatorProgressionSuspension(env)) return replayed;
         if (now() >= deadlineAt) return replayed;
         if (!refreshReplayLock(projectDir, held)) return replayed;
-        store.outbox.markCommitted(store.appendExact(snapshot));
+        store.captureFrozen(snapshot, { canCommit: () => refreshReplayLock(projectDir, held) });
+        // captureFrozen commits only the verified key, retaining conflicting original history.
         replayed += 1;
       }
       for (const file of queuedCaptures(projectDir)) {
+        if (operatorProgressionSuspension(env)) return replayed;
         if (now() >= deadlineAt) return replayed;
         if (!refreshReplayLock(projectDir, held)) return replayed;
         const claimed = claimQueued(file);
@@ -286,6 +300,7 @@ export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_
           returnClaim(claimed);
           return replayed;
         }
+        if (operatorProgressionSuspension(env)) { returnClaim(claimed); return replayed; }
         let job = null;
         try { job = JSON.parse(fs.readFileSync(claimed, 'utf8')); } catch { /* torn: dropped below */ }
         let committed = false;
@@ -296,7 +311,7 @@ export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_
             const consent = resolveTurnDb({ projectDir: job.originProjectDir || projectDir, brainHome });
             if (developmentHooksSuspended(job.originProjectDir || projectDir)
               || (consent.skipped && !consent.skipped.startsWith('no project memory db'))) { returnClaim(claimed); return replayed; }
-            const options = { rawInput: JSON.stringify(job.payload), host: job.host,
+            const options = { rawInput: JSON.stringify(job.payload), host: job.host, env,
               budgetMs: Math.max(0, deadlineAt - now()), makeStoreFactory: () => makeStoreFactory(deadlineAt), now, ordered: held, writeMetadata: false,
               captureTurn: () => ({ recorded: false, skipped: 'detached replay' }),
               captureEvents: () => ({ recorded: 0, skipped: 'detached replay' }) };
@@ -321,6 +336,7 @@ export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_
 
 /** Synchronous bounded startup drain. Pending debt must downgrade restore, never disappear. */
 export function drainCaptureQueue({ projectDir, budgetMs = 1000, ...options } = {}) {
+  if (operatorProgressionSuspension(options.env || process.env)) return { state: 'suspended', replayed: 0, pending: null };
   const startedAt = Date.now();
   const resolution = resolveProjectStore({ projectDir, gitTimeoutMs: Math.max(1, Math.min(300, budgetMs)) });
   const root = resolution.projectRoot;
@@ -330,4 +346,3 @@ export function drainCaptureQueue({ projectDir, budgetMs = 1000, ...options } =
   const pending = queuedWork(root) + outboxPending;
   return { state: pending ? 'pending' : 'settled', replayed, pending };
 }
-

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

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createProgressionSnapshot } from './project-progression-contract.mjs';
 import { ProjectProgressionStore } from './project-progression-store.mjs';
+import { redactText } from './continuity-events.mjs';
 
 const HOSTS = new Set(['claude', 'codex']);
 const CAPTURE_TRIGGERS = new Set([
@@ -105,15 +106,17 @@ function toolAction(payload) {
   const exitCode = Number.isSafeInteger(explicitCode)
     ? explicitCode
     : textualCode ? Number(textualCode[1]) : undefined;
-  const interrupted = responseRecord?.interrupted === true || responseRecord?.signal === 'SIGINT';
+  const error = boundedText(typeof responseRecord?.error === 'string' ? redactText(responseRecord.error) : undefined);
+  const signal = boundedText(typeof responseRecord?.signal === 'string' ? redactText(responseRecord.signal) : undefined);
+  const interrupted = responseRecord?.interrupted === true || Boolean(signal);
   const explicitError = responseRecord?.isError === true || payload.is_error === true;
   const declaredOutcome = ['success', 'failure', 'interrupted', 'unknown'].includes(responseRecord?.outcome)
     ? responseRecord.outcome : null;
-  const failed = explicitError || (Number.isSafeInteger(exitCode) && exitCode !== 0);
+  const failed = explicitError || Boolean(error) || (Number.isSafeInteger(exitCode) && exitCode !== 0);
   const terminal = failed || Number.isSafeInteger(exitCode)
     || responseRecord?.success === true || responseRecord?.ok === true;
   const outcome = payload.hook_event_name === 'PostToolUse'
-    ? (interrupted ? 'interrupted' : failed ? 'failure' : declaredOutcome || (terminal ? 'success' : 'unknown'))
+    ? (error ? 'failure' : interrupted ? 'interrupted' : failed ? 'failure' : declaredOutcome || (terminal ? 'success' : 'unknown'))
     : 'pending';
   const observation = {
     trigger: payload.hook_event_name,
@@ -121,7 +124,9 @@ function toolAction(payload) {
     ...(command ? { command } : {}),
     ...(filePath && !command ? { filePath } : {}),
     outcome,
-    ...(Number.isSafeInteger(exitCode) ? { exitCode } : {}),
+    ...(Number.isSafeInteger(exitCode) ? { exitCode } : responseRecord?.exit_code === null || responseRecord?.exitCode === null ? { exitCode: null } : {}),
+    ...(error ? { error } : {}),
+    ...(signal ? { signal } : {}),
     ...(interrupted ? { interrupted: true } : {}),
     ...(explicitError ? { isError: true } : {}),
   };
@@ -137,7 +142,7 @@ function toolAction(payload) {
   return observation;
 }
 
-function enrichStateWithObservation(state, payload) {
+export function enrichStateWithObservation(state, payload) {
   requireRecord(state, 'completeProjectState');
   const observation = toolAction(payload);
   if (!observation) return state;
@@ -164,6 +169,8 @@ export function captureProjectTransition({
   payload,
   projectDir,
   adapterVersion = readProgressionAdapterVersion(),
+  recoverFrozen = false,
+  canCommit,
   storeFactory = (options) => new ProjectProgressionStore(options),
 } = {}) {
   const normalizedHost = requireString(host, 'host').toLowerCase();
@@ -191,7 +198,7 @@ export function captureProjectTransition({
     aliased(progression, 'sourceIdentity', 'source_identity'),
     store.resolution.checkoutRoot, projectDir,
   );
-  const snapshot = createProgressionSnapshot({
+  let snapshot = createProgressionSnapshot({
     projectIdentity: store.resolution.projectIdentity,
     sourceIdentity,
     hostIdentity: { host: normalizedHost, adapterVersion },
@@ -206,7 +213,9 @@ export function captureProjectTransition({
       payload,
     ),
   });
-  const receipt = store.capture(snapshot);
+  let receipt;
+  if (recoverFrozen) ({ snapshot, receipt } = store.captureFrozen(snapshot, { canCommit }));
+  else receipt = store.capture(snapshot);
   verifyReceipt(snapshot, receipt);
   return { snapshot, receipt };
 }