ruvnet-brain 4.5.14 → 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.14 — updated 2026-07-30 03:24 EDT](https://img.shields.io/badge/version_4.5.14-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';
@@ -2326,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;
@@ -2355,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];
@@ -2365,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' } = {}) {

package/package.json

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

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

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.5.14",
+  "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/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",