ruvnet-brain 4.5.6 → 4.5.7

package/README.md

@@ -7,7 +7,7 @@ Created: 2026-06-29 22:36:38 EDT
 
 # 🧠 RuvNet Brain
 
-### 🧠 RuvNet Brain — [![RuvNet Brain version 4.5.6 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.5.6-updated_2026--07--30_03:24_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
+### 🧠 RuvNet Brain — [![RuvNet Brain version 4.5.7 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.5.7-updated_2026--07--30_03:24_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](https://github.com/stuinfla/ruvnet-brain/blob/main/plugin/.claude-plugin/plugin.json)
 
 **A portable, source-grounded brain over Reuven Cohen's (rUv's) RuvNet stack — delivered as a Claude Code plugin that makes Claude _use_ the stack instead of fighting it.**
 

package/kb/forge-update.mjs

@@ -1405,6 +1405,35 @@ export function bundleIdentity(src) {
   return parts.some(Boolean) ? parts.join('|') : null;
 }
 
+const downloadedArchiveVerifiers = new WeakSet();
+
+function archiveVerifierFromDigests(actualDigests, bytes) {
+  const verifier = Object.freeze({
+    bytes,
+    digest(algorithm = 'sha256') {
+      if (!Object.hasOwn(actualDigests, algorithm)) throw new Error(`archive algorithm ${algorithm} was not captured`);
+      return actualDigests[algorithm];
+    },
+  });
+  downloadedArchiveVerifiers.add(verifier);
+  return verifier;
+}
+
+// Capture the closed transaction algorithm inventory synchronously. Never retain mutable bytes:
+// the capability attests only to this creation-time snapshot, not a later caller-owned Buffer.
+export function createDownloadedArchiveVerifier(downloadedBuffer, expectedDigests = []) {
+  if (!Buffer.isBuffer(downloadedBuffer) || !Array.isArray(expectedDigests)) throw new TypeError('archive bytes and digest inventory required');
+  const algorithms = new Set(['sha256']);
+  for (const expected of expectedDigests) {
+    if (expected == null) continue;
+    if (typeof expected !== 'string' || !expected) throw new TypeError('invalid archive digest');
+    algorithms.add(expected.includes(':') ? expected.split(':')[0] : 'sha256');
+  }
+  const actualDigests = Object.freeze(Object.fromEntries([...algorithms].map(algorithm =>
+    [algorithm, createHash(algorithm).update(downloadedBuffer).digest('hex')])));
+  return archiveVerifierFromDigests(actualDigests, downloadedBuffer.length);
+}
+
 /**
  * Confirm the download+extraction actually changed what is on disk (issue #35 item 2, Dr. Mark
  * Allen / @mamd69).
@@ -1448,8 +1477,11 @@ export function bundleIdentity(src) {
  * @returns {{ok: boolean, reason: string|null, landed: object|null, kind: 'noop'|'damaged'|null,
  *            storeUnchanged: boolean, bundleChanged: boolean|null}}
  */
-export function verifyLanded({ kbDir, kbName, before, beforeBundle = null, expectedDigest = null, downloadedBuffer = null }) {
+export function verifyLanded({ kbDir, kbName, before, beforeBundle = null, expectedDigest = null, downloadedBuffer = null, archiveVerifier = null }) {
   const damaged = (reason, landed = null) => ({ ok: false, kind: 'damaged', reason, landed, storeUnchanged: false, bundleChanged: null });
+  if (archiveVerifier !== null && (!downloadedArchiveVerifiers.has(archiveVerifier) || downloadedBuffer !== null)) {
+    return damaged('archive verification capability is invalid or mixed with mutable archive bytes');
+  }
   const p = path.join(kbDir, 'SOURCE.json');
   if (!fs.existsSync(p)) {
     return damaged(`no SOURCE.json found at ${p} after extraction — cannot confirm what actually landed`);
@@ -1487,9 +1519,11 @@ export function verifyLanded({ kbDir, kbName, before, beforeBundle = null, expec
 
   // Bytes that do not match what the release declared are a HARD failure whatever the identities
   // say, and the copy now in place is suspect — so this is checked before anything else.
-  if (expectedDigest && downloadedBuffer) {
+  if (expectedDigest && (downloadedBuffer || archiveVerifier)) {
     const algo = expectedDigest.includes(':') ? expectedDigest.split(':')[0] : 'sha256';
-    const actual = `${algo}:${createHash(algo).update(downloadedBuffer).digest('hex')}`;
+    let actual;
+    try { actual = `${algo}:${archiveVerifier ? archiveVerifier.digest(algo) : createHash(algo).update(downloadedBuffer).digest('hex')}`; }
+    catch (error) { return damaged(`downloaded bundle digest verification failed: ${error.message}`, landed); }
     if (actual !== expectedDigest) {
       return damaged(`downloaded bundle digest ${actual} does not match the release-declared digest ${expectedDigest}`, landed);
     }
@@ -1705,7 +1739,7 @@ async function main() {
   const originLabel = resolved.origin === 'latest-release-asset' ? `live release asset "${resolved.assetName}"`
     : resolved.origin === 'live-manifest' ? 'live manifest' : 'PINNED FALLBACK (see warning above)';
   console.log(`\n[${behindStores.length} store(s)] downloading ${resolved.url}\n  (source: ${originLabel}) ...`);
-  const buf = await fetchBuffer(resolved.url);
+  let buf = await fetchBuffer(resolved.url);
   const sigBuf = await fetchBuffer(`${resolved.url}.sig`, { failureCode: 3, kind: 'signature' });
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-update-release-'));
   const zipPath = path.join(tmp, 'bundle.zip');
@@ -1718,6 +1752,14 @@ async function main() {
   const signature = verifyDownloadedBundle(zipPath, sigPath);
   if (!signature.ok) { fs.rmSync(tmp, { recursive: true, force: true }); die(`✗ SIGNATURE VERIFICATION FAILED: ${signature.reason}`, 4); }
   console.log(`  ✓ signature verified — ${signature.reason}`);
+  let archiveVerifier;
+  try { archiveVerifier = createDownloadedArchiveVerifier(buf, resolvedTargets.map(({ resolved: target }) => target.digest)); }
+  catch (error) {
+    fs.rmSync(tmp, { recursive: true, force: true });
+    die(`archive digest snapshot failed: ${error.message} — local files untouched.`, 4);
+  }
+  const bundleSha256 = archiveVerifier.digest();
+  buf = null; // Snapshot owns only immutable digest strings; release the downloaded bytes before validation.
   // DISK-SPACE PREFLIGHT, before a single byte is unpacked: the bundle unpacks in temp, then a whole
   // candidate generation is built beside the live one: the bundle, plus what prepareCandidate carries into
   // it from live — node_modules, and every private/local-ingest store file (restorePrivateFilesIntoCandidate
@@ -1801,7 +1843,7 @@ async function main() {
       for (const { local, resolved: storeResolution } of landingTargets) {
         execFileSync(process.execPath, [guard, '--dir', dir, '--name', local.kbName], { cwd: dir, stdio: 'pipe' });
         const verified = verifyLanded({ kbDir: dir, kbName: local.kbName, before: local, beforeBundle: source,
-          expectedDigest: storeResolution.digest, downloadedBuffer: buf });
+          expectedDigest: storeResolution.digest, archiveVerifier });
         if (!verified.ok && verified.kind !== 'noop') return { valid: false, failures: [verified.reason] };
         if (phase === 'live') finalVerificationByStore.set(local.kbName, verified);
       }
@@ -1872,7 +1914,6 @@ async function main() {
   fs.rmSync(tmp, { recursive: true, force: true });
   console.log(`  storage transaction: ${transaction.terminalVerdict}`);
   if (transaction.terminalVerdict === 'cleanup-pending') {
-    const bundleSha256 = createHash('sha256').update(buf).digest('hex');
     const cleanupOutcome = writeUpdateOutcome({ terminalVerdict: 'cleanup-pending', storageDelta: transaction.storageDelta,
       transactionReceipts: transaction.paths.receipts, bundleSha256,
       phaseEvidence: phaseEvidenceFor({ root: KB_DIR, terminalVerdict: 'cleanup-pending', bundleSha256,
@@ -1886,7 +1927,7 @@ async function main() {
   for (const { local, resolved: storeResolution } of landingTargets) {
     const verified = finalVerificationByStore.get(local.kbName)
       || verifyLanded({ kbDir: KB_DIR, kbName: local.kbName, before: local, beforeBundle: source,
-        expectedDigest: storeResolution.digest, downloadedBuffer: buf });
+        expectedDigest: storeResolution.digest, archiveVerifier });
     if (verified.storeUnchanged || verified.kind === 'noop') unchangedStores.push(local.kbName);
     landedByStore.set(local.kbName, { landed: verified.landed, origin: storeResolution.origin, assetName: storeResolution.assetName });
   }
@@ -1947,10 +1988,10 @@ async function main() {
     currencyVerdict: verdict.verdict, currencyReason: verdict.reason, candidateKind: candidateIdentity.kind,
     storageDelta: transaction.storageDelta,
     transactionReceipts: transaction.paths.receipts,
-    bundleSha256: createHash('sha256').update(buf).digest('hex'),
+    bundleSha256,
     coverageSha256: sha256File(path.join(KB_DIR, 'COVERAGE.json')),
     phaseEvidence: phaseEvidenceFor({ root: KB_DIR, terminalVerdict: transaction.terminalVerdict,
-      bundleSha256: createHash('sha256').update(buf).digest('hex'),
+      bundleSha256,
       transactionReceipts: transaction.paths.receipts, overlay: privateOverlay,
       storageDelta: transaction.storageDelta }) });
   if (finalOutcome?.terminalVerdict === 'recovery-required') die(finalOutcome.reason);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.5.6",
+  "version": "4.5.7",
   "description": "One-command installer for RuvNet Brain — a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
   "type": "module",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
   "description": "RuvNet brain transplant for Claude Code — grounds every RuvNet decision in real source across 77 rUv repositories, prefers Ruflo / RuVector-RVF / AgentDB over training-prior defaults (pgvector, Pinecone, hand-rolled cosine), and can pull in any RuvNet repo on demand. Ships a UserPromptSubmit retrieve-and-inject grounding hook and a PreToolUse write gate that refuses ungrounded rUv-product code until search_ruvnet has been consulted (ADR-0012 / ADR-067).",
-  "version": "4.5.6",
+  "version": "4.5.7",
   "author": {
     "name": "Stuart Kerr"
   },

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.5.6",
+  "version": "4.5.7",
   "description": "Source-grounded RuvNet knowledge, lifecycle enforcement, and learning for Codex.",
   "author": {
     "name": "Stuart Kerr"

package/plugin/commands/configure.md

@@ -1,6 +1,7 @@
 ---
 description: Open the RuvNet Brain Console (/rnbc) — a local web page that mirrors YOUR machine's RuvNet setup, explains it in plain English, and lets you safely configure and fix it. Read-only until you click; every machine change is explained first and is reversible.
-updated: 2026-10-01
+updated: 2026-10-04
+version: 1.0.1
 ---
 
 Launch the **RuvNet Brain Console** (RNBC) for the user. `/rnbc` is its name; `/rnb`, `/rvbc`,
@@ -64,6 +65,17 @@ header chip says how fresh the reading is and re-measures if they click it.
 Report it plainly — the real error, not a guess — and offer to fix it. Never leave them staring at
 a dead tab wondering whether it is still loading.
 
+## Promise capture preference
+
+If the user asks to stop automatic promise capture, explain the supported setting:
+`RUVNET_PROMISE_CAPTURE=off` in the hook process environment. It can be supplied for the machine or
+one project through the host's environment configuration. The exact value `off` stops capturing new
+"I'll …" promises; unset it or set `on` to resume capture. This preference is separate from the Brain
+on/off switch and is not currently a Console toggle. Existing promises remain visible and forceable,
+and close only on verified evidence. Capability and completion integrity checks keep running. Do not
+disable the Stop hook or edit the work ledger to apply this preference. Reopen the host if its current
+session has not picked up the changed environment.
+
 ---
 
 ## Things NOT to do before the page is open

package/plugin/hooks/hook-contracts.json

@@ -297,7 +297,7 @@
         "codex"
       ],
       "mode": "advisory",
-      "offBehavior": "run",
+      "offBehavior": "silence",
       "matcher": "*",
       "timeout": 6
     },

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 */ }
@@ -291,7 +305,8 @@ 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) {
@@ -316,6 +331,8 @@ function resultOf(executable, argv, result) {
 
 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 });
@@ -344,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}` }],
@@ -391,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 };
       }
@@ -405,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/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

@@ -13,6 +13,7 @@ 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
@@ -49,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;
@@ -232,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;
@@ -259,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;
@@ -274,8 +280,9 @@ 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.captureFrozen(snapshot, { canCommit: () => refreshReplayLock(projectDir, held) });
@@ -283,6 +290,7 @@ export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_
         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);
@@ -292,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;
@@ -302,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' }) };
@@ -327,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;
@@ -336,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-outbox.mjs

@@ -157,13 +157,21 @@ export class ProgressionOutbox {
     const committed = new Map();
     const quarantined = new Map();
     const recoveries = [];
+    let ordinal = 0;
     for (const record of readJsonl(this.path)) {
+      ordinal += 1;
       requireIdentity(record?.eventKey, 'outbox eventKey');
       requireIdentity(record?.payloadDigest, 'outbox payloadDigest');
       if (record.type === 'snapshot') {
         const prior = snapshots.get(record.eventKey);
         if (prior && prior.payloadDigest !== record.payloadDigest) quarantined.set(record.eventKey, 'outbox event key collision');
-        else snapshots.set(record.eventKey, record);
+        // Retain identity/recovery metadata, never every historical snapshot's full payload.
+        // A second incremental scan materializes only the unresolved payloads selected here.
+        else snapshots.set(record.eventKey, { eventKey: record.eventKey, payloadDigest: record.payloadDigest,
+          ordinal, recoveryDiagnostics: record.snapshot?.recoveryDiagnostics && {
+            originalEventKey: record.snapshot.recoveryDiagnostics.originalEventKey,
+            frozenPayloadDigest: record.snapshot.recoveryDiagnostics.frozenPayloadDigest,
+          }, snapshotDigest: record.snapshot?.payloadDigest });
       } else if (record.type === 'commit') {
         const prior = committed.get(record.eventKey);
         if (prior && prior !== record.payloadDigest) quarantined.set(record.eventKey, 'outbox commit collision');
@@ -186,19 +194,27 @@ export class ProgressionOutbox {
       }
     }
     const recovered = new Set(recoveries.filter((record) => {
-      const target = snapshots.get(record.recoveryEventKey)?.snapshot;
+      const target = snapshots.get(record.recoveryEventKey);
       return !quarantined.has(record.recoveryEventKey)
         && committed.get(record.recoveryEventKey) === record.recoveryPayloadDigest
-        && target?.payloadDigest === record.recoveryPayloadDigest
+        && target?.snapshotDigest === record.recoveryPayloadDigest
         && target.recoveryDiagnostics?.originalEventKey === record.eventKey
         && target.recoveryDiagnostics?.frozenPayloadDigest === record.payloadDigest;
     }).map((record) => `${record.eventKey}:${record.payloadDigest}`));
     this.quarantine = [...quarantined].map(([eventKey, reason]) => ({ eventKey, reason }));
-    return [...snapshots.values()]
+    const pending = new Map([...snapshots.values()]
       .filter((record) => !quarantined.has(record.eventKey) && !committed.has(record.eventKey)
         && !recovered.has(`${record.eventKey}:${record.payloadDigest}`))
-      .sort((left, right) => left.eventKey.localeCompare(right.eventKey))
-      .map((record) => record.snapshot);
+      .map((record) => [record.ordinal, record.eventKey]));
+    const payloads = [];
+    ordinal = 0;
+    if (pending.size) {
+      for (const record of readJsonl(this.path)) {
+        ordinal += 1;
+        if (pending.has(ordinal)) payloads.push({ eventKey: pending.get(ordinal), snapshot: record.snapshot });
+      }
+    }
+    return payloads.sort((left, right) => left.eventKey.localeCompare(right.eventKey)).map((record) => record.snapshot);
   }
 
   /** Keys pendingSnapshots() refused to replay because their records disagree, with the reason. */

package/plugin/scripts/project-progression-session-start.mjs

@@ -8,6 +8,7 @@ import { withProgressionReader } from './project-progression-reader.mjs';
 import { drainCaptureQueue, queuedWork } from './session-snapshot-hook.mjs';
 import { replayTurnQueue } from './turn-outcome-capture.mjs';
 import { STAGE_BUDGETS_MS } from './session-start-budget.mjs';
+import { operatorProgressionSuspension } from './project-progression-suspension.mjs';
 
 const PROGRESSION_NAMESPACE = 'project-progression';
 
@@ -191,6 +192,15 @@ export function restoreProgressionForSession({
   },
 } = {}) {
   const projectDir = env.CLAUDE_PROJECT_DIR || cwd;
+  try {
+    if (operatorProgressionSuspension(env)) {
+      // Turn recording is independent: suspension must not strand ordinary AgentDB capture.
+      const turns = replayTurnQueue({ projectDir, env, home: env.HOME || os.homedir(), synchronous: true,
+        deadlineMs: Date.now() + deadlineMs });
+      return { status: 'unavailable', reason: 'operator-suspended', severity: 'info', pendingTurns: turns.pending,
+        context: '[RuvNet Brain — PROJECT CONTINUITY UNAVAILABLE]\nAutomatic progression capture, replay and restore are operator-suspended. Evidence and queues are preserved. Ordinary AgentDB memory and explicit checkpoints remain available; no project progression was restored.' };
+    }
+  } catch { return unknown('restore-failed'); }
   let resolution;
   try {
     resolution = resolveProjectStore({ projectDir });

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

@@ -0,0 +1,60 @@
+// Operator containment only (#390 B). No store, checkpoint, event, turn or search is disabled here.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+
+const suspendedResults = new WeakSet();
+export function progressionSuspensionFile(env = process.env) {
+  return path.join(env.RUVNET_BRAIN_STATE_DIR || path.join(env.HOME || os.homedir(), '.config', 'ruvnet-brain'), 'brain-progression-suspension');
+}
+export function operatorProgressionSuspension(env = process.env) {
+  if (env.RUVNET_BRAIN_PROGRESSION_SUSPENDED === '1') return { source: 'environment' };
+  if (env.RUVNET_BRAIN_PROGRESSION_SUSPENDED && env.RUVNET_BRAIN_PROGRESSION_SUSPENDED !== '0') {
+    throw new Error('invalid automatic progression suspension environment setting');
+  }
+  let value;
+  try { value = JSON.parse(fs.readFileSync(progressionSuspensionFile(env), 'utf8')); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw new Error('automatic progression suspension policy unreadable or invalid'); }
+  if (value?.schemaVersion !== 1 || typeof value.suspended !== 'boolean') {
+    throw new Error('automatic progression suspension policy unreadable or invalid');
+  }
+  return value.suspended ? { source: 'operator-state' } : null;
+}
+export function automaticProgressionSuspensionResult(env = process.env, fields = {}) {
+  const control = operatorProgressionSuspension(env);
+  if (!control) return null;
+  const result = Object.freeze({ ...fields, progressionSuspended: true, progressionCaptured: false,
+    receipt: null, skipped: 'operator suspended automatic project progression', suspensionSource: control.source });
+  suspendedResults.add(result);
+  return result;
+}
+// A look-alike public flag is never authority to bypass an unexpected capture failure.
+export const isAutomaticProgressionSuspension = (result) => Boolean(result && suspendedResults.has(result));
+
+/** Explicit operator configuration: replacing this control file never touches evidence or queues. */
+export function setOperatorProgressionSuspension(suspended, { env = process.env } = {}) {
+  if (typeof suspended !== 'boolean') throw new TypeError('suspended must be a boolean');
+  const file = progressionSuspensionFile(env);
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, JSON.stringify({ schemaVersion: 1, suspended }), { flag: 'wx', mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } finally { try { fs.unlinkSync(temporary); } catch { /* renamed or not created */ } }
+  return operatorProgressionSuspension(env);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  try {
+    const argv = process.argv.slice(2);
+    if (argv.length !== 1 || !['--suspend', '--resume', '--status'].includes(argv[0])) {
+      throw new Error('usage: project-progression-suspension.mjs --suspend | --resume | --status');
+    }
+    if (argv[0] !== '--status') setOperatorProgressionSuspension(argv[0] === '--suspend');
+    const control = operatorProgressionSuspension();
+    console.log(JSON.stringify({ automaticProgression: control ? 'operator-suspended' : 'enabled', source: control?.source || null,
+      evidencePreserved: true, explicitCheckpointsAvailable: true }));
+  } catch (error) { console.error(error.message); process.exitCode = 1; }
+}

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

@@ -5,9 +5,11 @@ import crypto from 'node:crypto';
 import os from 'node:os';
 import { developmentHooksSuspended } from './development-maintenance.mjs';
 import { resolveTurnDb } from './turn-outcome-capture.mjs';
+import { automaticProgressionSuspensionResult } from './project-progression-suspension.mjs';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { redactText } from './continuity-events.mjs';
+import { conditionNotice } from './continuity-journal.mjs';
 import { normalizeHostEvent } from './hook-input.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { withProgressionReader } from './project-progression-reader.mjs';
@@ -148,7 +150,9 @@ export function observeTransitionSource(resolution, projectDir = resolution.chec
 
 /** Called only by the fenced queue drainer; current heads merge, original observations stay fixed. */
 export function captureNormalizedTransition(job, { readHistory = readTransitionHistory, capture = runSessionSnapshotHook,
-  budgetMs = 6500, makeStoreFactory, now = Date.now } = {}) {
+  budgetMs = 6500, makeStoreFactory, now = Date.now, env = process.env } = {}) {
+  const suspended = automaticProgressionSuspensionResult(env);
+  if (suspended) return suspended;
   const deadlineAt = now() + budgetMs;
   const resolution = resolveProjectStore({ projectDir: job.originProjectDir, gitTimeoutMs: Math.max(1, Math.min(500, budgetMs)) });
   const normalized = job.payload.normalizedTransition;
@@ -173,7 +177,7 @@ export function captureNormalizedTransition(job, { readHistory = readTransitionH
   const progression = buildRestoredTransitionProgression({ resolution, observation: normalized.observation,
     snapshots, sessionIdentity: job.payload.session_id, host: job.host,
     sourceIdentity: normalized.sourceIdentity }, restored);
-  const result = capture(job.originProjectDir, job.event, { host: job.host, budgetMs: Math.max(0, deadlineAt - now()),
+  const result = capture(job.originProjectDir, job.event, { host: job.host, env, budgetMs: Math.max(0, deadlineAt - now()),
     ...(makeStoreFactory ? { makeStoreFactory } : {}), writeMetadata: false,
     rawInput: JSON.stringify({ session_id: job.payload.session_id, hook_event_name: job.event, projectProgression: progression }),
     captureTurn: () => ({ recorded: false, skipped: 'transition boundary' }),
@@ -184,6 +188,8 @@ export function captureNormalizedTransition(job, { readHistory = readTransitionH
 export function runProjectTransitionHook(projectDir, event, { payload = {}, host = process.env.RUVNET_HOOK_HOST || 'claude',
   readHistory = readTransitionHistory, capture = runSessionSnapshotHook, env = process.env } = {}) {
   if (developmentHooksSuspended(projectDir)) return { state: 'skipped', reason: 'development hooks suspended' };
+  const suspended = automaticProgressionSuspensionResult(env, { state: 'suspended', reason: 'automatic project progression is operator-suspended' });
+  if (suspended) return suspended;
   const observation = normalizeTransition(payload, event, { host });
   if (observation.skipped) return { state: 'skipped', reason: observation.skipped };
   const brainHome = env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain');
@@ -194,22 +200,33 @@ export function runProjectTransitionHook(projectDir, event, { payload = {}, host
   const transportEvent = event === 'PostToolUseFailure' ? 'PostToolUse' : event;
   // Fsync the selected observation BEFORE any history enumeration/merge. A deadline, corruption,
   // or long-lived project must leave it pending rather than erase it or fabricate root ancestry.
-  const queued = queueCapture({ projectDir: resolution.projectRoot, originProjectDir: projectDir, event: transportEvent, host,
+  const queued = queueCapture({ projectDir: resolution.projectRoot, originProjectDir: projectDir, env, event: transportEvent, host,
     payload: { session_id: payload.session_id, hook_event_name: transportEvent,
       normalizedTransition: { observation, sourceIdentity: observeTransitionSource(resolution, projectDir) } } });
   if (!queued) return { state: 'degraded', reason: 'normalized observation queue unwritable', eventId: observation.id };
   let result = null;
-  runOutboxReplay({ projectDir: resolution.projectRoot, budgetMs: Math.min(6500, effectiveBudgetMs(env)),
-    captureNormalized: (job, options) => captureNormalizedTransition(job, { ...options, readHistory, capture }),
+  runOutboxReplay({ projectDir: resolution.projectRoot, env, budgetMs: Math.min(6500, effectiveBudgetMs(env)),
+    captureNormalized: (job, options) => captureNormalizedTransition(job, { ...options, env, readHistory, capture }),
     onCaptured: (captured) => { if (captured?.eventId === observation.id) result = captured; } });
-  if (!result?.receipt) replayOutboxDetached({ projectDir: resolution.projectRoot });
+  if (!result?.receipt) replayOutboxDetached({ projectDir: resolution.projectRoot, env });
   return { state: result?.progressionCaptured && result.receipt ? 'committed' : 'pending', eventId: observation.id, result };
 }
 
+/** One pending-readback condition across prompt/tool boundaries and both CLI entrypoints. */
+export function transitionPendingNotice(projectDir, payload, message) {
+  const { projectRoot } = resolveProjectStore({ projectDir, gitTimeoutMs: 500 });
+  return conditionNotice({ swarm: path.join(projectRoot, '.swarm'),
+    session: normalizeHostEvent(payload)?.session_id, condition: 'project-transition-pending-readback', message });
+}
+
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   try {
     const payload = JSON.parse(fs.readFileSync(0, 'utf8') || '{}');
-    const result = runProjectTransitionHook(payload.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd(), process.argv[2], { payload });
-    if (result.state === 'pending') process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: process.argv[2], additionalContext: 'Project memory transition is pending; exact AgentDB readback was not verified at this boundary.' } }));
+    const projectDir = payload.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    const result = runProjectTransitionHook(projectDir, process.argv[2], { payload });
+    if (result.state === 'pending') {
+      const message = transitionPendingNotice(projectDir, payload, 'Project memory transition is pending; exact AgentDB readback was not verified at this boundary.');
+      if (message) process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: process.argv[2], additionalContext: message } }));
+    }
   } catch { process.stdout.write(JSON.stringify({ systemMessage: 'Project memory transition capture degraded; exact readback was not verified.' })); }
 }

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

@@ -17,6 +17,7 @@ import { ProjectProgressionStore } from './project-progression-store.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { resolveTurnDb, captureTurnOutcome } from './turn-outcome-capture.mjs';
 import { captureContinuityEvents, stopNotice } from './continuity-journal.mjs';
+import { automaticProgressionSuspensionResult } from './project-progression-suspension.mjs';
 
 /**
  * The capture boundary's whole budget. hooks.json declares 10s; this keeps the internal work well
@@ -158,6 +159,8 @@ export function runSessionSnapshotHook(projectDir, event, {
     continuity = { recorded: 0, skipped: `continuity capture failed: ${error.message}` };
   }
   const idle = { metadataWritten, progressionCaptured: false, receipt: null, turn, continuity };
+  const operatorSuspended = automaticProgressionSuspensionResult(env, idle);
+  if (operatorSuspended) return operatorSuspended;
 
   if (hasProjectProgression(payload)) {
     if (payload.hook_event_name !== event) {
@@ -206,7 +209,7 @@ export function runSessionSnapshotHook(projectDir, event, {
     try { frozen = produce({ resolution, projectDir, payload, host, trigger: event }); } catch { frozen = null; }
     const queued = frozen?.projectProgression ? queueCapture({ projectDir: root, originProjectDir: projectDir, env, event, host,
       payload: { session_id: payload.session_id, hook_event_name: event, projectProgression: frozen.projectProgression } }) : null;
-    const handed = queued ? spawnReplay({ projectDir: root, token }) : false;
+    const handed = queued ? spawnReplay({ projectDir: root, token, env }) : false;
     if (!handed && token && token !== ordered) releaseReplayLock(root, token);
     return { ...idle, replayed: 0, progressionCaptured: false, deferredToReplayer: Boolean(queued),
       replaySkipped: `${why}; this capture ${queued ? 'queued behind it' : 'NOT queued (queue unwritable)'}`
@@ -262,7 +265,7 @@ export function runSessionSnapshotHook(projectDir, event, {
       // NOT LOST — DEFERRED. capture() fsyncs the snapshot to the durable outbox BEFORE it writes to
       // the store, so a budget overrun leaves the evidence on disk. On a short budget nothing later in
       // this process can settle it, so the lock goes straight to a detached worker.
-      handedLock = !ordered && budgetMs < REPLAY_MIN_BUDGET_MS && pendingCount() > 0 && spawnReplay({ projectDir: root, token });
+      handedLock = !ordered && budgetMs < REPLAY_MIN_BUDGET_MS && pendingCount() > 0 && spawnReplay({ projectDir: root, token, env });
       return { ...idle, replayed, skipped: `capture deferred: ${error.message}`,
         ...(handedLock ? { replaySkipped: 'deferred capture handed to a detached worker' } : {}) };
     }
@@ -281,9 +284,9 @@ export function runSessionSnapshotHook(projectDir, event, {
     // simultaneous SessionEnds lost the second one's final state (4.4.1). So: queued work → hand THIS
     // lock to a worker; and re-check after releasing, for a boundary that queued in between.
     if (!ordered && !handedLock) {
-      if (!(queuedWork(root) && spawnReplay({ projectDir: root, token }))) {
+      if (!(queuedWork(root) && spawnReplay({ projectDir: root, token, env }))) {
         releaseReplayLock(root, token);
-        if (queuedWork(root)) spawnReplay({ projectDir: root });
+        if (queuedWork(root)) spawnReplay({ projectDir: root, env });
       }
     }
   }
@@ -297,10 +300,14 @@ if (process.argv[1] && path.resolve(process.argv[1]).endsWith('session-snapshot-
   // Finish evaluating this module before importing its transition consumer.
   void (async () => {
   try {
-    const { runProjectTransitionHook } = await import('./project-transition-hook.mjs');
+    const { runProjectTransitionHook, transitionPendingNotice } = await import('./project-transition-hook.mjs');
     const payload = JSON.parse(fs.readFileSync(0, 'utf8') || '{}');
-    const result = runProjectTransitionHook(payload.cwd || projectDirectory(), process.argv[2], { payload });
-    if (result.state === 'pending') process.stdout.write(JSON.stringify({ systemMessage: 'Project memory transition remains pending; exact readback was not verified.' }));
+    const projectDir = payload.cwd || projectDirectory();
+    const result = runProjectTransitionHook(projectDir, process.argv[2], { payload });
+    if (result.state === 'pending') {
+      const message = transitionPendingNotice(projectDir, payload, 'Project memory transition remains pending; exact readback was not verified.');
+      if (message) process.stdout.write(JSON.stringify({ systemMessage: message }));
+    }
   } catch { process.stdout.write(JSON.stringify({ systemMessage: 'Project memory transition capture degraded; exact readback was not verified.' })); }
   })();
 } else if (process.argv[1] && path.resolve(process.argv[1]).endsWith('session-snapshot-hook.mjs')) {

package/plugin/scripts/turn-outcome-capture.mjs

@@ -110,10 +110,12 @@ export function claudeTurn(lines) {
 }
 
 function readTail(file, bytes = TRANSCRIPT_TAIL_BYTES) {
-  const size = fs.statSync(file).size;
-  const offset = Math.max(0, size - bytes);
   const handle = fs.openSync(file, 'r');
   try {
+    const stat = fs.fstatSync(handle);
+    if (!stat.isFile()) throw new Error('Transcript must be a regular file');
+    const size = stat.size;
+    const offset = Math.max(0, size - bytes);
     const buf = Buffer.alloc(size - offset);
     fs.readSync(handle, buf, 0, buf.length, offset);
     const lines = buf.toString('utf8').split(/\r?\n/);
@@ -128,7 +130,9 @@ export function readSettledTranscript(file, { stableMs = 400, maxMs = 2000, slee
   const deadline = Date.now() + Math.max(0, maxMs);
   let size = -1;
   for (;;) {
-    const now = fs.statSync(file).size;
+    const stat = fs.statSync(file);
+    if (!stat.isFile()) throw new Error('Transcript must be a regular file');
+    const now = stat.size;
     if (now === size || Date.now() >= deadline) break;
     size = now;
     pause(Math.min(stableMs, Math.max(0, deadline - Date.now())));

package/scripts/release-qualification-contract.mjs

@@ -44,7 +44,9 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
       "files": [
         "tests/unit/automatic-hook-retirement.test.mjs",
         "tests/unit/install-activation-rollback.test.mjs",
-        "tests/unit/forge-update-apply-rollback.test.mjs"
+        "tests/unit/forge-update-apply-rollback.test.mjs",
+        "tests/unit/forge-update-archive-digest.test.mjs",
+        "tests/unit/kb-copy-proof-legacy-sidecars.test.mjs"
       ]
     },
     {
@@ -93,7 +95,8 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
       "files": [
         "tests/unit/nightly-scheduler.test.mjs",
         "tests/unit/nightly-refresh-launcher.test.mjs",
-        "tests/unit/nightly-two-run-proof.test.mjs"
+        "tests/unit/nightly-two-run-proof.test.mjs",
+        "tests/unit/nightly-refresh-run-health.test.mjs"
       ]
     },
     {
@@ -151,13 +154,31 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
         "tests/mutation/citation-binding-mutation.test.mjs"
       ]
     },
+    {
+      "id": "owner-capture-and-off-controls",
+      "reason": "Brain OFF suppresses capacity execution; promise opt-out suppresses only new capture and preserves existing closure and capability truth",
+      "files": [
+        "tests/unit/capacity-aware-parallel-work.test.mjs",
+        "tests/unit/continuation-gate-capability-truth.test.mjs",
+        "tests/unit/continuation-gate-completion-claims.test.mjs"
+      ]
+    },
+    {
+      "id": "active-managed-generation",
+      "reason": "Active code selection binds help authorization and execution to one immutable leased generation across promotion",
+      "files": [
+        "tests/unit/managed-cli-generation.test.mjs"
+      ]
+    },
     {
       "id": "pending-memory-durability",
       "reason": "Complete outbox tails replay and accepted pending journal events survive capacity pressure without silent deletion",
       "files": [
         "tests/unit/project-progression-outbox.test.mjs",
         "tests/unit/project-progression-durability.test.mjs",
-        "tests/unit/continuity-customer-regressions.test.mjs"
+        "tests/unit/continuity-customer-regressions.test.mjs",
+        "tests/unit/progression-outbox-containment.test.mjs",
+        "tests/unit/transition-pending-notices.test.mjs"
       ]
     }
   ],
@@ -166,7 +187,8 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
       "id": "native-explicit-interface",
       "reason": "Real MCP subprocess readiness, command policy and literal argv safety",
       "files": [
-        "tests/integration/managed-cli-mcp.test.mjs"
+        "tests/integration/managed-cli-mcp.test.mjs",
+        "tests/integration/managed-cli-server-boundary.test.mjs"
       ]
     },
     {
@@ -219,7 +241,8 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
         "tests/unit/turn-durable-transport.test.mjs",
         "tests/integration/automatic-progression-continuation.test.mjs",
         "tests/integration/capture-consent-boundary.test.mjs",
-        "tests/integration/session-start-turn-replay.test.mjs"
+        "tests/integration/session-start-turn-replay.test.mjs",
+        "tests/integration/progression-suspension.test.mjs"
       ]
     },
     {