ruvnet-brain 4.5.13 → 4.5.15

package/README.md

@@ -7,7 +7,7 @@ Created: 2026-06-29 22:36:38 EDT
 
 # 🧠 RuvNet Brain
 
-### 🧠 RuvNet Brain — [![RuvNet Brain version 4.5.13 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.5.13-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.15 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.5.15-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/bin/install.mjs

@@ -1750,6 +1750,42 @@ function atomicReplace(targetPath, writeTmp) {
   }
 }
 
+function legacyBrainWrapperOwnership(wrapperPath, home) {
+  const source = path.join(REPO_ROOT, 'plugin', 'scripts', 'codex-hook-wrapper.mjs');
+  try {
+    const canonicalHome = fs.realpathSync(home);
+    if (path.resolve(wrapperPath) !== path.resolve(home, '.cache', 'ruvnet-brain', 'codex-hook.mjs')) {
+      return { state: 'conflict', reason: 'bridge is outside the expected Brain namespace' };
+    }
+    for (const relative of ['.cache', path.join('.cache', 'ruvnet-brain')]) {
+      const ancestor = path.join(home, relative);
+      let parent;
+      try { parent = fs.lstatSync(ancestor); } catch (error) {
+        if (error.code === 'ENOENT') break;
+        throw error;
+      }
+      if (!parent.isDirectory() || parent.isSymbolicLink()
+        || fs.realpathSync(ancestor) !== path.join(canonicalHome, relative)
+        || (typeof process.getuid === 'function' && parent.uid !== process.getuid())) {
+        return { state: 'conflict', reason: 'bridge namespace is indirect or belongs to another owner' };
+      }
+    }
+  } catch { return { state: 'conflict', reason: 'bridge namespace could not be verified' }; }
+  let stat;
+  try { stat = fs.lstatSync(wrapperPath); } catch (error) {
+    if (error.code === 'ENOENT') return { state: 'absent' };
+    return { state: 'conflict', reason: 'existing bridge could not be inspected' };
+  }
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1
+    || (typeof process.getuid === 'function' && stat.uid !== process.getuid())) {
+    return { state: 'conflict', reason: 'existing bridge is not an unshared regular file' };
+  }
+  try {
+    if (fs.readFileSync(wrapperPath).equals(fs.readFileSync(source))) return { state: 'verified' };
+  } catch { /* Missing proof is not ownership. */ }
+  return { state: 'conflict', reason: 'existing bridge differs from the shipped Brain source' };
+}
+
 export function wireCodexHost({
   codexDir = codexHomeDir(),
   configPath = path.join(codexDir, 'config.toml'),
@@ -1763,6 +1799,14 @@ export function wireCodexHost({
   // No Codex on this machine is not a warning. Say nothing and change nothing.
   if (!host) return { host: false, action: 'no-host' };
 
+  // Check ownership before retiring registrations or changing any installed bytes.
+  const wrapperOwnership = legacyBrainWrapperOwnership(hookWrapperPath, path.dirname(codexDir));
+  if (wrapperOwnership.state === 'conflict') {
+    if (announce) warn(`Codex hook bridge preserved: ${wrapperOwnership.reason}`);
+    return { host: true, action: 'hook-wrapper-ownership-conflict', hookWrapperInstalled: false,
+      error: wrapperOwnership.reason };
+  }
+
   if (announce) {
     step('Wiring the Codex host', 'Codex reads MCP servers from ~/.codex/config.toml — the brain was never registered there');
   }
@@ -1819,12 +1863,12 @@ export function wireCodexHost({
   // the versioned cache so a plugin refresh cannot leave Codex pointing at a missing executable.
   // The bridge resolves the active immutable generation on every fire and fails open on every
   // non-contract error; only the two continuity registrations use it.
-  retireManagedHookRegistrations({ home: path.dirname(codexDir), codexDir, wrapperPath: hookWrapperPath });
   const hookWrapperSource = path.join(REPO_ROOT, 'plugin', 'scripts', 'codex-hook-wrapper.mjs');
   if (!fs.existsSync(hookWrapperSource)) {
     if (announce) warn(`Codex hook bridge source missing from this bundle: ${hookWrapperSource}`);
     return { host: true, action: 'hook-wrapper-source-missing' };
   }
+  let hookRetirement;
   try {
     fs.mkdirSync(path.dirname(hookWrapperPath), { recursive: true });
     const wrapperStat = (() => { try { return fs.lstatSync(hookWrapperPath); } catch (error) {
@@ -1833,11 +1877,17 @@ export function wireCodexHost({
     if (wrapperStat?.isSymbolicLink()) {
       throw new Error('installer-owned hook bridge path is a symlink; refusing to overwrite it');
     }
+    const currentOwnership = legacyBrainWrapperOwnership(hookWrapperPath, path.dirname(codexDir));
+    if (currentOwnership.state === 'conflict') throw new Error(currentOwnership.reason);
+    hookRetirement = retireManagedHookRegistrations({ home: path.dirname(codexDir), codexDir, wrapperPath: hookWrapperPath });
     atomicReplace(hookWrapperPath, (tmp) => fs.copyFileSync(hookWrapperSource, tmp));
   } catch (error) {
     if (announce) warn(`could not install the Codex hook bridge at ${hookWrapperPath}: ${error.message}`);
     return { host: true, action: 'hook-wrapper-install-failed', error: error.message };
   }
+  if (announce && hookRetirement.conflicts.length) {
+    warn(`Preserved ${hookRetirement.conflicts.length} customized or unverified hook entries.`);
+  }
 
   let before = '';
   try { before = fs.readFileSync(configPath, 'utf8'); } catch { /* first run — no config yet */ }
@@ -1848,7 +1898,7 @@ export function wireCodexHost({
       info(`  to hand it to us instead, delete that ${c.bold('[mcp_servers.ruvnet-brain]')} block and re-run this installer`);
     }
     return { host: true, action, serverPath, managedCliPath, runtimePreferencesPath,
-      hookWrapperPath, hookWrapperInstalled: true };
+      hookWrapperPath, hookWrapperInstalled: true, hookOwnershipConflicts: hookRetirement.conflicts.length };
   }
   if (text !== before) {
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
@@ -1860,7 +1910,8 @@ export function wireCodexHost({
     info(`  ${c.dim('only our marked block is written; every other section is byte-preserved')}`);
   }
   return { host: true, action, serverPath, managedCliPath, runtimePreferencesPath,
-    hookWrapperPath, hookWrapperInstalled: true, changed: text !== before };
+    hookWrapperPath, hookWrapperInstalled: true, hookOwnershipConflicts: hookRetirement.conflicts.length,
+    changed: text !== before };
 }
 
 const CODEX_PLUGIN_ID = 'ruvnet-brain@ruvnet-brain';
@@ -2140,8 +2191,18 @@ export function codexSessionSafety(status) {
   };
 }
 
+function codexAdministrativeProbeBinary() {
+  if (process.env.CODEX_BIN) return process.env.CODEX_BIN;
+  try {
+    const brainHome = process.env.RUVNET_BRAIN_HOME || path.join(os.homedir(), '.cache', 'ruvnet-brain');
+    const configured = JSON.parse(fs.readFileSync(path.join(brainHome, 'model-routing', 'terminal-launcher-config.json'), 'utf8'));
+    if (typeof configured.realCodex === 'string' && path.isAbsolute(configured.realCodex)) return configured.realCodex;
+  } catch { /* absent or malformed configuration retains the ordinary bounded PATH probe */ }
+  return 'codex';
+}
+
 function codexHooksList({
-  codexBin = process.env.CODEX_BIN || 'codex',
+  codexBin = codexAdministrativeProbeBinary(),
   codexHome = codexHomeDir(),
   cwd = process.cwd(),
   timeoutMs = 8_000,
@@ -2316,23 +2377,62 @@ export function codexLifecycleGuidance(status) {
   }
 }
 
-// Remove only explicit Brain ownership or the exact installer-owned durable bridge.
+// Remove only byte-verified Brain bridges with an exact shipped hook definition.
 // Foreign commands, mixed command strings, unknown shapes, and their surrounding settings survive.
 export function retireManagedHookRegistrations({ home = os.homedir(), codexDir = codexHomeDir(),
   files = [path.join(home, '.claude', 'settings.json'), path.join(home, '.claude', 'settings.local.json'),
     path.join(codexDir, 'hooks.json')], wrapperPath = codexHookWrapperPath(codexDir) } = {}) {
   let removed = 0;
   const changedFiles = [];
-  const owns = (hook) => {
-    if (hook?.pluginId === 'ruvnet-brain@ruvnet-brain') return true;
+  const conflicts = [];
+  const verifiedWrapper = legacyBrainWrapperOwnership(wrapperPath, path.dirname(codexDir)).state === 'verified';
+  const tokensOf = (command) => (command.match(/"[^"]*"|'[^']*'|[^\s]+/g) || [])
+    .map((token) => token.replace(/^["']|["']$/g, ''));
+  const registry = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'plugin', 'hooks', 'codex-hooks.json'), 'utf8'));
+  const definitions = Object.entries(registry.hooks).flatMap(([event, groups]) => groups.flatMap(group =>
+    group.hooks.flatMap(hook => {
+      const values = typeof hook.command === 'string' ? tokensOf(hook.command) : [];
+      return values[0] === 'node' && values[1] === '-e' && /^\d+$/.test(values[3] || '')
+        ? [{ event, matcher: String(group.matcher ?? '*'), hook, args: values.slice(4) }] : [];
+    })));
+  const owns = (hook, event, group) => {
     const command = hook?.command;
-    if (typeof command !== 'string' || /[;&|`\n\r]/.test(command)) return false;
-    const tokens = command.match(/"[^"]*"|'[^']*'|[^\s]+/g) || [];
-    const values = tokens.map((token) => token.replace(/^["']|["']$/g, ''));
-    return values.length >= 2 && /(?:^|[/\\])node(?:\.exe)?$/.test(values[0])
-      && values[1] === wrapperPath;
+    if (!verifiedWrapper || typeof command !== 'string' || hook.type !== 'command'
+      || (hook.pluginId != null && hook.pluginId !== 'ruvnet-brain@ruvnet-brain')
+      || Object.keys(group).some(key => !['matcher', 'hooks'].includes(key))) return false;
+    return definitions.some(definition => {
+      if (definition.event !== event || definition.matcher !== String(group.matcher ?? '*')) return false;
+      if (Object.keys(hook).some(key => !['command', 'pluginId', ...Object.keys(definition.hook)].includes(key))) return false;
+      if (Object.keys(definition.hook).some(key => key !== 'command' && hook[key] !== definition.hook[key])) return false;
+      if (Object.keys(hook).some(key => !['command', 'pluginId'].includes(key)
+        && hook[key] !== definition.hook[key])) return false;
+      if (command === definition.hook.command) return true;
+      if (/[;&|`$\n\r]/.test(command)) return false;
+      // Match literal installer forms, not a shell-like split: adjacent quoted tokens
+      // can execute a different script even when a permissive splitter looks identical.
+      if (/["']/.test(wrapperPath) || (process.platform !== 'win32' && wrapperPath.includes('\\'))
+        || (process.platform === 'win32' && /[%!^]/.test(command))
+        || definition.args.some(arg => !/^[\w-]+$/.test(arg))) return false;
+      const scripts = [`"${wrapperPath}"`];
+      if (process.platform !== 'win32') scripts.push(`'${wrapperPath}'`);
+      if (/^[\w/.:~-]+$/.test(wrapperPath)) scripts.push(wrapperPath);
+      const nodes = ['node', `"${process.execPath}"`];
+      if (process.platform !== 'win32') nodes.push(`'${process.execPath}'`);
+      if (/^[\w/.:~-]+$/.test(process.execPath)) nodes.push(process.execPath);
+      return nodes.some(node => scripts.some(script =>
+        command === `${node} ${script} ${definition.args.join(' ')}`));
+    });
   };
   for (const file of files) {
+    let stat;
+    try { stat = fs.lstatSync(file); } catch (error) {
+      if (error.code === 'ENOENT') continue;
+      throw error;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) {
+      conflicts.push({ file, reason: 'shared or indirect settings preserved' });
+      continue;
+    }
     let before;
     try { before = fs.readFileSync(file, 'utf8'); } catch (error) {
       if (error.code === 'ENOENT') continue;
@@ -2345,7 +2445,16 @@ export function retireManagedHookRegistrations({ home = os.homedir(), codexDir =
       if (!Array.isArray(groups)) continue;
       document.hooks[event] = groups.flatMap((group) => {
         if (!Array.isArray(group?.hooks)) return [group];
-        const hooks = group.hooks.filter((hook) => { if (!owns(hook)) return true; count++; return false; });
+        const hooks = group.hooks.filter((hook) => {
+          if (!owns(hook, event, group)) {
+            if (hook?.pluginId === 'ruvnet-brain@ruvnet-brain'
+              || (typeof hook?.command === 'string' && hook.command.includes(wrapperPath))) {
+              conflicts.push({ file, event, reason: 'unverified or customized hook preserved' });
+            }
+            return true;
+          }
+          count++; return false;
+        });
         return hooks.length || group.hooks.length === 0 ? [{ ...group, hooks }] : [];
       });
       if (groups.length && document.hooks[event].length === 0) delete document.hooks[event];
@@ -2355,7 +2464,7 @@ export function retireManagedHookRegistrations({ home = os.homedir(), codexDir =
     removed += count;
     changedFiles.push(file);
   }
-  return { removed, changedFiles };
+  return { removed, changedFiles, conflicts };
 }
 
 export function automaticHookRetirementStatus(root = REPO_ROOT, { scope = 'source' } = {}) {
@@ -2997,13 +3106,7 @@ async function doctorRun({ json }) {
       hostConvergence = classifyHostConvergence(recorded);
       const codex = recorded.hosts?.codex;
       if (codex?.state === 'ready' && codex.restartRequired === true && codex.restartScope === 'unproven') {
-        let binary = process.env.CODEX_BIN || 'codex';
-        if (!process.env.CODEX_BIN) {
-          try {
-            const configured = JSON.parse(fs.readFileSync(path.join(path.dirname(convergencePath), 'model-routing', 'terminal-launcher-config.json'), 'utf8'));
-            if (typeof configured.realCodex === 'string' && path.isAbsolute(configured.realCodex)) binary = configured.realCodex;
-          } catch { /* native PATH resolution remains bounded and fail closed */ }
-        }
+        const binary = codexAdministrativeProbeBinary();
         const fresh = await probeFreshCodexDeclarations({ binary, codexHome: codexHomeDir(), cwd: process.cwd(),
           releasedPluginRoot: path.join(REPO_ROOT, 'plugin'), expectedVersion: PACKAGE_VERSION });
         hostConvergence = reconcileFreshCodexDeclarations(recorded, fresh);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.5.13",
+  "version": "4.5.15",
   "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.13",
+  "version": "4.5.15",
   "author": {
     "name": "Stuart Kerr"
   },

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

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

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

@@ -213,7 +213,11 @@ export function auditCompletionClaims(message, { turn = null, host = 'claude' }
   if (!namesCheck) problems.push('the answer does not name the check that proves it');
   if (!disclosesGaps) problems.push('the answer does not disclose what is NOT verified');
   const transcriptOk = turn ? verification.checks.length > 0 : false;
-  const verdict = transcriptOk && namesCheck && disclosesGaps ? 'PASS' : !turn && namesCheck && disclosesGaps ? 'UNKNOWN' : 'FAIL';
+  const scopedCheck = claims.every(claim => /^(?:The\s+)?(?:targeted|selected|unit|syntax)\s+(?:unit\s+)?(?:checks?|tests?)\s+(?:is|are)\s+(?:now\s+)?(?:passing|green|verified)[.!]?$/i.test(claim.text));
+  // A transcript command is an observed check, not proof of the owner's whole task.
+  if (transcriptOk && namesCheck && disclosesGaps && !scopedCheck) problems.push('observed checks cover only their executed scope; whole-task completion is UNKNOWN');
+  const verdict = transcriptOk && namesCheck && disclosesGaps && scopedCheck ? 'OBSERVED_CHECK'
+    : namesCheck && disclosesGaps ? 'UNKNOWN' : 'FAIL';
   return { verdict, claims, verification, namesCheck, disclosesGaps, problems };
 }
 

package/plugin/scripts/continuation-gate.mjs

@@ -272,16 +272,12 @@ if (has('--complete-objective')) {
   }
   const led = load();
   if (led.objective) {
-    // DERIVED from the required argument checked above, not asserted (ADR-0024 / status-honesty.mjs):
-    // this line is unreachable with blank/missing evidence — the guard exits 2 first. That proves an
-    // explicit, human/model-invoked CLI action supplied named evidence; it does not verify the
-    // evidence is TRUE, which is exactly why continuation-objective.mjs's own header already
-    // documents this ledger as non-authoritative ("neither prove user provenance nor establish task
-    // completion") — a nudge-suppression preference with the reason attached for audit, not a
-    // verified fact standing in for a real completion check.
-    led.objective.state = evidence.trim() ? 'completed' : led.objective.state;
-    led.objective.completedAt = new Date().toISOString();
-    led.objective.completionEvidence = evidence;
+    // Prose is a request, never verified completion or authority to suppress truth audits.
+    led.objective.completionRequestedAt = new Date().toISOString();
+    led.objective.completionRequest = evidence.trim();
+    save(led);
+    console.error('completion unverified: prose cannot complete this objective; retain unfinished work');
+    process.exit(2);
   }
   save(led);
   console.log(led.objective ? `objective completed: ${evidence}` : 'no objective to complete');
@@ -315,8 +311,8 @@ if (has('--help') || has('-h')) {
     '  --set-commitment-state <blocked|deferred|superseded|disputed> --item "<exact text>"',
     '    --session-id "<capturing session>" --reason "<why>" [--replacement "<reference>"]',
     '                                      retain a noncompleted assistant item; user work unchanged',
-    '  --complete-objective "<evidence>"  close the current objective as state: completed, with the',
-    '                                      completion evidence recorded — leaves other ledger items',
+    '  --complete-objective "<evidence>"  request closure; prose alone never marks completed',
+    '                                      unverified requests retain the unfinished objective;',
     '                                      untouched',
     '  --cancel-objective "<reason>"      close the current objective as state: cancelled, with the',
     '                                      reason recorded — leaves other ledger items untouched',
@@ -372,7 +368,7 @@ const completion = (() => {
     const turn = HOST === 'claude' ? readClaudeTurn(hookInput.transcript_path) : null;
     // Claude always sends a JSONL transcript; one we cannot read is OUR failure, and a Stop hook
     // fails open on its own machinery (ADR-074 failure semantics) — never a correction request.
-    if (HOST === 'claude' && !turn) return { verdict: 'NONE', claims: [], unreadable: true };
+    // Missing native evidence stays UNKNOWN; it cannot silently validate a completion claim.
     return auditCompletionClaims(message, { turn, host: HOST });
   } catch { return { verdict: 'NONE', claims: [] }; }
 })();
@@ -427,8 +423,7 @@ promiseBookkeeping();
  * emitted on a stop that is already a continuation.
  */
 if (hookInput.stop_hook_active) process.exit(EXIT_ALLOW);
-// Terminal objectives remain terminal even if legacy/global ledger rows or observations stay open.
-if (['cancelled', 'completed', 'blocked'].includes(led.objective?.state)) process.exit(EXIT_ALLOW);
+// A terminal preference suppresses only its own nudge, never independent truth audits.
 const objective = authorizedContinuationObjective(led.objective, hookInput, projectIdentity);
 
 // LOOP-SAFETY 1b (GPT-5.6-Sol review) — an empty-but-parseable `{}` is NOT a real Stop payload; a genuine
@@ -665,7 +660,7 @@ if (observations.length) console.error(JSON.stringify({ kind: 'continuation-advi
   authority: false, items: observations.map(({ text, at }) => ({ text, at })) }));
 // ONE correction per turn: a single item however many claims the answer made; the stop_hook_active
 // exit and the cooldown lock below bound it to one request per stop episode.
-const completionWork = completion.verdict === 'FAIL' ? [{
+const completionWork = ['FAIL', 'UNKNOWN'].includes(completion.verdict) ? [{
   text: `You claimed "${completion.claims[0].text.slice(0, 160)}" is done; ${completion.problems.join('; ')}. Run the real consumer path, or restate it as UNVERIFIED.`,
   at: new Date(nowMs).toISOString(), derived: true, kind: 'completion-claim-integrity',
 }] : [];
@@ -733,7 +728,9 @@ const ageLabel = (i) => {
  * This replaces a read-lastForcedAt-then-write that failed OPEN on a write error and let two hooks race.
  */
 const COOLDOWN_MS = Number(process.env.RUVNET_CONTINUATION_COOLDOWN_MS ?? 20000);
-const LOCK = LEDGER + '.cooldown';
+const episode = crypto.createHash('sha256').update(JSON.stringify([projectIdentity.projectId, projectIdentity.worktreeId,
+  hookInput.session_id, led.objective?.id ?? null, hookInput.turn_id ?? String(hookInput.last_assistant_message || '')])).digest('hex');
+const LOCK = LEDGER + '.cooldown.' + episode;
 function claimCooldown(now, windowMs) {
   try {
     const prev = Date.parse(fs.readFileSync(LOCK, 'utf8'));
@@ -771,8 +768,8 @@ const header = capabilityClaims.length
   ? ['Your proposed final answer contains a RuvNet capability claim that is contradicted or not provable.',
      'Do NOT deliver it unchanged — continue now and correct the claim from the sealed live-host inventory.']
   : completionClaims.length
-  ? ['Your proposed final answer claims work is done without end-to-end evidence from this turn.',
-     'Do NOT deliver it unchanged — run the real consumer path now, or restate the claim as UNVERIFIED.']
+  ? ['Your proposed final answer claims completion beyond the available verified scope.',
+     'Correct only that claim: report the observed check scope and what remains UNVERIFIED.']
   : committed.length && observed.length
   ? [`You have unfinished work you committed to, and ${repoLabel} has open work of its own.`,
      'Do NOT end the turn — continue now.']
@@ -836,12 +833,4 @@ const lines = [
     : []),
 ];
 
-process.stdout.write(JSON.stringify({
-  hookSpecificOutput: {
-    hookEventName: 'Stop',            // must name the firing event or the envelope is discarded
-    additionalContext: lines.join('\n'),
-  },
-}));
-
-// Exit 0 regardless. This gate informs at the boundary; it never breaks the turn.
-process.exit(EXIT_ALLOW);
+process.stdout.write(JSON.stringify({ decision: 'block', reason: lines.join('\n') }));

package/plugin/scripts/continuation-objective.mjs

@@ -24,7 +24,7 @@ export function authorizedContinuationObjective(objective, input, identity) {
   if (!identity || input?.hook_event_name !== 'Stop' || !text(input.session_id)
     || input.interrupted || input.cancelled || input.stop_hook_active) return null;
   if (objective?.schemaVersion !== 1 || objective.kind !== 'continuation-preferences'
-    || objective.authoritative !== false || objective.state !== 'active'
+    || objective.authoritative !== false || !['active', 'completed'].includes(objective.state)
     || !text(objective.id) || !text(objective.text) || !Number.isFinite(Date.parse(objective.at))
     || objective.authorization?.kind !== 'user' || !text(objective.authorization.reference)
     || objective.projectId !== identity.projectId

package/plugin/scripts/hook-shim.mjs

@@ -185,6 +185,16 @@ const TABLE = {
 };
 
 const hookId = process.argv[2];
+// Native Claude supplies this exact registered plugin root; do not guess a host from absence.
+if (['session-snapshot', 'continuation-gate'].includes(hookId)
+    && process.env.RUVNET_HOOK_HOST === undefined && process.env.CLAUDE_PLUGIN_ROOT) {
+  try {
+    const ownPluginRoot = fs.realpathSync(path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..'));
+    if (fs.realpathSync(process.env.CLAUDE_PLUGIN_ROOT) === ownPluginRoot) process.env.RUVNET_HOOK_HOST = 'claude';
+  } catch { /* Missing or mismatched native registration remains unknown. */ }
+}
+
+
 const entry = TABLE[hookId];
 if (!entry) {
   process.stderr.write(`[hook-shim] unknown hook id: ${JSON.stringify(hookId)} — known: ${Object.keys(TABLE).join(', ')}\n`);

package/scripts/model-managed-prompt.mjs

@@ -30,19 +30,22 @@ function verifyRefs(refs) {
   }
 }
 
-/** Private immutable-by-digest copy of the actual parent transcript, never a generated summary. */
+/** Actual native bytes only; large histories use a source-bound native compaction projection. */
 export async function captureNativeParentContext({ harness, sessionId, env = process.env,
   evidenceRoot = path.join(env.HOME || os.homedir(), '.cache/ruvnet-brain/model-routing/parent-context'),
-  observeCodex } = {}) {
+  observeCodex, deadline = Infinity, signal } = {}) {
   requireValue(process.platform !== 'win32', 'private native parent transcript capture unsupported on Windows; ACL proof unavailable');
   if (!sessionId) return [];
   requireValue(/^[a-f0-9-]{36}$/i.test(sessionId) && ['codex', 'claude-code'].includes(harness), 'native parent identity required');
-  let source, expected;
+  let source, expected, sourceBound, observedTurns, observedBytes;
   if (harness === 'codex') {
     const observe = observeCodex ?? (await import('./model-routing-execution-adapters.mjs')).readCodexWorkerObservation;
-    const observed = observe(sessionId, { home: env.CODEX_HOME || path.join(env.HOME || os.homedir(), '.codex'), allowHistory: true });
+    const observed = observe(sessionId, { home: env.CODEX_HOME || path.join(env.HOME || os.homedir(), '.codex'), allowHistory: true, deadline, signal });
     requireValue(observed?.sessionId === sessionId && HASH.test(observed.evidence?.sha256 || ''), 'actual Codex parent evidence unproven');
-    source = observed.evidence.path; expected = observed.evidence.sha256;
+    source = observed.evidence.path; expected = observed.evidence.sha256; sourceBound = observed.evidence.sourceBound;
+    observedTurns = observed.turnCount; observedBytes = observed.evidence.byteLength;
+    const nativeHome = fs.realpathSync(env.CODEX_HOME || path.join(env.HOME || os.homedir(), '.codex'));
+    requireValue(source.startsWith(path.join(nativeHome, 'sessions') + path.sep), 'parent evidence escaped native session home');
   } else {
     const projects = path.join(env.CLAUDE_CONFIG_DIR || path.join(env.HOME || os.homedir(), '.claude'), 'projects');
     const matches = [];
@@ -57,14 +60,54 @@ export async function captureNativeParentContext({ harness, sessionId, env = pro
   requireValue(path.isAbsolute(source || '') && fs.realpathSync(source) === source, 'canonical native parent transcript required');
   const fd = fs.openSync(source, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW); let bytes;
   try {
-    const before = fs.fstatSync(fd);
-    requireValue(before.isFile() && before.uid === process.getuid?.() && before.size <= 16 * 1024 * 1024, 'owned bounded parent transcript required');
-    bytes = fs.readFileSync(fd); const after = fs.fstatSync(fd), current = fs.lstatSync(source);
-    requireValue(before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs &&
-      current.ino === after.ino && !current.isSymbolicLink(), 'parent transcript changed while captured');
+    const before = fs.fstatSync(fd, { bigint: true }), limit = 16 * 1024 * 1024;
+    requireValue(before.isFile() && before.uid === BigInt(process.getuid()), 'owned bounded parent transcript required');
+    const live = () => requireValue(!signal?.aborted && Date.now() < deadline, 'parent capture cancelled or expired'); live();
+    if (before.size <= BigInt(limit)) {
+      sourceBound = undefined; bytes = Buffer.alloc(Number(before.size)); let offset = 0;
+      while (offset < bytes.length) {
+        live(); const count = fs.readSync(fd, bytes, offset, Math.min(256 * 1024, bytes.length - offset), offset);
+        requireValue(count > 0, 'parent transcript truncated while captured'); offset += count;
+      }
+    }
+    else {
+      requireValue(harness === 'codex' && sourceBound?.kind === 'native-compaction-projection'
+        && sourceBound.nativeSessionId === sessionId && sourceBound.sourceSha256 === expected
+        && sourceBound.sourceBytes === Number(before.size) && sourceBound.sourceBytes === observedBytes
+        && sourceBound.fullTurnCount === observedTurns && sourceBound.omittedHistoryPrefix === true
+        && Number.isSafeInteger(sourceBound.fullTurnCount) && sourceBound.fullTurnCount > 0
+        && Array.isArray(sourceBound.ranges) && sourceBound.ranges.length >= 2 && sourceBound.ranges.length <= 3,
+      'bounded native compaction provenance required');
+      let total = 0, priorEnd = 0;
+      for (const range of sourceBound.ranges) {
+        requireValue(Number.isSafeInteger(range.offset) && range.offset >= priorEnd && Number.isSafeInteger(range.bytes)
+          && range.bytes > 0 && range.offset + range.bytes <= Number(before.size), 'unsafe native projection range');
+        priorEnd = range.offset + range.bytes; total += range.bytes;
+      }
+      requireValue(sourceBound.ranges[0].offset === 0 && priorEnd === Number(before.size) && total <= limit, 'native projection exceeded bound');
+      const hash = crypto.createHash('sha256'), buffer = Buffer.alloc(256 * 1024), parts = []; let offset = 0;
+      while (offset < Number(before.size)) {
+        live(); const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, Number(before.size) - offset), offset);
+        requireValue(count > 0, 'parent transcript truncated while captured'); hash.update(buffer.subarray(0, count));
+        for (const range of sourceBound.ranges) {
+          const start = Math.max(offset, range.offset), end = Math.min(offset + count, range.offset + range.bytes);
+          if (end > start) parts.push(Buffer.from(buffer.subarray(start - offset, end - offset)));
+        }
+        offset += count;
+      }
+      requireValue(hash.digest('hex') === expected, 'parent transcript evidence changed'); bytes = Buffer.concat(parts, total);
+      const rows = new TextDecoder('utf-8', { fatal: true }).decode(bytes).trim().split('\n').map(line => JSON.parse(line));
+      requireValue(rows[0]?.type === 'session_meta' && rows[0].payload?.id === sessionId && rows.filter(row => row.type === 'session_meta').length === 1
+        && rows.some(row => row.type === 'compacted' && Array.isArray(row.payload?.replacement_history)), 'native projection provenance mismatch');
+      sourceBound = { kind: sourceBound.kind, nativeSessionId: sessionId, sourceSha256: expected, sourceBytes: Number(before.size),
+        fullTurnCount: sourceBound.fullTurnCount, omittedHistoryPrefix: true, ranges: sourceBound.ranges, nativeHistoryMutated: false };
+    }
+    const after = fs.fstatSync(fd, { bigint: true }), current = fs.lstatSync(source, { bigint: true });
+    requireValue(['dev', 'ino', 'size', 'mtimeNs', 'ctimeNs'].every(key => before[key] === after[key] && after[key] === current[key])
+      && !current.isSymbolicLink(), 'parent transcript changed while captured'); live();
   } finally { fs.closeSync(fd); }
   const digest = sha(bytes);
-  requireValue(bytes.length > 0 && (!expected || digest === expected), 'parent transcript evidence changed');
+  requireValue(bytes.length > 0 && (!expected || sourceBound || digest === expected), 'parent transcript evidence changed');
   if (harness === 'claude-code') {
     const rows = bytes.toString('utf8').split('\n').filter(Boolean).map(line => JSON.parse(line));
     requireValue(rows.some(row => row.sessionId === sessionId), 'actual Claude transcript session identity missing');
@@ -77,7 +120,7 @@ export async function captureNativeParentContext({ harness, sessionId, env = pro
   const file = path.join(directory, `${sessionId}.jsonl`);
   const output = fs.openSync(file, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_NOFOLLOW, 0o600);
   try { fs.writeFileSync(output, bytes); fs.fsyncSync(output); } finally { fs.closeSync(output); }
-  return [{ path: file, digest }];
+  return [{ path: file, digest, ...(sourceBound ? { sourceBound } : {}) }];
 }
 
 async function service() {
@@ -264,7 +307,7 @@ export async function runManagedPrompt({ originalPrompt, prompt = originalPrompt
     }
     if (!contextRefs.length && (retainedContext.sessionId || retainedContext.threadId)) {
       contextRefs = await bounded(() => captureContext({ harness, sessionId: retainedContext.sessionId ?? retainedContext.threadId,
-        env: primaryOptions.env ?? process.env }));
+        env: primaryOptions.env ?? process.env, deadline, signal: combined }));
       requireValue(contextRefs.length > 0, 'existing parent transcript required');
     }
     requireValue(original.length <= 120000, 'substantive request exceeds bounded completion-frame input');

package/scripts/model-routing-execution-adapters.mjs

@@ -18,36 +18,93 @@ export function nativeWorkflowBinaries(home = os.homedir()) {
   return { claude: config.realClaude, codex: config.realCodex };
 }
 
-export function readCodexWorkerObservation(sessionId, { home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), now = Date.now(), expectedPriorTurns, evidencePath, allowHistory = false } = {}) {
+export function readCodexWorkerObservation(sessionId, { home = process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), now = Date.now(), expectedPriorTurns, evidencePath, expectedPrefix, allowHistory = false, deadline = Infinity, signal } = {}) {
   if (!/^[a-f0-9-]{36}$/.test(sessionId || '')) throw blocked('Native worker session identity missing');
   const matches = [];
   const directories = [];
-  const base = path.join(home, 'sessions');
-  if (evidencePath) directories.push(path.dirname(evidencePath));
+  const base = path.join(fs.existsSync(home) ? fs.realpathSync(home) : home, 'sessions');
+  if (evidencePath) {
+    const directory = fs.realpathSync(path.dirname(evidencePath));
+    if (!directory.startsWith(base + path.sep)) throw blocked('Native evidence escaped its session home');
+    evidencePath = path.join(directory, path.basename(evidencePath)); directories.push(directory);
+  }
   else if ((expectedPriorTurns !== undefined || allowHistory) && fs.existsSync(base)) {
     for (const year of fs.readdirSync(base)) if (/^\d{4}$/.test(year))
       for (const month of fs.readdirSync(path.join(base, year))) if (/^\d{2}$/.test(month))
         for (const day of fs.readdirSync(path.join(base, year, month))) if (/^\d{2}$/.test(day)) directories.push(path.join(base, year, month, day));
   } else for (const offset of [0, 86400000]) {
     const date = new Date(now - offset).toISOString().slice(0, 10).split('-');
-    directories.push(path.join(home, 'sessions', ...date));
+    directories.push(path.join(base, ...date));
   }
   for (const directory of new Set(directories)) {
     if (!fs.existsSync(directory)) continue;
     for (const name of fs.readdirSync(directory)) {
       if (!name.endsWith(`-${sessionId}.jsonl`)) continue;
       const file = path.join(directory, name), stat = fs.lstatSync(file);
-      if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024 * 1024) throw blocked('Unsafe native worker evidence file');
-      matches.push({ file, bytes: fs.readFileSync(file) });
+      if (!stat.isFile() || stat.isSymbolicLink() || fs.realpathSync(file) !== file || process.getuid && stat.uid !== process.getuid()) throw blocked('Unsafe native worker evidence file');
+      if (!evidencePath || evidencePath === file) matches.push({ file });
     }
   }
   if (matches.length !== 1) throw blocked('Exact native worker rollout unavailable or ambiguous');
-  const rows = matches[0].bytes.toString('utf8').trim().split('\n').map(line => JSON.parse(line));
-  const contexts = rows.filter(row => row.type === 'turn_context');
-  if (!contexts.length || !allowHistory && contexts.length !== (expectedPriorTurns === undefined ? 1 : expectedPriorTurns + 1)) throw blocked('Native worker has unexpected turn history');
-  const context = contexts.at(-1).payload;
+  const file = matches[0].file, fd = fs.openSync(file, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+  const limit = 16 * 1024 * 1024, decoder = new TextDecoder('utf-8', { fatal: true }), hash = crypto.createHash('sha256');
+  const prefix = expectedPrefix && crypto.createHash('sha256'), buffer = Buffer.alloc(256 * 1024);
+  let before, offset = 0, rowOffset = 0, rowBytes = 0, parts = [], context, contextRange, meta, compact, turnCount = 0, metaCount = 0;
+  const live = () => { if (signal?.aborted || Date.now() >= deadline) throw blocked('Native evidence capture cancelled or expired'); };
+  const consume = () => {
+    let row;
+    try { row = JSON.parse(decoder.decode(Buffer.concat(parts, rowBytes))); } catch { throw blocked('Malformed native evidence record or UTF-8'); }
+    if (!row || typeof row !== 'object' || typeof row.type !== 'string') throw blocked('Malformed native evidence record');
+    const range = { offset: rowOffset, bytes: rowBytes };
+    if (row.type === 'session_meta') { metaCount++; meta = { ...range, id: row.payload?.id }; }
+    if (row.type === 'turn_context') { turnCount++; context = row.payload; contextRange = range; }
+    if (row.type === 'compacted') {
+      if (!Array.isArray(row.payload?.replacement_history) || !row.payload.replacement_history.length) throw blocked('Native compaction provenance unavailable');
+      compact = range;
+    }
+    rowOffset += rowBytes; rowBytes = 0; parts = [];
+  };
+  try {
+    before = fs.fstatSync(fd, { bigint: true });
+    if (!before.isFile() || process.getuid && before.uid !== BigInt(process.getuid()) || before.size > BigInt(Number.MAX_SAFE_INTEGER)
+      || !process.getuid && before.size > BigInt(limit)) throw blocked('Unsafe native worker evidence file');
+    if (expectedPrefix && (!Number.isSafeInteger(expectedPrefix.bytes) || expectedPrefix.bytes < 0 || expectedPrefix.bytes > Number(before.size)
+      || !/^[a-f0-9]{64}$/.test(expectedPrefix.sha256 || ''))) throw blocked('Native history prefix changed');
+    while (offset < Number(before.size)) {
+      live(); const count = fs.readSync(fd, buffer, 0, Math.min(buffer.length, Number(before.size) - offset), offset);
+      if (!count) throw blocked('Native evidence truncated during capture');
+      hash.update(buffer.subarray(0, count));
+      if (prefix && offset < expectedPrefix.bytes) prefix.update(buffer.subarray(0, Math.min(count, expectedPrefix.bytes - offset)));
+      let start = 0;
+      while (start < count) {
+        const newline = buffer.indexOf(10, start), end = newline >= start && newline < count ? newline + 1 : count;
+        const part = Buffer.from(buffer.subarray(start, end)); rowBytes += part.length;
+        if (rowBytes > limit) throw blocked('Native evidence record exceeded bound');
+        parts.push(part); if (end <= count && buffer[end - 1] === 10) consume(); start = end;
+      }
+      offset += count;
+    }
+    if (rowBytes) { if (Number(before.size) > limit) throw blocked('Partial native evidence terminal record'); consume(); }
+    const after = fs.fstatSync(fd, { bigint: true }), current = fs.lstatSync(file, { bigint: true });
+    if (['dev', 'ino', 'size', 'mtimeNs', 'ctimeNs'].some(key => before[key] !== after[key] || after[key] !== current[key]) || current.isSymbolicLink()) throw blocked('Native evidence changed during capture');
+    live();
+  } finally { fs.closeSync(fd); }
+  if (prefix && prefix.digest('hex') !== expectedPrefix.sha256) throw blocked('Native history prefix changed');
+  if (!turnCount || !context || !allowHistory && turnCount !== (expectedPriorTurns === undefined ? 1 : expectedPriorTurns + 1)) throw blocked('Native worker has unexpected turn history');
+  const sha256 = hash.digest('hex'), bytes = Number(before.size);
+  if (metaCount > 1 || meta && meta.id !== sessionId) throw blocked('Native history session provenance mismatch');
+  let sourceBound;
+  if (bytes > limit) {
+    if (metaCount !== 1 || meta?.id !== sessionId) throw blocked('Native history session provenance mismatch');
+    if (compact) {
+      const ranges = [{ offset: meta.offset, bytes: meta.bytes }, ...(contextRange.offset < compact.offset ? [contextRange] : []), { offset: compact.offset, bytes: bytes - compact.offset }];
+      if (ranges.some((range, index) => index && range.offset < ranges[index - 1].offset + ranges[index - 1].bytes)) throw blocked('Native projection provenance overlaps');
+      sourceBound = { kind: 'native-compaction-projection', nativeSessionId: sessionId, sourceSha256: sha256, sourceBytes: bytes,
+        fullTurnCount: turnCount, omittedHistoryPrefix: true, ranges };
+    }
+  }
   return { model: context.model, effort: context.effort, cwd: context.cwd, sandbox: context.sandbox_policy, sessionId,
-    turnCount: contexts.length, evidence: { path: matches[0].file, sha256: digest(matches[0].bytes), type: 'native-turn-context' } };
+    turnCount, evidence: { path: file, sha256, type: 'native-turn-context', byteLength: bytes, ...(sourceBound ? { sourceBound } : {}) } };
 }
 
 /** Only the installed user-owned Brain search server is projected into isolated native workers. */
@@ -96,7 +153,8 @@ export async function executeCodexWorkflowWorker({ binary, decision, prompt, cwd
   if (performance.now() >= limit || signal?.aborted) throw blocked('Native worker deadline expired during readiness');
   const spec = buildLaunch(decision, { cwd });
   const evidenceHome = clean.CODEX_HOME || path.join(os.homedir(), '.codex');
-  const prior = sessionId ? observe(sessionId, { home: evidenceHome, expectedPriorTurns: undefined, allowHistory: true }) : null;
+  const prior = sessionId ? observe(sessionId, { home: evidenceHome, expectedPriorTurns: undefined, allowHistory: true,
+    deadline: Date.now() + Math.max(0, limit - performance.now()), signal }) : null;
   const args = sessionId ? ['exec', 'resume', '--ignore-user-config', '--skip-git-repo-check', '--json', '--model', decision.model,
     '-c', `model_reasoning_effort=\"${decision.effort}\"`, '-c', 'model_provider=\"openai\"',
     '-c', 'service_tier=\"default\"', '-c', `sandbox_mode=\"${readOnly ? 'read-only' : 'workspace-write'}\"`,
@@ -104,6 +162,7 @@ export async function executeCodexWorkflowWorker({ binary, decision, prompt, cwd
     : [...spec.args.slice(0, -1), '--skip-git-repo-check', '--json', '--sandbox', readOnly ? 'read-only' : 'workspace-write',
       '-c', 'features.multi_agent=false', '-c', 'features.multi_agent_v2=false', '-'];
   args.splice(args.length - 1, 0, ...codexBrainSearchArguments(clean));
+  if (performance.now() >= limit || signal?.aborted) throw blocked('Native worker deadline expired before launch');
   const result = await new Promise((resolve, reject) => {
     const child = launch(binary, args, { cwd, env: clean, shell: false, stdio: ['pipe', 'pipe', 'pipe'] });
     let stdout = '', stderr = '', finished = false, timer, killTimer, cancelled = false, cancelReason;
@@ -140,7 +199,9 @@ export async function executeCodexWorkflowWorker({ binary, decision, prompt, cwd
     throw blocked('Native Codex turn did not complete successfully');
   }
   if (sessionId && thread?.thread_id !== sessionId) throw blocked('Native parent session changed');
-  const observation = observe(thread?.thread_id, sessionId ? { home: evidenceHome, expectedPriorTurns: prior.turnCount, evidencePath: prior.evidence.path } : { home: evidenceHome });
+  const observation = observe(thread?.thread_id, { home: evidenceHome, deadline: Date.now() + Math.max(0, limit - performance.now()), signal,
+    ...(sessionId ? { expectedPriorTurns: prior.turnCount, evidencePath: prior.evidence.path,
+      expectedPrefix: { bytes: prior.evidence.byteLength, sha256: prior.evidence.sha256 } } : {}) });
   if (observation.model !== decision.model || observation.effort !== decision.effort || observation.cwd !== cwd
     || (readOnly && observation.sandbox?.type !== 'read-only')) throw blocked('Native worker model, effort, directory or sandbox mismatch');
   const messages = events.filter(event => event.type === 'item.completed' && event.item?.type === 'agent_message');

package/scripts/release-qualification-contract.mjs

@@ -155,8 +155,8 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
         "tests/unit/model-routing-defence.test.mjs"
       ],
       "platformFiles": {
-        "linux": ["tests/unit/model-terminal-canonical-entry.test.mjs", "tests/unit/codex-managed-terminal.test.mjs", "tests/unit/grok-subscription-host.test.mjs", "tests/unit/model-managed-parent-context-posix.test.mjs"],
-        "macos": ["tests/unit/model-terminal-canonical-entry.test.mjs", "tests/unit/codex-managed-terminal.test.mjs", "tests/unit/grok-subscription-host.test.mjs", "tests/unit/model-managed-parent-context-posix.test.mjs"]
+        "linux": ["tests/unit/model-terminal-canonical-entry.test.mjs", "tests/unit/codex-managed-terminal.test.mjs", "tests/unit/grok-subscription-host.test.mjs", "tests/unit/model-managed-parent-context-posix.test.mjs", "tests/unit/automatic-hook-retirement-posix.test.mjs"],
+        "macos": ["tests/unit/model-terminal-canonical-entry.test.mjs", "tests/unit/codex-managed-terminal.test.mjs", "tests/unit/grok-subscription-host.test.mjs", "tests/unit/model-managed-parent-context-posix.test.mjs", "tests/unit/automatic-hook-retirement-posix.test.mjs"]
       }
     },
     {
@@ -243,14 +243,25 @@ export const RELEASE_REQUIREMENTS = Object.freeze({
       ]
     },
     {
-      "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": "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",
+    "tests/unit/continuation-gate-objective-close.test.mjs",
+    "tests/unit/continuation-objective.test.mjs",
+    "tests/unit/continuation-gate.test.mjs"
+  ],
+  "platformFiles": {
+    "linux": [
+      "tests/unit/hook-shim.test.mjs"
+    ],
+    "macos": [
+      "tests/unit/hook-shim.test.mjs"
+    ]
+  }
+},
     {
       "id": "active-managed-generation",
       "reason": "Active code selection binds help authorization and execution to one immutable leased generation across promotion",