ruvnet-brain 4.3.37 → 4.3.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.3.37",
+  "version": "4.3.39",
   "description": "One-command installer for RuvNet Brain \u2014 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": {
@@ -68,6 +68,7 @@
     "cap:collect": "node scripts/rerank-cap-eval.mjs --collect",
     "cap:report": "node scripts/rerank-cap-eval.mjs --report",
     "cap:ab": "node scripts/rerank-cap-warm-ab.mjs",
+    "completion-claim:replay": "node scripts/completion-claim-replay.mjs",
     "hooks:check": "node scripts/hook-retirement-check.mjs",
     "release:qualify": "node scripts/release-qualification.mjs",
     "rehearse:corpus": "node scripts/rehearse-corpus-pipeline.mjs",
@@ -96,6 +97,7 @@
     "scripts/",
     "kb/verify-citation.mjs",
     "kb/retrieval-result.mjs",
+    "kb/forge-update.mjs",
     "kb/corpus-release-identity.mjs",
     "kb/capability-only.mjs",
     "kb/capability-summaries/",

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.3.37",
+  "version": "4.3.39",
   "author": {
     "name": "Stuart Kerr"
   },

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

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

package/plugin/hooks/codex-hooks.json

@@ -65,8 +65,8 @@
         "hooks": [
           {
             "type": "command",
-            "command": "node -e \"const f=require('node:fs'),o=require('node:os'),p=require('node:path'),c=require('node:child_process'),d=process.env.CODEX_HOME||p.join(o.homedir(),'.codex'),b=process.env.RUVNET_BRAIN_HOME||p.join(p.dirname(d),'.cache','ruvnet-brain'),w=p.join(b,'codex-hook.mjs');let s;try{s=f.statSync(w)}catch{}if(!s?.isFile())process.exit(0);const r=c.spawnSync(process.execPath,[w,...process.argv.slice(2)],{stdio:['inherit','pipe','pipe'],encoding:'utf8',env:process.env,timeout:Number(process.argv[1]),killSignal:'SIGKILL'});if(r.status===0||r.status===2){if(r.stdout)process.stdout.write(r.stdout);if(r.stderr)process.stderr.write(r.stderr)}process.exit(r.status===2?2:0)\" 2500 unprompted-speech UserPromptSubmit",
-            "timeout": 3
+            "command": "node -e \"const f=require('node:fs'),o=require('node:os'),p=require('node:path'),c=require('node:child_process'),d=process.env.CODEX_HOME||p.join(o.homedir(),'.codex'),b=process.env.RUVNET_BRAIN_HOME||p.join(p.dirname(d),'.cache','ruvnet-brain'),w=p.join(b,'codex-hook.mjs');let s;try{s=f.statSync(w)}catch{}if(!s?.isFile())process.exit(0);const r=c.spawnSync(process.execPath,[w,...process.argv.slice(2)],{stdio:['inherit','pipe','pipe'],encoding:'utf8',env:process.env,timeout:Number(process.argv[1]),killSignal:'SIGKILL'});if(r.status===0||r.status===2){if(r.stdout)process.stdout.write(r.stdout);if(r.stderr)process.stderr.write(r.stderr)}process.exit(r.status===2?2:0)\" 9000 unprompted-speech UserPromptSubmit",
+            "timeout": 10
           },
           {
             "type": "command",
@@ -75,8 +75,8 @@
           },
           {
             "type": "command",
-            "command": "node -e \"const f=require('node:fs'),o=require('node:os'),p=require('node:path'),c=require('node:child_process'),d=process.env.CODEX_HOME||p.join(o.homedir(),'.codex'),b=process.env.RUVNET_BRAIN_HOME||p.join(p.dirname(d),'.cache','ruvnet-brain'),w=p.join(b,'codex-hook.mjs');let s;try{s=f.statSync(w)}catch{}if(!s?.isFile())process.exit(0);const r=c.spawnSync(process.execPath,[w,...process.argv.slice(2)],{stdio:['inherit','pipe','pipe'],encoding:'utf8',env:process.env,timeout:Number(process.argv[1]),killSignal:'SIGKILL'});if(r.status===0||r.status===2){if(r.stdout)process.stdout.write(r.stdout);if(r.stderr)process.stderr.write(r.stderr)}process.exit(r.status===2?2:0)\" 1500 capacity-aware-parallel-work",
-            "timeout": 2
+            "command": "node -e \"const f=require('node:fs'),o=require('node:os'),p=require('node:path'),c=require('node:child_process'),d=process.env.CODEX_HOME||p.join(o.homedir(),'.codex'),b=process.env.RUVNET_BRAIN_HOME||p.join(p.dirname(d),'.cache','ruvnet-brain'),w=p.join(b,'codex-hook.mjs');let s;try{s=f.statSync(w)}catch{}if(!s?.isFile())process.exit(0);const r=c.spawnSync(process.execPath,[w,...process.argv.slice(2)],{stdio:['inherit','pipe','pipe'],encoding:'utf8',env:process.env,timeout:Number(process.argv[1]),killSignal:'SIGKILL'});if(r.status===0||r.status===2){if(r.stdout)process.stdout.write(r.stdout);if(r.stderr)process.stderr.write(r.stderr)}process.exit(r.status===2?2:0)\" 5500 capacity-aware-parallel-work",
+            "timeout": 6
           },
           {
             "type": "command",

package/plugin/hooks/hook-contracts.json

@@ -1,5 +1,5 @@
 {
-  "_note": "The legacy automatic gate collection remains retired. What is permitted is the continuity plane below and nothing else: SessionStart restores the canonical project checkpoint; UserPromptSubmit runs the single unprompted-speech chokepoint; Stop may nudge one explicitly authorized project-scoped objective AND capture a project snapshot; PreCompact and SessionEnd capture a project snapshot. Version 3 of this file permitted exactly two handlers, which was not a safety property but a contradiction: it demanded a restore while forbidding any event that could WRITE the journal the restore reads, so the canonical store held zero progression rows. Adding to this list is still a deliberate act that must pass `npm run hooks:check`; what changed is that the shape can now express the plane that actually works. Amended 2026-09-11 (Stuart): the continuity-only charter had retired the ONLY enforcement of ADR-0012 — never write rUv-product code the brain has not seen — and the failure it exists to prevent recurred the day it was measured absent. The plane now also carries three grounding registrations: ground-ruvnet (UserPromptSubmit, grounding injection — a second owner of that event, scoped by ADR-040 §Amendment 2026-09-11 to directives rather than speech), decision-gate’s write route (PreToolUse, the one refuser, ADR-067), and grounding-stamp (PostToolUse on a successful search_ruvnet, the receipt that opens the write gate). Amended 2026-09-12: the 2026-09-11 claim that Codex PreToolUse/PostToolUse delivery had never been observed was measured with a prompt that never invoked a tool (`codex exec \"reply OK\"`), so it was an untested path, not a failing one. Re-measured with prompts that actually call a tool (a real apply_patch write, a real MCP search_ruvnet call against this repo's own server): both events FIRED on codex-cli 0.154.0 with real payloads. decision-gate's write route and grounding-stamp are now dual-host (see _codexCapture and contracts below); the bash route (exec_command) remains Claude-only — today's measurement did not exercise it. Also amended 2026-09-12: added grounding-turn-mark (UserPromptSubmit) and grounding-turn-gate (Stop), the \"answered without searching\" pair — ground-ruvnet's Gate 1 directive is advisory, so nothing previously checked whether the model complied before the turn ended. grounding-turn-mark records that Gate 1 fired for a turn; grounding-turn-gate forces continuation at Stop if grounding-stamp's own evidence shows no search_ruvnet call happened since. Both dual-host from the start (the Stop-block contract is already proven on Codex via continuation-gate). Added capacity-aware-parallel-work at UserPromptSubmit on both measured hosts: it is context-only, resource-bounded, and requires the coordinator to check actual tool/runtime slots; it does not spawn or claim workers.",
+  "_note": "The legacy automatic gate collection remains retired. What is permitted is the continuity plane below and nothing else: SessionStart restores the canonical project checkpoint; UserPromptSubmit runs the single unprompted-speech chokepoint; Stop may nudge one explicitly authorized project-scoped objective AND capture a project snapshot; PreCompact and SessionEnd capture a project snapshot. Version 3 of this file permitted exactly two handlers, which was not a safety property but a contradiction: it demanded a restore while forbidding any event that could WRITE the journal the restore reads, so the canonical store held zero progression rows. Adding to this list is still a deliberate act that must pass `npm run hooks:check`; what changed is that the shape can now express the plane that actually works. Amended 2026-09-11 (Stuart): the continuity-only charter had retired the ONLY enforcement of ADR-0012 — never write rUv-product code the brain has not seen — and the failure it exists to prevent recurred the day it was measured absent. The plane now also carries three grounding registrations: ground-ruvnet (UserPromptSubmit, grounding injection — a second owner of that event, scoped by ADR-040 §Amendment 2026-09-11 to directives rather than speech), decision-gate’s write route (PreToolUse, the one refuser, ADR-067), and grounding-stamp (PostToolUse on a successful search_ruvnet, the receipt that opens the write gate). Amended 2026-09-12: the 2026-09-11 claim that Codex PreToolUse/PostToolUse delivery had never been observed was measured with a prompt that never invoked a tool (`codex exec \"reply OK\"`), so it was an untested path, not a failing one. Re-measured with prompts that actually call a tool (a real apply_patch write, a real MCP search_ruvnet call against this repo's own server): both events FIRED on codex-cli 0.154.0 with real payloads. decision-gate's write route and grounding-stamp are now dual-host (see _codexCapture and contracts below); the bash route (exec_command) remains Claude-only — today's measurement did not exercise it. Also amended 2026-09-12: added grounding-turn-mark (UserPromptSubmit) and grounding-turn-gate (Stop), the \"answered without searching\" pair — ground-ruvnet's Gate 1 directive is advisory, so nothing previously checked whether the model complied before the turn ended. grounding-turn-mark records that Gate 1 fired for a turn; grounding-turn-gate forces continuation at Stop if grounding-stamp's own evidence shows no search_ruvnet call happened since. Both dual-host from the start (the Stop-block contract is already proven on Codex via continuation-gate). Added capacity-aware-parallel-work at UserPromptSubmit on both measured hosts: it is context-only, resource-bounded, and requires the coordinator to check actual tool/runtime slots; it does not spawn or claim workers. Amended 2026-09-30 (ADR-0030 decision point #1, no new registration): grounding-turn-mark also arms a turn when the prompt asks a capability/feasibility/architecture question about any tool or platform, and grounding-turn-gate then requires every capability claim in the final answer to be bound to a relevant STRONG source read this turn after the last weak one (a WebFetch body is a small model's summary: weak); on Claude it reads the transcript instead of stamp mtimes, which removed the measured 'no search recorded' false alarms. ADR-0030 #2/#3 run in shadow only.",
   "_version": 8,
   "_eventOwners": [
     {
@@ -30,7 +30,7 @@
         "claude",
         "codex"
       ],
-      "responsibility": "May request one continuation for one explicitly authorized, project-scoped objective read from the user's own work ledger (ADR-043). Never a refusal, never a second task store."
+      "responsibility": "May request one continuation for one explicitly authorized, project-scoped objective read from the user's own work ledger (ADR-043). Never a refusal, never a second task store. Amended 2026-09-30 (ADR-074 class `completion`, no new registration): the same Stop body also requests ONE correction when the final answer claims work is done without a verification command run after the last state change this turn (Claude transcript), a named check, and a NOT-verified disclosure — on Codex, whose rollout format is not parsed, only the answer-side half is enforced and the transcript half is reported UNKNOWN. It also records first-person promises from the final answer into the SAME per-project ledger (Claude only; capped; closed only by a later evidence-passing completion claim, never by --done) and requests continuation on them under the same loop guards and cooldown."
     },
     {
       "event": "Stop",
@@ -89,7 +89,7 @@
         "claude",
         "codex"
       ],
-      "responsibility": "The ONE process that may refuse a Write/Edit/MultiEdit/NotebookEdit/apply_patch (ADR-067): composes protect-state, hijack-ruvnet, ground-before-write (ADR-0012) and adr-currency into one decision with one reason. Fails open on its own errors. apply_patch is Codex's raw write-tool name, added to the shared matcher 2026-09-12 after a real apply_patch call was measured to fire PreToolUse live (codex-cli 0.154.0); codex-hook-adapter.mjs normalizes it to the same Edit shape decision-gate.mjs's policies already read on Claude."
+      "responsibility": "The ONE process that may refuse a Write/Edit/MultiEdit/NotebookEdit/apply_patch (ADR-067): composes protect-state, hijack-ruvnet, ground-before-write (ADR-0012), adr-currency and duplicate-code (2026-09-30: a new code file or large new export duplicating existing code in this checkout, refused at most once per path per session) into one decision with one reason. Fails open on its own errors. apply_patch is Codex's raw write-tool name, added to the shared matcher 2026-09-12 after a real apply_patch call was measured to fire PreToolUse live (codex-cli 0.154.0); codex-hook-adapter.mjs normalizes it to the same Edit shape decision-gate.mjs's policies already read on Claude."
     },
     {
       "event": "PostToolUse",
@@ -109,7 +109,7 @@
         "claude",
         "codex"
       ],
-      "responsibility": "Records that ground-ruvnet's Gate 1 (the same regex, proven byte-identical by test) matched this turn's prompt, so grounding-turn-gate has something to check at Stop — Stop's own payload carries no prompt text. Writes only a marker file under ~/.cache/ruvnet-brain/grounding-turn/; never blocks, never speaks to the model."
+      "responsibility": "Records that ground-ruvnet's Gate 1 (the same regex, proven byte-identical by test) matched this turn's prompt, so grounding-turn-gate has something to check at Stop — Stop's own payload carries no prompt text. Amended 2026-09-30: also arms when the prompt asks a capability/feasibility/architecture question about any tool or platform, recording the subjects it named; a marker not yet consumed is merged without moving its mtime (a queued mid-turn prompt re-dating it was a measured false-alarm cause). Writes only a marker file under ~/.cache/ruvnet-brain/grounding-turn/; never blocks, never speaks to the model."
     },
     {
       "event": "Stop",
@@ -119,7 +119,7 @@
         "claude",
         "codex"
       ],
-      "responsibility": "The 'answered without searching' gate (2026-09-12): if grounding-turn-mark's marker shows Gate 1 fired this turn and grounding-stamp's own stamp evidence shows no search_ruvnet call happened since, forces continuation via the same hookSpecificOutput.additionalContext contract continuation-gate already uses on both hosts. A separate registration from continuation-gate — see grounding-turn-gate.mjs's header for why folding it into that file's ledger/cooldown semantics would corrupt them rather than extend them. Consumes its marker unconditionally so a stale one can never pressure an unrelated later turn."
+      "responsibility": "The 'answered without searching' gate (2026-09-12): if grounding-turn-mark's marker shows Gate 1 fired this turn and grounding-stamp's own stamp evidence shows no search_ruvnet call happened since, forces continuation via the same hookSpecificOutput.additionalContext contract continuation-gate already uses on both hosts. A separate registration from continuation-gate — see grounding-turn-gate.mjs's header for why folding it into that file's ledger/cooldown semantics would corrupt them rather than extend them. Consumes its marker unconditionally so a stale one can never pressure an unrelated later turn. Amended 2026-09-30 (ADR-0030 #1): on Claude, 'was search_ruvnet called' is read from the transcript, and on an armed turn each capability claim in the final answer must be bound to a relevant strong source read this turn after the last weak one, else ONE correction naming the claim and what was read; on Codex (rollout not parsed) only rUv-term claims are judged, from stamps, and the rest are UNKNOWN. Gates #2/#3 are shadow-logged, never delivered."
     }
   ],
   "_notInThisPlane": [
@@ -179,7 +179,7 @@
       "mode": "blocking",
       "offBehavior": "silence",
       "matcher": "*",
-      "timeout": 3
+      "timeout": 9
     },
     {
       "id": "continuation-gate",
@@ -250,7 +250,7 @@
       "mode": "advisory",
       "offBehavior": "run",
       "matcher": "*",
-      "timeout": 2
+      "timeout": 6
     },
     {
       "id": "decision-gate",

package/plugin/hooks/hooks.json

@@ -20,7 +20,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hook-shim.mjs\" unprompted-speech UserPromptSubmit",
-            "timeout": 3
+            "timeout": 9
           },
           {
             "type": "command",
@@ -30,7 +30,7 @@
           {
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/hook-shim.mjs\" capacity-aware-parallel-work || true",
-            "timeout": 2
+            "timeout": 6
           },
           {
             "type": "command",

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

@@ -10,7 +10,7 @@ const HOSTS = Object.freeze(['claude', 'codex']);
 const OS_LANES = Object.freeze(['linux', 'macos', 'windows']);
 const CLAIM_CLASSES = Object.freeze(['installation', 'behavior', 'currentVersion', 'latestVersion', 'health']);
 const VERSION = /\bv?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b/;
-const RUVNET_TOOL = '(?:Ruflo|Claude Flow|Agentic Flow|Agentic QE|RuVector|Agent Browser|Ruv Swarm|AgentDB|RuLake|RuvNet Brain)';
+const RUVNET_TOOL_DEFAULT = '(?:Ruflo|Claude Flow|Agentic Flow|Agentic QE|RuVector|Agent Browser|Ruv Swarm|AgentDB|RuLake|RuvNet Brain)';
 const MAX_AGE_MS = 10 * 60_000;
 const MAX_LEDGER_BYTES = 1024 * 1024;
 const STOPWORDS = new Set(['a', 'an', 'and', 'are', 'can', 'could', 'does', 'for', 'has', 'have',
@@ -227,7 +227,16 @@ export function readLiveSurfaceReceipts({ file = null, env = process.env, limit
   } catch { return []; }
 }
 
-function extractClaims(message) {
+/**
+ * Claim extraction. `tools` widens the subject vocabulary beyond RUVNET_TOOL (grounding-turn-gate.mjs
+ * passes repo aliases, installed stores and the armed prompt's subjects); the default is unchanged,
+ * so this file's own Stop audit keeps exactly its original scope.
+ */
+const escapeRe = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+export function extractClaims(message, { tools = null } = {}) {
+  const RUVNET_TOOL = tools?.length
+    ? `(?:${[...new Set(tools.map(String).filter(Boolean))].sort((a, b) => b.length - a.length).map(escapeRe).join('|')})`
+    : RUVNET_TOOL_DEFAULT;
   const claims = [];
   for (const sentence of safeMessage(message).split(/(?<=[.!?])\s+|\n+/).map((value) => value.trim()).filter(Boolean)) {
     let match = new RegExp(`\\b(${RUVNET_TOOL})\\b[^.!?]{0,48}\\b(?:current|installed)\\s+version\\s+(?:is\\s+)?v?(\\d+\\.\\d+\\.\\d+(?:[-+][0-9A-Za-z.-]+)?)`, 'i').exec(sentence);

package/plugin/scripts/capacity-aware-parallel-work.mjs

@@ -74,12 +74,35 @@ export function parseMacPressureOutput(text, { totalMemoryBytes, normalizedLoad
   return { freePct, swapUsedBytes, compressorBytes, totalMemoryBytes, normalizedLoad };
 }
 
-/** Classify measured pressure. Unknown or incomplete measurements recommend serial work. */
+/**
+ * The total-agent ceiling when no host cap is reported, scaled to the machine. Owner rule (2026-09-30):
+ * a big machine must be used — 16 cores / 128 GB is ~10 agents when idle; small or unmeasured machines
+ * keep the conservative 4.
+ */
+export function hardwareAgentCeiling(cores) {
+  if (!Number.isInteger(cores) || cores < 1) return UNKNOWN_RUNTIME_TOTAL_AGENT_CEILING;
+  if (cores >= 12) return 10;
+  if (cores >= 8) return 6;
+  return UNKNOWN_RUNTIME_TOTAL_AGENT_CEILING;
+}
+
+/**
+ * Classify measured pressure. Memory probes can time out on a loaded machine, so a sample carrying only
+ * the load average is classified by load alone (an unmeasurable memory state must not silently turn a
+ * 16-core machine into a one-agent machine). Nothing measurable at all recommends serial work.
+ */
 export function pressureRecommendation(sample) {
-  if (!sample || ![
-    sample.freePct, sample.swapUsedBytes, sample.compressorBytes,
-    sample.totalMemoryBytes, sample.normalizedLoad,
-  ].every(Number.isFinite) || sample.totalMemoryBytes <= 0) {
+  const memoryKnown = !!sample && [
+    sample.freePct, sample.swapUsedBytes, sample.compressorBytes, sample.totalMemoryBytes,
+  ].every(Number.isFinite) && sample.totalMemoryBytes > 0;
+  if (sample && !memoryKnown && Number.isFinite(sample.normalizedLoad) && sample.normalizedLoad >= 0) {
+    const load = sample.normalizedLoad;
+    if (load >= 1) return { tier: 'constrained', totalAgents: 1, reason: 'CPU oversubscribed (load-only measurement)' };
+    if (load >= 0.75) return { tier: 'high-cpu', totalAgents: 3, reason: 'CPU pressure is high (load-only measurement)' };
+    if (load >= 0.55) return { tier: 'moderate', totalAgents: 5, reason: 'CPU headroom is partial (load-only measurement)' };
+    return { tier: 'available', totalAgents: null, reason: 'CPU headroom is available (load-only measurement)' };
+  }
+  if (!sample || !memoryKnown || !Number.isFinite(sample.normalizedLoad)) {
     return { tier: 'unknown', totalAgents: 1, reason: 'capacity signals unavailable' };
   }
   const compressedRatio = sample.compressorBytes / sample.totalMemoryBytes;
@@ -93,7 +116,7 @@ export function pressureRecommendation(sample) {
     return { tier: 'high-cpu', totalAgents: 3, reason: 'CPU pressure is high' };
   }
   if (sample.freePct < 75 || compressedRatio >= 0.2 || sample.normalizedLoad >= 0.55) {
-    return { tier: 'moderate', totalAgents: 2, reason: 'resource headroom is partial' };
+    return { tier: 'moderate', totalAgents: 5, reason: 'resource headroom is partial' };
   }
   return { tier: 'available', totalAgents: null, reason: 'measured headroom is available' };
 }
@@ -106,10 +129,15 @@ export function effectiveAgentRecommendation(sample, {
   configuredMaxChildren = null,
   runtimeTotalAgentCap = null,
   workUnitCount = null,
+  cores = null,
 } = {}) {
   const pressure = pressureRecommendation(sample);
   const runtimeCapKnown = Number.isInteger(runtimeTotalAgentCap) && runtimeTotalAgentCap >= 1;
-  const limits = [pressure.totalAgents ?? (runtimeCapKnown ? runtimeTotalAgentCap : UNKNOWN_RUNTIME_TOTAL_AGENT_CEILING)];
+  const ceiling = hardwareAgentCeiling(cores);
+  // A host-reported cap is authoritative over the hardware ceiling; pressure tiers never exceed it.
+  const limits = [pressure.totalAgents === null
+    ? (runtimeCapKnown ? runtimeTotalAgentCap : ceiling)
+    : Math.min(pressure.totalAgents, ceiling)];
   if (Number.isInteger(configuredMaxChildren) && configuredMaxChildren >= 0) {
     limits.push(configuredMaxChildren + 1); // configured workers plus the coordinating agent
   }
@@ -139,8 +167,19 @@ function readInput() {
   return Buffer.concat(chunks).toString('utf8');
 }
 
+// The load average alone, from the OS. Used when the macOS memory probe times out (it does, under
+// exactly the heavy load that matters) and on other platforms. Windows reports no load average, so it
+// stays unmeasured there rather than reading as an idle machine.
+function collectLoadOnly() {
+  if (process.platform === 'win32') return null;
+  const cpuCount = os.cpus().length;
+  const load = os.loadavg()[0];
+  if (!cpuCount || !Number.isFinite(load) || load < 0) return null;
+  return { normalizedLoad: load / cpuCount, loadAvg1: load };
+}
+
 function collectMacPressure() {
-  if (process.platform !== 'darwin') return null;
+  if (process.platform !== 'darwin') return collectLoadOnly();
   try {
     // One bounded subprocess gathers pressure, swap, and compressor bytes. Never use raw free RAM
     // as the capacity signal; memory_pressure, actual swap, compression, and normalized load drive
@@ -149,28 +188,42 @@ function collectMacPressure() {
       encoding: 'utf8', timeout: PROBE_TIMEOUT_MS, maxBuffer: 24 * 1024,
       env: { PATH: '/usr/bin:/bin:/usr/sbin:/sbin' },
     });
-    if (probe.error || probe.status !== 0) return null;
+    if (probe.error || probe.status !== 0) return collectLoadOnly();
     const cpuCount = os.cpus().length;
     const load = os.loadavg()[0];
     if (!cpuCount || !Number.isFinite(load) || load < 0) return null;
-    return parseMacPressureOutput(probe.stdout, {
+    const parsed = parseMacPressureOutput(probe.stdout, {
       totalMemoryBytes: os.totalmem(), normalizedLoad: load / cpuCount,
     });
+    return parsed ? { ...parsed, loadAvg1: load } : collectLoadOnly();
   } catch {
-    return null;
+    return collectLoadOnly();
   }
 }
 
-export function formatAdvisory(recommendation) {
+/** The numbers behind the recommendation, so the owner can check them (owner 2026-09-30). */
+export function describeMeasurement(sample, cores) {
+  if (!sample || !Number.isFinite(sample.normalizedLoad)) return 'capacity measurement unavailable';
+  const parts = [];
+  if (Number.isInteger(cores) && cores > 0) parts.push(`${cores} cores`);
+  if (Number.isFinite(sample.totalMemoryBytes) && sample.totalMemoryBytes > 0) parts.push(`${Math.round(sample.totalMemoryBytes / GIB)} GB RAM`);
+  parts.push(Number.isFinite(sample.loadAvg1) ? `load ${sample.loadAvg1.toFixed(1)} (${sample.normalizedLoad.toFixed(2)}/core)` : `load ${sample.normalizedLoad.toFixed(2)}/core`);
+  if (Number.isFinite(sample.freePct)) parts.push(`memory ${Math.round(sample.freePct)}% free`);
+  if (Number.isFinite(sample.swapUsedBytes)) parts.push(sample.swapUsedBytes > 0 ? 'swap in use' : 'no swap');
+  return parts.join(', ');
+}
+
+export function formatAdvisory(recommendation, measured = null) {
   const n = recommendation.totalAgents;
   const runtime = recommendation.runtimeCapKnown
     ? 'Do not exceed the host-reported runtime cap; configured concurrency is only a ceiling.'
-    : `This hook cannot see the live runtime/tool cap; ${UNKNOWN_RUNTIME_TOTAL_AGENT_CEILING} total is only a conservative ceiling until the coordinator checks it. Configured concurrency is not proof of available slots.`;
+    : `This hook cannot see the live runtime/tool cap; ${n} total is this machine's measured ceiling until the coordinator checks it. Configured concurrency is not proof of available slots.`;
   const workerPlan = recommendation.workers > 0
     ? `At most ${recommendation.workers} worker agent${recommendation.workers === 1 ? '' : 's'}`
     : 'No additional worker agents';
   return [
     'Capacity-aware parallel-work advisory (context only; no workers were started).',
+    ...(measured ? [`Measured just now: ${measured}. State these numbers to the owner when you size a fan-out, and never claim parallel workers that are not running.`] : []),
     `This prompt appears to contain independent work. Resource tier: ${recommendation.tier}; recommend no more than ${n} total agent${n === 1 ? '' : 's'} including the coordinator (${workerPlan}).`,
     `${runtime} Treat configured concurrency as a ceiling only; never infer that configured slots are available.`,
     'If a real agent-spawn/task tool is available and slots remain, launch actual workers now with non-overlapping deliverables and collect their results. If tools or slots are unavailable, continue serially and do not claim parallel workers exist.',
@@ -185,11 +238,14 @@ export function runCapacityHook(rawInput, sample) {
   // "independent work" prose but nobody wrote it — never advise a parallel-work fan-out off of one.
   if (isHarnessGenerated(prompt)) return '';
   if (!isSubstantialParallelWork(prompt)) return '';
-  return formatAdvisory(effectiveAgentRecommendation(sample === undefined ? collectMacPressure() : sample, {
+  const measuredSample = sample === undefined ? collectMacPressure() : sample;
+  const cores = os.cpus().length;
+  return formatAdvisory(effectiveAgentRecommendation(measuredSample, {
     configuredMaxChildren: input?.configured_max_children,
     runtimeTotalAgentCap: input?.runtime_total_agent_cap,
     workUnitCount: input?.independent_workstream_count ?? estimateWorkUnitCount(prompt),
-  }));
+    cores,
+  }), describeMeasurement(measuredSample, cores));
 }
 
 function main() {

package/plugin/scripts/codex-hook-wrapper.mjs

@@ -69,6 +69,9 @@ function timeoutFor(hookId) {
   // tinguishable from a crash; 6000ms covers the gate's cap plus this chain's spawn overhead
   // (measured 773–1145ms end-to-end warm, so ~150–400ms of that is the wrapper/adapter/shim).
   if (hookId === 'decision-gate') return 6_000;
+  // Advisory capacity hook: 4 of 8 runs were killed at the old 2s host timeout on a loaded machine (measured
+  // 2026-09-30). Keep the wrapper's budget below the registration's own 5.5s so the wrapper, not the host, ends it.
+  if (hookId === 'capacity-aware-parallel-work') return 5_000;
   if (hookId === 'ground-ruvnet' || hookId === 'unprompted-speech' || hookId === 'continuation-gate') {
     return 8_500;
   }

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

@@ -0,0 +1,262 @@
+/**
+ * completion-claim-evidence.mjs — ADR-074's `completion` claim class, and the promise capture that
+ * rides the same boundary. Pure functions only: continuation-gate.mjs (the ONE Stop chokepoint) owns
+ * delivery, loop safety, cooldown and the ledger write. No hook registration of its own.
+ *
+ * WHY (owner, 2026-09-30): "You can never ever tell me something is done and implemented without
+ * having tested it end to end... That's how I ended up with a broken corpus that hasn't been
+ * successfully updated in 40 days because you never told me it was broken."
+ *
+ * THE RULE, deterministic, read from the host transcript of THIS turn (everything after the last
+ * genuine user message):
+ *   A positive completion assertion ("fixed", "done", "shipped", "it will now…") PASSES only when
+ *   (1) at least one verification command EXECUTED after the last state-changing action, with its
+ *       result present and not an error, AND
+ *   (2) the answer names the check (a "Verified:"-style line, or the executed command's own name), AND
+ *   (3) the answer discloses what is NOT verified.
+ *   Anything else is one correction request. No claim recognised → no verdict about the prose.
+ *
+ * HOSTS. Claude Code transcripts (`transcript_path`, JSONL) are parsed. Codex's Stop payload also
+ * carries `transcript_path`, but its rollout format is NOT parsed anywhere in this repository
+ * (project-progression-sources.mjs and turn-outcome-capture.mjs both decline it), so on Codex the
+ * transcript half is UNKNOWN and only the answer-side half (2)+(3) is enforced — disclosed in the
+ * correction text, never silently treated as proven.
+ */
+import { readSettledTranscript } from './turn-outcome-capture.mjs';
+
+const MAX_SENTENCE = 400;
+export const PROMISE_KIND = 'assistant-commitment';
+export const PROMISE_CAP_PER_TURN = 3;
+export const PROMISE_CAP_OPEN = 8;
+
+// ── answer-side parsing ─────────────────────────────────────────────────────────────────────────
+/** Code, inline code, quoted strings and block quotes are someone else's words, never a claim. */
+export function strippedProse(message) {
+  return String(message || '')
+    .replace(/```[\s\S]*?```/g, '\n')
+    .replace(/`[^`\n]*`/g, ' ')
+    .replace(/"[^"\n]{0,300}"|“[^”\n]{0,300}”/g, ' ')
+    .replace(/^\s*>.*$/gm, ' ')
+    .replace(/^\s*\|.*\|\s*$/gm, ' '); // table rows are data cells, not sentences
+}
+
+function sentences(message) {
+  return strippedProse(message)
+    .split(/(?<=[.!?])\s+|\n+/)
+    .map((s) => s.trim())
+    .filter((s) => s && s.length <= MAX_SENTENCE);
+}
+
+// A sentence that is itself a disclosure, a negation, a hedge or a condition is not a claim.
+const NOT_A_CLAIM = /\b(?:not|never|no|nothing|none|cannot|can't|won't|isn't|aren't|wasn't|weren't|hasn't|haven't|didn't|doesn't|don't|without|unverified|untested|unproven|unknown|yet|if|unless|until|once|when|whether|should|would|could|might|may|maybe|probably|likely|expected|supposed|hopefully|assuming|pending|remaining|remains|todo|tbd|before|after|previously|earlier|already|yesterday|ago|last\s+(?:week|night|time|session|release)|claimed|claims|said|says|reported|told|neither|nor|as\s+soon\s+as|tell\s+me|I(?:'ll|’ll)|we(?:'ll|’ll)|will\s+(?!now\b)|(?:was|were)\s+working|damage\s+is\s+done)\b|\?/i;
+const CLAIM_PATTERNS = [
+  // "X is fixed", "the gate is now live", "tests are passing", "it's done"
+  /\b(?:is|are|was|were|has\s+been|have\s+been|(?:it|that|this|what|everything|there)(?:'s|’s)|now)\s+(?:all\s+|fully\s+|now\s+|finally\s+|successfully\s+|actually\s+)*(?:fixed|done|complete|completed|resolved|shipped|deployed|live(?!\s+(?:in|inside|under|with|alongside))|implemented|landed|published|merged|released|verified|green|passing|operational|in\s+place|wired(?:\s+up)?|working(?!\s+(?:on|with|through|in|as|tree|copy|dir)))\b/i,
+  // "I fixed", "I've shipped", "we deployed"
+  /\b(?:I|we)(?:'ve|’ve|\s+have)?\s+(?:now\s+|just\s+|successfully\s+|also\s+|fully\s+)*(?:fixed|shipped|deployed|resolved|completed|implemented|landed|published|released|verified|finished|wired\s+up)\b/i,
+  // "Done." "Fixed:" "Shipped —" "✅ Deployed" at the start of a line
+  /^(?:[-*•]\s*|#+\s*|\*\*|✅\s*)*(?:done|fixed|shipped|deployed|resolved|complete|completed|implemented|all\s+done|all\s+set|all\s+green)\b\s*(?:[.!:—–-]|\*\*|$)/i,
+  // "now works", "it will now block …", "works end to end"
+  /\b(?:now\s+works|works\s+now|works\s+end[- ]to[- ]end|will\s+now\s+(?:work|fire|block|catch|run|stay|refuse|correct|speak|pass|succeed))\b/i,
+];
+
+/** Positive completion assertions, in message order. Deterministic; no model call. */
+export function extractCompletionClaims(message) {
+  const out = [];
+  for (const sentence of sentences(message)) {
+    if (NOT_A_CLAIM.test(sentence)) continue;
+    if (CLAIM_PATTERNS.some((re) => re.test(sentence))) out.push({ class: 'completion', text: sentence });
+  }
+  return out;
+}
+
+const NAMED_CHECK = /(?:^|\n)\s*(?:[-*•]\s*|#+\s*|\*\*)*(?:verified|verification|evidence|proof|tested|checks?(?:\s+run)?|test\s+results?|measured)\b[^\n]{0,4}?(?:\*\*)?\s*[:—–]/i;
+const DISCLOSES_GAPS = /\b(?:not\s+(?:yet\s+)?(?:verified|tested|checked|exercised|measured|proven|covered|run)|unverified|untested|unproven|what\s+i\s+did\s+not\s+(?:test|verify|check)|did\s+not\s+(?:test|verify|check|run|exercise)|didn't\s+(?:test|verify|check|run|exercise)|remains?\s+unknown|UNKNOWN)\b/i;
+
+// ── transcript-side parsing (Claude Code JSONL) ─────────────────────────────────────────────────
+const textOf = (content) => (typeof content === 'string' ? content
+  : Array.isArray(content) ? content.filter((c) => c?.type === 'text' && typeof c.text === 'string').map((c) => c.text).join('\n') : '');
+
+const TMP_PATH = /^(?:\/tmp\/|\/private\/tmp\/|\/var\/folders\/|\$\{?TMPDIR|\/dev\/null)/;
+const MUTATING_SEGMENT = [
+  /\bgit\s+(?:commit|push|merge|rebase|reset|revert|cherry-pick|tag|am|apply|restore|stash\s+(?:pop|apply)|mv|rm|switch|checkout)\b/,
+  /\bgh\s+(?:release\s+(?:create|edit|upload|delete)|pr\s+(?:create|merge|close|edit|ready)|workflow\s+run|run\s+rerun|issue\s+(?:create|close|edit|comment)|repo\s+edit|secret\s+set|variable\s+set|api\b[^|;&]*-X\s*(?:POST|PUT|PATCH|DELETE))\b/,
+  /\b(?:npm|pnpm|yarn)\s+(?:publish|version|install|i|add|uninstall|remove|ci|link|unpublish|dist-tag)\b/,
+  /\bnpm\s+run\s+[\w:.-]*(?:write|set|fix|deploy|publish|release|sync|install|update|apply|seed|stamp|migrate|format)[\w:.-]*/,
+  /\b(?:launchctl\s+(?:load|unload|bootstrap|bootout|enable|disable|kickstart)|crontab\s+(?!-l\b)\S|schtasks\s+\/(?:create|delete|change))/i,
+  /\b(?:vercel\s+(?:deploy|--prod|promote|alias)|netlify\s+deploy|docker\s+(?:push|build)|kubectl\s+(?:apply|delete|rollout)|terraform\s+apply|wrangler\s+(?:deploy|publish))\b/,
+  /\s--(?:write|apply|fix|install|enable-nightly|publish|commit|seed|set|update)\b/,
+  /\b(?:sed|perl)\s+(?:-[a-zA-Z]*i|-i)\b/,
+];
+const FILE_MUTATORS = /^(?:sudo\s+)?(?:rm|mv|cp|mkdir|touch|chmod|chown|ln|truncate|rsync|unzip|tee|install)\b/;
+const TRIVIAL = /^(?:sudo\s+)?(?:ls|cat|head|tail|less|more|grep|egrep|rg|find|fd|wc|echo|printf|pwd|cd|which|type|command|sort|uniq|cut|tr|stat|file|date|sleep|true|false|export|set|source|\.|test|\[|jq|awk|sed|basename|dirname|realpath|env|git\s+(?:status|log|diff|show|branch|rev-parse|remote|config|worktree\s+list|stash\s+list))\b/;
+
+function segments(command) {
+  return String(command || '').split(/&&|\|\||;|\n|\|/).map((s) => s.trim()).filter(Boolean);
+}
+function segmentMutates(segment) {
+  if (MUTATING_SEGMENT.some((re) => re.test(segment))) return true;
+  if (FILE_MUTATORS.test(segment)) {
+    const args = segment.split(/\s+/).slice(1).filter((a) => !a.startsWith('-'));
+    return !args.length || !args.every((a) => TMP_PATH.test(a.replace(/^['"]|['"]$/g, '')));
+  }
+  return /(?:^|[^0-9&>])>{1,2}\s*(?!&|\/dev\/null)(['"]?)([^\s'"]+)/.test(segment)
+    && !TMP_PATH.test((/>{1,2}\s*['"]?([^\s'"]+)/.exec(segment) || [])[1] || '');
+}
+const segmentChecks = (segment) => !TRIVIAL.test(segment) && !segmentMutates(segment);
+function checkName(segment) {
+  const words = segment.replace(/^(?:[A-Z_][A-Z0-9_]*=\S+\s+)+/, '').split(/\s+/);
+  const run = words.findIndex((w) => w === 'run');
+  if (/^(?:npm|pnpm|yarn)$/.test(words[0]) && run >= 0 && words[run + 1]) return words[run + 1];
+  if (words[0] === 'npx' && words[1]) return words[1];
+  if (words[0] === 'node' && words[1]) return words[1].split('/').pop().replace(/\.[cm]?js$/, '');
+  return words.slice(0, 2).join(' ');
+}
+
+const READ_ONLY_AGENTS = /^(?:explore|plan|claude-code-guide|statusline-setup)$/i;
+const MCP_MUTATING = /__(?:create|update|delete|remove|publish|deploy|push|write|send|set|merge|upload|patch|put|post|add|rename|move|approve|promote|rollback|cancel|buy|store|edit|import|reset|stop|terminate|spawn|execute)[a-z_-]*$/i;
+
+/**
+ * The current turn of a Claude JSONL transcript: every main-thread record after the last genuine
+ * user message, plus that message's text. Shared by claudeTurnEvents() and grounding-turn-evidence.mjs
+ * so both gates agree on where a turn starts.
+ */
+export function currentTurnRecords(lines) {
+  const recs = [];
+  for (const l of lines || []) { try { const o = JSON.parse(l); if (!o?.isSidechain) recs.push(o); } catch { /* torn line */ } }
+  let start = -1;
+  recs.forEach((o, i) => {
+    const c = o?.message?.content;
+    const isToolResult = Array.isArray(c) && c.some((x) => x?.type === 'tool_result');
+    if (o?.type === 'user' && (o.message?.role || 'user') === 'user' && !isToolResult && !o.isMeta && textOf(c).trim()) start = i;
+  });
+  return { boundaryFound: start >= 0, prompt: start >= 0 ? textOf(recs[start].message?.content) : '', recs: recs.slice(start + 1) };
+}
+
+/** Ordered events for the current turn of a Claude JSONL transcript. */
+export function claudeTurnEvents(lines) {
+  const { boundaryFound, recs: turnRecs } = currentTurnRecords(lines);
+  const results = new Map();
+  for (const o of turnRecs) {
+    const c = o?.message?.content;
+    if (!Array.isArray(c)) continue;
+    for (const r of c) {
+      if (r?.type === 'tool_result' && r.tool_use_id) {
+        results.set(r.tool_use_id, { error: r.is_error === true || o.toolUseResult?.interrupted === true,
+          present: textOf(r.content).trim().length > 0 || String(o.toolUseResult?.stdout || '').trim().length > 0 });
+      }
+    }
+  }
+  const events = [];
+  for (const o of turnRecs) {
+    const c = o?.message?.content;
+    if (o?.type !== 'assistant' || !Array.isArray(c)) continue;
+    for (const u of c) {
+      if (u?.type !== 'tool_use') continue;
+      const input = u.input || {};
+      const result = results.get(u.id) || { present: false, error: false };
+      if (['Edit', 'Write', 'MultiEdit', 'NotebookEdit'].includes(u.name)) {
+        events.push({ kind: 'change', what: `${u.name} ${input.file_path || input.notebook_path || ''}`.trim() });
+      } else if (u.name === 'Bash') {
+        for (const seg of segments(input.command)) {
+          if (segmentMutates(seg)) events.push({ kind: 'change', what: seg.slice(0, 120) });
+          else if (segmentChecks(seg)) events.push({ kind: 'check', what: seg.slice(0, 120), name: checkName(seg), ...result });
+        }
+      } else if (u.name === 'Agent' || u.name === 'Task') {
+        if (!READ_ONLY_AGENTS.test(String(input.subagent_type || ''))) events.push({ kind: 'change', what: `${u.name} ${input.subagent_type || 'agent'}` });
+      } else if (String(u.name || '').startsWith('mcp__')) {
+        events.push(MCP_MUTATING.test(u.name) ? { kind: 'change', what: u.name }
+          : { kind: 'check', what: u.name, name: u.name.split('__').pop(), ...result });
+      }
+    }
+  }
+  return { boundaryFound, events };
+}
+
+/** Verification that ran AFTER the last state change this turn, with a present, non-error result. */
+export function postChangeVerification(turn) {
+  const events = turn?.events || [];
+  let lastChange = -1;
+  events.forEach((e, i) => { if (e.kind === 'change') lastChange = i; });
+  const checks = events.slice(lastChange + 1).filter((e) => e.kind === 'check' && e.present && !e.error);
+  return { lastChange: lastChange >= 0 ? events[lastChange].what : null, checks,
+    staleChecks: events.slice(0, Math.max(0, lastChange)).filter((e) => e.kind === 'check').length };
+}
+
+export function readClaudeTurn(transcriptPath, { read = readSettledTranscript } = {}) {
+  if (typeof transcriptPath !== 'string' || !/\.jsonl$/i.test(transcriptPath)) return null;
+  try { return claudeTurnEvents(read(transcriptPath, { maxMs: 0 })); } catch { return null; }
+}
+
+/**
+ * The completion audit. `turn` is claudeTurnEvents() output, or null when the host transcript is
+ * unavailable/unparsed (then the transcript half is UNKNOWN and says so).
+ */
+export function auditCompletionClaims(message, { turn = null, host = 'claude' } = {}) {
+  const claims = extractCompletionClaims(message);
+  if (!claims.length) return { verdict: 'NONE', claims };
+  const text = String(message || '');
+  const verification = turn ? postChangeVerification(turn) : null;
+  const names = verification?.checks.map((c) => String(c.name || '').toLowerCase()).filter((n) => n.length >= 3) || [];
+  const namesCheck = NAMED_CHECK.test(text) || names.some((n) => text.toLowerCase().includes(n));
+  const disclosesGaps = DISCLOSES_GAPS.test(strippedProse(text).replace(/```[\s\S]*?```/g, ''))
+    || DISCLOSES_GAPS.test(text);
+  const problems = [];
+  if (!turn) problems.push(`this host's (${host}) transcript is unavailable or not parsed, so whether a check ran after the change is UNKNOWN`);
+  else if (!verification.checks.length) {
+    problems.push(verification.lastChange
+      ? `no end-to-end check ran this turn after the last change (${verification.lastChange})`
+      : 'no end-to-end check ran this turn');
+  }
+  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';
+  return { verdict, claims, verification, namesCheck, disclosesGaps, problems };
+}
+
+// ── promises (first-person commitments) ─────────────────────────────────────────────────────────
+const PROMISE_LEAD = /\b(?:I(?:'ll|’ll|\s+will)|I(?:'m|’m|\s+am)\s+going\s+to|next,?\s+I(?:'ll|’ll|\s+will)|I\s+commit\s+to)\s+(?:now\s+|next\s+|then\s+|also\s+|immediately\s+|first\s+)*([a-z][^.!?\n]{6,158})/i;
+const PROMISE_REJECT = /\?|:\*\*|\b(?:if|unless|once|when|whenever|as\s+soon\s+as|after|the\s+moment|until|whether|shortly|regularly|periodically|every\s+\d+|check\s+(?:back|again|on\s+it)|keep\s+(?:watching|an\s+eye)|maybe|might|could|would|probably|perhaps|possibly|option|alternatively|either|or\s+I\s+(?:can|could)|want\s+me|should\s+I|shall\s+I|let\s+you\s+know|wait|await|stand\s+by|hold\s+off|leave\s+(?:it|that|this)\s+to\s+you|happy\s+to|glad\s+to|be\s+honest|note\s+that|keep\s+(?:that|this)\s+in\s+mind|try\s+to|need\s+your|your\s+(?:approval|go-ahead|call|decision|confirmation))\b/i;
+const TRIVIAL_PROMISE = /^(?:not|never|be|say|mention|note|admit|point|flag|stop|stay|leave|keep|summari[sz]e|explain|answer|respond|reply|report|remember|give|tell|send|paste|bring|hand|show|walk|notify|post|update\s+you|come\s+back|get\s+back|handle|only|stand|work)\b/i;
+
+export const normalizePromise = (value) => String(value || '').toLowerCase().replace(/[`*_"“”'’]/g, '')
+  .replace(/[^a-z0-9./:+-]+/g, ' ').trim().slice(0, 160);
+
+/** Non-hedged, present-session, first-person commitments in the FINAL answer. */
+export function extractCommitments(message) {
+  const out = [];
+  const seen = new Set();
+  const lines = strippedProse(message).split('\n');
+  let inPlan = false;
+  for (const raw of lines) {
+    const line = raw.trim();
+    if (/^(?:[-*•]\s*|#+\s*|\*\*)*my\s+plan\b.{0,20}[:—–]\s*$/i.test(line)) { inPlan = true; continue; }
+    const item = inPlan ? /^(?:\d+[.)]|[-*•])\s+(.{6,160})$/.exec(line) : null;
+    if (inPlan && !item && line) inPlan = false;
+    const candidates = item ? [item[1]] : sentences(line).map((s) => PROMISE_LEAD.exec(s)?.[1]).filter(Boolean);
+    const whole = item ? item[1] : line;
+    for (const action of candidates) {
+      if (PROMISE_REJECT.test(whole) || TRIVIAL_PROMISE.test(action.trim())) continue;
+      const text = action.replace(/\s+/g, ' ').trim().replace(/[,;:]$/, '');
+      const key = normalizePromise(text);
+      if (key.length < 6 || seen.has(key)) continue;
+      seen.add(key);
+      out.push({ text, key });
+    }
+  }
+  return out.slice(0, PROMISE_CAP_PER_TURN);
+}
+
+const STOP = new Set(['the', 'a', 'an', 'and', 'or', 'to', 'of', 'in', 'on', 'for', 'with', 'it', 'is', 'are',
+  'this', 'that', 'now', 'next', 'then', 'will', 'be', 'i', 'we', 'all', 'so', 'as', 'at', 'by', 'from']);
+const tokens = (value) => normalizePromise(value).split(' ').filter((t) => t.length > 2 && !STOP.has(t));
+
+/** A passing completion claim closes a promise only when it names the same work. */
+export function claimClosesPromise(claimText, promiseText) {
+  const want = tokens(promiseText);
+  if (!want.length) return false;
+  const have = new Set(tokens(claimText));
+  const hit = want.filter((t) => have.has(t)).length;
+  return hit >= 2 && hit / want.length >= 0.4;
+}