ruvnet-brain 4.3.27 → 4.3.29

package/plugin/scripts/ruvnet-gate1-pattern.mjs

@@ -27,3 +27,20 @@ export const RUVNET_GATE1_PATTERN =
 export function ruvnetGate1Matches(text) {
   return new RegExp(RUVNET_GATE1_PATTERN, 'i').test(String(text ?? ''));
 }
+
+/**
+ * H1 / GitHub #316: the plain substring vocabulary mechanically derived from RUVNET_GATE1_PATTERN —
+ * one lowercased term per `|`-separated alternative, with the `\b` word-boundary anchors stripped
+ * (irrelevant to a substring scan) and the one optional-plural alternative ("swarms?") reduced to
+ * its shortest substring-safe form ("swarm", which is a substring of both "swarm" and "swarms").
+ *
+ * This is the ONE vocabulary grounding-stamp.sh's GATE1_ONLY_TERMS must mirror byte-for-byte
+ * (tests/unit/grounding-stamp-terms.test.mjs enforces it, same idiom as
+ * tests/unit/ruvnet-gate1-pattern.test.mjs's byte-identity check against ground-ruvnet.sh). Before
+ * that fix, grounding-stamp.sh hard-coded its own narrower 9-term list that omitted `ruvnet` itself
+ * — so a search literally about "ruvnet" minted no stamp and grounding-turn-gate.mjs's Stop-time
+ * check wrongly reported "no successful search_ruvnet call this turn".
+ */
+export const RUVNET_GATE1_TERMS = RUVNET_GATE1_PATTERN
+  .split('|')
+  .map((alt) => alt.replace(/\\b/g, '').replace(/s\?$/, '').toLowerCase());

package/plugin/scripts/session-start-core.mjs

@@ -283,8 +283,6 @@ export async function runSessionStart({
       } else if (running) {
         write(path.join(stateDir, '.dev-version'), `${running}\n`);
       }
-      const source = json(path.join(home, '.cache', 'ruvnet-brain', 'kb', 'SOURCE.json'), {});
-      const kbVersion = typeof source?.releaseTag === 'string' ? source.releaseTag : '';
       const readiness = mcpReadiness(env, home);
 
       const grounding = json(path.join(stateDir, 'install-state.json'));
@@ -315,10 +313,18 @@ export async function runSessionStart({
       // alarm mechanism as HEALTH ALARM above (never gated by maintainerIssueEntitlement).
       emit(`[RuvNet Brain v${bannerVersion} — active this session${updated ? ` · updated ${updated}` : ''}]`);
       bannerEmitted = true;
-      const bundleTag = String(kbVersion).replace(/^v/, '');
-      if (bundleTag && bannerVersion !== 'unknown' && bundleTag !== bannerVersion) {
+      // S2 (ONE CURRENCY VERDICT): this no longer compares the KB's own SOURCE.json releaseTag to the
+      // plugin version — that heuristic fires a FALSE POSITIVE for the entire (normal, expected)
+      // window between the plugin auto-updating and the KB's own background --check catching up, and
+      // it duplicated, less accurately, a comparison kb/forge-update.mjs already makes properly
+      // (against the LIVE canonical release, not a locally-observed string). Instead this reads the
+      // recorded verdict from the SessionStart heartbeat's own `--check --result-file` run — the SAME
+      // structured verdict --apply and bin/install.mjs read — and only alarms on a genuine CODE-release
+      // mismatch (a corpus-only update does not mean the plugin's own code is out of sync).
+      const kbCheck = json(path.join(stateDir, '.last-kb-check-result.json'));
+      if (kbCheck?.currencyVerdict === 'UPDATE_AVAILABLE' && kbCheck?.candidateKind === 'code') {
         emit('🚨 [RuvNet Brain — INSTALL ALARM: plugin and knowledge bundle are out of sync] 🚨');
-        emit(`Your plugin is v${bannerVersion} but the knowledge bundle on this machine is v${bundleTag} — they are meant to ship together, so search results may not match this plugin's behavior yet. Fix: npx ruvnet-brain@latest --update (or reinstall: npx github:stuinfla/ruvnet-brain --force).`);
+        emit(`${kbCheck.currencyReason || 'a newer code release is available'} — they are meant to ship together, so search results may not match this plugin's behavior yet. Fix: npx ruvnet-brain@latest --update (or reinstall: npx github:stuinfla/ruvnet-brain --force).`);
       }
 
       const hookContracts = readHookContracts(path.join(pluginRoot, 'hooks', 'hook-contracts.json'));

package/plugin/scripts/session-start-update-plane.mjs

@@ -77,8 +77,12 @@ export const heartbeat = ({ env, hookDir, stateDir, home, running, seedDispatche
     if (/\bBEHIND\b/.test(read(kbLog))) {
       emit('[RuvNet Brain — a newer knowledge bundle is available. It is signed (Ed25519) and the updater verifies that signature before extracting anything. We do NOT auto-apply it: applying replaces executable tool files, which is your call. To update: cd ~/.cache/ruvnet-brain/kb && node forge-update.mjs --apply]');
     }
+    // S2 (ONE CURRENCY VERDICT): --result-file records the SAME structured verdict --check/--apply
+    // and bin/install.mjs already read (forge-update.mjs's currencyVerdict()), at the well-known path
+    // session-start-core.mjs's banner stage reads it from — so the banner's own "is my code out of
+    // sync" alarm reads this recorded verdict instead of re-deriving its own comparison.
     dispatchDetached(hookDir, 60, kbLog, process.execPath,
-      [path.join(kbDir, 'forge-update.mjs'), '--check'], env);
+      [path.join(kbDir, 'forge-update.mjs'), '--check', '--result-file', path.join(stateDir, '.last-kb-check-result.json')], env);
   }
   const versionLog = path.join(stateDir, '.last-version-check.log');
   const remoteVersion = firstVersion(read(versionLog));

package/plugin/scripts/unprompted-runtime.mjs

@@ -86,7 +86,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
-import { readStdinBounded } from './hook-input.mjs';
+import { readStdinBounded, isHarnessGenerated } from './hook-input.mjs';
 import { resolveBash } from './hook-shim-bash.mjs';
 
 // WHERE THIS FILE'S SIBLINGS LIVE. Resolved from THIS file's own location so it is correct under the
@@ -112,9 +112,16 @@ const SCRIPTS_DIR = path.dirname(SELF);                     // the payload's scr
 // The CC event name the shim forwarded. No event → nothing to run; stay silent.
 const EVENT = process.argv[2] || '';
 
-// Bound the whole runtime well under the 5s hook budget: producers run sequentially and each has its
-// own internal watchdog, but a backstop timeout here means a wedged producer can never hang the turn.
-const PRODUCER_TIMEOUT_MS = Number(process.env.RUVNET_UNPROMPTED_TIMEOUT_MS) || 4000;
+// Bound the whole runtime well under this hook's DECLARED timeout (hooks.json / codex-hooks.json:
+// 'unprompted-speech' is 3s, not the 5s this comment used to assume) — producers run sequentially and
+// each has its own internal watchdog, but a backstop timeout here means a wedged producer can never
+// hang the turn. Found live 2026-09-27: the old 4000ms default left NO real margin under a 3000ms
+// declared timeout once Node startup + per-producer spawnSync overhead is counted, and slower
+// per-process-spawn hosts (Windows CI) pushed measured wall-clock to 83% of budget — selfcheck.mjs's
+// own 80%-margin rule exists exactly to catch a hook running this close to its declared contract.
+// 2000ms leaves real headroom (Node/import startup + the 80% margin check at 2400ms) on every host,
+// not just a Windows-specific patch.
+const PRODUCER_TIMEOUT_MS = Number(process.env.RUVNET_UNPROMPTED_TIMEOUT_MS) || 2000;
 const MAX_BUFFER = 1 << 20;
 
 const VALID_CHANNELS = new Set(['advocacy', 'promotion', 'lesson', 'alarm']);
@@ -223,6 +230,17 @@ try {
 } catch { /* not JSON → no occasion → silence, below */ }
 if (!event) silent();
 
+// H2: a background task notification, slash-command scaffold, or other harness-authored message
+// arrives on UserPromptSubmit exactly like real user text (wrapped in tags such as
+// <task-notification>, <local-command-caveat>, <system-reminder>, ...). None of that is something a
+// user typed, so no producer here should react to it — an advocacy nudge, a lesson prompt, or a
+// promotion offer fired at the harness's own bookkeeping is noise on every background-task turn.
+// PreToolUse payloads carry no `prompt`/`user_prompt`/`input` field, so this is a no-op for them.
+{
+  const promptText = event.prompt ?? event.user_prompt ?? event.input;
+  if (typeof promptText === 'string' && isHarnessGenerated(promptText)) silent();
+}
+
 const producers = resolveProducers(EVENT);
 if (!producers.length) silent();   // unknown event, or nothing wired for it — never speak on a guess
 
@@ -396,10 +414,13 @@ for (const c of candidates) {
       let offer = true;
       try { offer = led.shouldStillOffer(findingId, { severity, stateHash }); } catch { offer = false; }
       if (!offer) break;                                     // dismissed / budget spent → drop
-      // Deliver, and record the OFFERED denominator centrally (best-effort; recording never breaks
-      // the hook it measures). Moving OFFERED here is what makes precision computable at the one place
-      // that actually decides to show a card.
-      try { led.record({ id: findingId, action: led.ACTIONS.OFFERED, severity, stateHash }); } catch { /* a lost row costs one denominator, never the turn */ }
+      // Persist the OFFERED denominator before delivery. A recommendation whose delivery receipt was
+      // not durably written cannot participate in the later applied/dismissed lifecycle; emitting it
+      // anyway would create a card the next prompt cannot resolve and would make precision lie.
+      let receipt;
+      try { receipt = led.record({ id: findingId, action: led.ACTIONS.OFFERED, severity, stateHash }); }
+      catch { receipt = null; }
+      if (!receipt?.ok) break;
       advisories.push({ copy, hookEventName });
       break;
     }

package/plugin/skills/ruvnet-brain/PLAYBOOK.md

@@ -13,7 +13,7 @@ not all individually audited and remain diagnostics. A diagnostic pass is not pr
 Promote only the clean exact candidate SHA and its sealed artifacts after qualification. Public
 acceptance still requires all nine OS/host-mode leaves plus real native installed-update proof on
 each platform, ending at `install-verified`. Imported upstream corpus freshness remains UNKNOWN
-until separately proven. See `docs/QA-RELEASE-PROCESS.md` and the audit records in `docs/reviews/`.
+until separately proven. See `CONTRIBUTING.md` and the audit records in `docs/reviews/`.
 
 ---
 

package/scripts/adr-072-completion.mjs

@@ -4,9 +4,10 @@ import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { verifyCapabilityClaimAggregate } from '../plugin/scripts/capability-claim-evidence.mjs';
+import { LEGACY_REVIEW_MODEL_IDS } from './review-model-defaults.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
-const REQUIRED_REVIEWERS = Object.freeze(['claude-fable-5', 'gpt-5.6-sol']);
+const REQUIRED_REVIEWERS = LEGACY_REVIEW_MODEL_IDS;
 
 const command = (cwd, bin, args) => {
   const result = spawnSync(bin, args, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });

package/scripts/calibrate-router.mjs

@@ -26,18 +26,18 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { recordOutcome } from './metaharness-router.mjs';
-import { estimateCosts, estTokens } from './route-cheap.mjs';
+import { CLAUDE_MODEL_IDS, estimateCosts, estTokens } from './route-cheap.mjs';
 
 const CLAUDE = path.join(os.homedir(), '.npm-global/bin/claude');
 const RECEIPTS = process.env.METAHARNESS_RECEIPTS
   || path.join(os.homedir(), '.claude', 'metaharness', 'routing-receipts.jsonl');
 
 const MODELS = [
-  { alias: 'haiku', name: 'claude-haiku-4.5' },
-  { alias: 'sonnet', name: 'claude-sonnet-5' },
-  { alias: 'opus', name: 'claude-opus-4.8' },   // the baseline tier
+  { alias: 'haiku', name: CLAUDE_MODEL_IDS.haiku },
+  { alias: 'sonnet', name: CLAUDE_MODEL_IDS.sonnet },
+  { alias: 'opus', name: CLAUDE_MODEL_IDS.opus },   // the baseline tier
 ];
-const BASELINE = 'claude-opus-4.8';
+const BASELINE = CLAUDE_MODEL_IDS.opus;
 
 // Deterministic tasks: known answers, graded by regex — no LLM judge, no judgment calls.
 const TASKS = [
@@ -90,7 +90,7 @@ for (const [ti, task] of TASKS.entries()) {
   }
 }
 
-const cheap = results.flatMap((r) => [r.runs['claude-haiku-4.5'].ms]);
+const cheap = results.flatMap((r) => [r.runs[CLAUDE_MODEL_IDS.haiku].ms]);
 const base = results.map((r) => r.runs[BASELINE].ms);
 const sum = (a) => a.reduce((s, x) => s + x, 0);
 console.log(`\nhaiku total ${(sum(cheap) / 1000).toFixed(1)}s vs opus baseline ${(sum(base) / 1000).toFixed(1)}s on ${TASKS.length} tasks`);

package/scripts/candidate-host-evidence.mjs

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { stagedHostVerifier, readCandidateRetrieval, verifyCandidateRetrievalAssets } from './staged-host-verifier.mjs';
 import { payloadIdFor } from './release-payload.mjs';
 import { validateRetrievalCanaryReceipt } from './retrieval-canary.mjs';
+import { HOST_WARMUP_TIMEOUT_MS, RELEASE_SEARCH_DEADLINE_MS } from './host-install-matrix.mjs';
 
 const arg = (name) => {
   const index = process.argv.indexOf(name);
@@ -12,13 +13,13 @@ const arg = (name) => {
 };
 
 export async function buildCandidateHostEvidence({ manifestFile, packagePath, bundlePath, planFile, coverageFile, failureFile },
-  { createVerifier = stagedHostVerifier } = {}) {
+  { createVerifier = stagedHostVerifier, sequentialSearches = false } = {}) {
   const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
   const payloadId = payloadIdFor(manifest);
   const identity = { version: manifest.version, candidateSha: manifest.candidateSha, payloadId };
   const retrieval = readCandidateRetrieval({ manifest, planFile, coverageFile });
   verifyCandidateRetrievalAssets({ retrieval, assets: { packagePath, bundlePath } });
-  const result = await createVerifier({ assets: { packagePath, bundlePath }, identity, retrieval })
+  const result = await createVerifier({ assets: { packagePath, bundlePath }, identity, retrieval, sequentialSearches })
     .verify({ source: 'candidate', assets: { packagePath, bundlePath } });
   verifyCandidateRetrievalAssets({ retrieval, assets: { packagePath, bundlePath } });
   if (result.verdict !== 'PASS') {
@@ -32,34 +33,60 @@ export async function buildCandidateHostEvidence({ manifestFile, packagePath, bu
   }
 
   const modeNames = { claude: 'claude-only', codex: 'codex-only', dual: 'dual-host' };
-  const leaves = Object.entries(modeNames).map(([mode, name]) => {
+  const leaves = [];
+  const failures = [];
+  for (const [mode, name] of Object.entries(modeNames)) {
     const fixture = result.fixtures?.[mode];
     const grounding = fixture?.grounding;
-    const grounded = grounding && ['repo', 'path', 'file', 'storedPath']
-      .every((field) => typeof grounding[field] === 'string' && grounding[field].trim());
-    if (fixture?.status !== 'PASS' || fixture?.process?.status !== 0 || !grounded) {
-      throw new Error(`${name} did not produce a clean installed-search grounding receipt`);
+    const warmupGrounding = fixture?.warmupGrounding;
+    const hasReceipt = (receipt) => receipt && ['repo', 'path', 'file', 'storedPath']
+      .every((field) => typeof receipt[field] === 'string' && receipt[field].trim());
+    if (!Number.isFinite(fixture?.warmupMs) || fixture.warmupMs < 0 || fixture.warmupMs > HOST_WARMUP_TIMEOUT_MS
+      || !hasReceipt(warmupGrounding) || warmupGrounding.repo !== 'ruvnet-brain') {
+      failures.push(`${name} did not produce a grounded worker warmup within ${HOST_WARMUP_TIMEOUT_MS}ms (${fixture?.warmupMs ?? 'unmeasured'}ms)`);
     }
-    validateRetrievalCanaryReceipt(fixture.retrieval, { plan: retrieval.plan });
-    return {
+    if (!Number.isFinite(fixture?.searchMs) || fixture.searchMs < 0 || fixture.searchMs > RELEASE_SEARCH_DEADLINE_MS) {
+      failures.push(`${name} first measured cited search exceeded the ${RELEASE_SEARCH_DEADLINE_MS}ms candidate deadline (${fixture?.searchMs ?? 'unmeasured'}ms)`);
+    }
+    if (fixture?.status !== 'PASS' || fixture?.process?.status !== 0 || !hasReceipt(grounding)) {
+      failures.push(`${name} did not produce a clean installed-search grounding receipt`);
+    }
+    try { validateRetrievalCanaryReceipt(fixture?.retrieval, { plan: retrieval.plan }); }
+    catch (error) { failures.push(`${name} retrieval canary rejected: ${error.message}`); }
+    leaves.push({
       name,
       sha: manifest.candidateSha,
       payloadId,
-      status: fixture.status === 'PASS' ? 'completed' : 'failed',
-      conclusion: 'success',
+      status: fixture?.status === 'PASS' && fixture?.process?.status === 0 && hasReceipt(grounding) ? 'completed' : 'failed',
+      conclusion: failures.length ? 'failure' : 'success',
       verdict: 'PASS',
       source: 'candidate-host-evidence',
       mode,
-      functionalSearch: true,
-      searchExit: fixture.process.status,
+      functionalSearch: fixture?.status === 'PASS',
+      searchExit: fixture?.process?.status ?? null,
+      warmupMs: fixture?.warmupMs,
+      warmupGrounding,
+      searchMs: fixture?.searchMs,
       grounding,
-      retrieval: fixture.retrieval,
+      retrieval: fixture?.retrieval,
       artifactSha256: retrieval.artifactSha256,
+    });
+  }
+  if (failures.length) {
+    const failure = {
+      schemaVersion: 1, kind: 'ruvnet-brain-candidate-host-failure', verdict: 'FAIL',
+      sha: manifest.candidateSha, payloadId, artifactSha256: retrieval.artifactSha256,
+      candidateArchiveSha256: retrieval.candidateArchiveSha256, planSha256: retrieval.plan.planSha256,
+      failures, result,
     };
-  });
+    if (failureFile) fs.writeFileSync(path.resolve(failureFile), JSON.stringify(failure, null, 2) + '\n',
+      { flag: 'wx', mode: 0o600 });
+    throw new Error(`candidate host matrix failed: ${failures.join('; ')}`);
+  }
   return {
     schemaVersion: 1,
     sha: manifest.candidateSha,
+    hostPlatform: process.platform,
     payloadId,
     artifactSha256: retrieval.artifactSha256,
     leaves,
@@ -68,7 +95,8 @@ export async function buildCandidateHostEvidence({ manifestFile, packagePath, bu
 
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   const evidence = await buildCandidateHostEvidence({ manifestFile: arg('--manifest'),
-    packagePath: arg('--package'), bundlePath: arg('--bundle'), planFile: arg('--plan'), coverageFile: arg('--coverage'), failureFile: arg('--out') ? `${arg('--out')}.failure.json` : null });
+    packagePath: arg('--package'), bundlePath: arg('--bundle'), planFile: arg('--plan'), coverageFile: arg('--coverage'), failureFile: arg('--out') ? `${arg('--out')}.failure.json` : null },
+  { sequentialSearches: process.argv.includes('--sequential-searches') });
   fs.writeFileSync(path.resolve(arg('--out')), `${JSON.stringify(evidence, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
   console.log(JSON.stringify({ verdict: 'PASS', payloadId: evidence.payloadId, leaves: evidence.leaves.map(({ name }) => name) }));
 }

package/scripts/corpus-reconcile.mjs

@@ -17,8 +17,10 @@ import { promoteArtifactSet } from '../kb/incremental-refresh.mjs';
 import { rebuildCorpusAggregates } from './corpus-aggregates.mjs';
 import { assertCapabilityOnlyStore, isCapabilityOnly, CAPABILITY_RETIRED_SUFFIXES } from '../kb/capability-only.mjs';
 import { fileIdentity } from '../plugin/scripts/coverage-integrity.mjs';
+import { readDiagnosticAccuracyReport } from './oracle/retrieval-accuracy.mjs';
 import { storeRoot } from '../kb/store-root.mjs';
 import { captureGistSources } from './gist-receipts.mjs';
+import { projectSourceStore } from './rvf-generation.mjs';
 
 export { rebuildCorpusAggregates };
 
@@ -540,7 +542,13 @@ export async function executeReconciliation({
       promotedFiles.push(file.name);
     }
     mergedLedger.stores[result.store] = result.generation;
-    mergedSource.stores[result.store] = result.source;
+    // S4 (ONE PROVENANCE RECORD): re-project the merged SOURCE.json entry FROM the merged ledger
+    // row rather than trusting the worker's own already-written SOURCE.json fragment verbatim —
+    // the merge boundary is where multiple workers' results combine, so it is the right place to
+    // assert "the ledger is the source of truth" rather than assume every worker upheld it.
+    // `result.source` (validateWorkerOutput's read of the worker's own output, already checked
+    // there to bind the exact upstream SHA) supplies the non-identity updater fields unchanged.
+    mergedSource.stores[result.store] = projectSourceStore(result.store, result.generation, result.source);
   }
   mergedLedger.stores = Object.fromEntries(Object.entries(mergedLedger.stores).sort(([a], [b]) => a.localeCompare(b)));
   mergedSource.stores = Object.fromEntries(Object.entries(mergedSource.stores).sort(([a], [b]) => a.localeCompare(b)));
@@ -766,12 +774,33 @@ export function prepareCorpusCandidate({
   // bounded run (--stores/--sample) still writes a report, but it marks itself incomplete and the
   // seal refuses it, so a bounded measurement can never be presented as a corpus-wide pass.
   const accuracyReportFile = `${bundleFile}.accuracy.json`;
-  checked(run, process.execPath, [accuracyScript, '--bundle', bundleFile,
+  // A stale leftover report from a prior run must never be mistaken for a fresh measurement of
+  // THIS bundle -- delete it before invoking the script so only a report the script just wrote
+  // (or none at all) can be found below.
+  fs.rmSync(accuracyReportFile, { force: true });
+  const accuracyResult = run(process.execPath, [accuracyScript, '--bundle', bundleFile,
     '--oracle', accuracyOracle, '--out', accuracyReportFile,
     ...(accuracyStores != null ? ['--stores', String(accuracyStores)] : []),
     ...(accuracySample != null ? ['--sample', String(accuracySample)] : []),
     ...(accuracyTimeoutMs != null ? ['--timeout-ms', String(accuracyTimeoutMs)] : [])],
-  { stdio: 'inherit' });
+  { stdio: 'inherit' }) || {};
+  // C3 was demoted to a non-blocking diagnostic on 2026-09-15 (commit a20727b7, ADR-086
+  // amendment) -- every other caller (corpus-candidate.mjs, release.mjs, corpus-seed.yml) reads
+  // it through readDiagnosticAccuracyReport, which checks the report's integrity/archive binding,
+  // never its score. A nonzero exit here is therefore NOT immediately fatal: it may just mean the
+  // measured score fell below the (no-longer-enforced) threshold. What stays fatal is a CRASHED
+  // measurement -- no valid report bound to this exact archive was produced at all.
+  if (accuracyResult.error || accuracyResult.status !== 0) {
+    let diagnostic;
+    try {
+      diagnostic = readDiagnosticAccuracyReport({ reportFile: accuracyReportFile, archive: fileIdentity(bundleFile) });
+    } catch (error) {
+      fail(`retrieval-accuracy diagnostic (C3) crashed with no valid report to show for it: ${error.message}`);
+    }
+    console.log(`[corpus-reconcile] C3 retrieval-accuracy diagnostic scored below its (non-blocking) `
+      + `threshold: state=${diagnostic.state} classification=${diagnostic.classification} `
+      + `totals=${JSON.stringify(diagnostic.totals)} -- continuing, C3 is advisory only.`);
+  }
   // THE BLOCKING RETRIEVAL GATE (ADR-086 amendment 2026-09-15). Same placement and same discipline
   // as the C3 run above — the EXTRACTED final archive through the customer query path — but this is
   // the measurement that can refuse a candidate. It asks the 194 frozen human questions, one per

package/scripts/correction-detect.mjs

@@ -188,6 +188,8 @@
 // industrialised. `confidence` orders the ratification queue and does nothing else — a confidence
 // threshold is just ratification with the human removed and the word "confidence" in front of it.
 
+import { HARNESS_GENERATED_PATTERNS } from '../plugin/scripts/hook-input.mjs';
+
 /** Corrections are short. The measured tightened detector used this bound; specs and briefs exceed it. */
 export const MAX_UTTERANCE_CHARS = 800;
 
@@ -224,18 +226,15 @@ export const ACCEPTED_MISSES = Object.freeze([
  * speech at all. The detector was right to ignore them; the pool handed them to a human to label
  * anyway, burning ~29% of the scarcest resource in this whole problem (labelled examples) on rows
  * whose answer is definitionally "no", and diluting the base rate with them.
+ *
+ * H2 (2026-09-26): re-exported from plugin/scripts/hook-input.mjs's HARNESS_GENERATED_PATTERNS
+ * rather than kept as this file's own literal array. Other UserPromptSubmit consumers
+ * (unprompted-runtime.mjs, capacity-aware-parallel-work.mjs, grounding-turn-mark.mjs) needed the
+ * exact same recognition and, before this fix, had no shared place to get it from — hook-input.mjs
+ * is that ONE owner now; this name stays so correction-detect-measure.mjs and this file's own test
+ * do not need to change.
  */
-export const HARNESS_TEMPLATES = [
-  /\[Your previous response/i,
-  /\[Request interrupted/i,
-  /<\/?system-reminder>/i,
-  /<\/?(?:command-name|command-message|command-args|local-command-stdout|local-command-stderr|local-command-caveat|task-notification|function_results|function_calls|budget)\b/i,
-  /^\s*Caveat:/i,
-  /Base directory for this skill:/i,
-  /This session is being continued from a previous conversation/i,
-  /^\s*#\s*claudeMd\b/im,
-  /\[INTELLIGENCE\]/i,
-];
+export const HARNESS_TEMPLATES = HARNESS_GENERATED_PATTERNS;
 
 /**
  * Pasted content, not speech. Includes markdown structure — this repository's own ADRs and DDDs are

package/scripts/dispatch-receipt.mjs

@@ -25,7 +25,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { CLAUDE_TIERS, PRICING, estTokens, estimateCosts, receiptLine, receiptsPath, priceOf } from './route-cheap.mjs';
+import { CLAUDE_MODEL_IDS, CLAUDE_TIERS, PRICING, estTokens, estimateCosts, receiptLine, receiptsPath, priceOf } from './route-cheap.mjs';
 
 // Default input share when only a MEASURED TOTAL is known. A subagent's tokens are dominated by input
 // (it re-reads files and tool output on every turn); its final report is small. 0.9 is an assumption,
@@ -33,7 +33,7 @@ import { CLAUDE_TIERS, PRICING, estTokens, estimateCosts, receiptLine, receiptsP
 const DEFAULT_INPUT_SHARE = 0.9;
 
 export function parseArgs(argv) {
-  const args = { model: 'claude-haiku-4.5', inherited: 'claude-opus-4.8', class: 'mechanical' };
+  const args = { model: CLAUDE_MODEL_IDS.haiku, inherited: CLAUDE_MODEL_IDS.opus, class: 'mechanical' };
   for (let i = 0; i < argv.length; i++) {
     const k = argv[i];
     if (['--model', '--inherited', '--task', '--class', '--in-chars', '--out-chars', '--label', '--total-tokens', '--split'].includes(k)) {

package/scripts/dual-host-deliberation.mjs

@@ -5,13 +5,14 @@ import fs from 'node:fs';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { probeSubscriptionHosts, subscriptionOnlyEnv } from './subscription-hosts.mjs';
+import { DUAL_HOST_MODEL_IDS } from './review-model-defaults.mjs';
 
 const HOSTS = Object.freeze(['claude-code', 'codex']);
 // Top subscription models verified on the native hosts on 2026-09-10.
 // Keep these explicit: an implicit host default silently weakens the dual review.
 export const TOP_SUBSCRIPTION_MODELS = Object.freeze({
-  'claude-code': 'claude-fable-5-1',
-  codex: 'gpt-6-astra',
+  'claude-code': DUAL_HOST_MODEL_IDS.claude,
+  codex: DUAL_HOST_MODEL_IDS.codex,
 });
 const HARD_PROBLEM = /\b(adr|architecture|architect|ddd|bounded context|aggregate|agentic[- ]?qe|holistic|security|production|migration|irreversible|threat model|experience)\b/i;
 

package/scripts/execution-policy.mjs

@@ -4,6 +4,7 @@
 
 const NATIVE_HOSTS = new Set(['claude', 'codex']);
 const API_EXECUTORS = new Set(['agent_execute', 'sdk', 'openrouter', 'api']);
+const ACTIONS = new Set(['read', 'write', 'delegate', 'release', 'external']);
 const ARCHITECTURE_TERMS = /\b(adr|ddd|architecture|release|deploy|qa|security|schema|migration)\b/i;
 const CONSEQUENTIAL_ACTIONS = new Set(['delegate', 'write', 'release', 'external']);
 const FRESHNESS_MS = 30 * 60 * 1000;
@@ -33,8 +34,8 @@ export function validateEvidence(input = {}, now = Date.now()) {
   if (!memory || memory.status !== 'retrieved' || !fresh(memory.observedAt, now)) {
     failures.push('fresh exact AgentDB checkpoint retrieval is required');
   } else {
-    if (!String(memory.path || '').endsWith('/.swarm/memory.db')) failures.push('memory receipt must use the project .swarm/memory.db');
-    if (!/^project-state-current-\d+$/.test(String(memory.key || ''))) failures.push('memory receipt must retrieve an append-only project-state-current key');
+    if (!/[\\/]\.swarm[\\/]memory\.db$/.test(String(memory.path || ''))) failures.push('memory receipt must use the project .swarm/memory.db');
+    if (!/^project-state-current-\d+(?:-[A-Za-z0-9][A-Za-z0-9_-]*)?$/.test(String(memory.key || ''))) failures.push('memory receipt must retrieve an append-only project-state-current key');
     if (!hex64(memory.valueDigest)) failures.push('memory receipt must bind the retrieved value digest');
   }
   return { valid: failures.length === 0, failures };
@@ -46,6 +47,13 @@ export function classifyExecutionPolicy(input = {}) {
   const changedFiles = [...new Set((input.changedFiles || []).map(String).filter(Boolean))];
   const nativeHosts = [...new Set((input.nativeHosts || []).map(String).filter((h) => NATIVE_HOSTS.has(h)))];
   const requestedExecutor = String(input.requestedExecutor || '');
+  if (!ACTIONS.has(action)) {
+    return {
+      schema: 'ruvnet-brain.execution-policy.v1',
+      verdict: 'REFUSE', action, swarmRequired: false, swarmReason: 'invalid-action',
+      executor: 'unknown', reason: 'unsupported-action', evidence: { valid: false, failures: ['action must be one of read, write, delegate, release, external'] },
+    };
+  }
   const explicitSwarm = input.explicitSwarm === true;
   const multiFile = changedFiles.length >= 3;
   const architectureTask = ARCHITECTURE_TERMS.test(description) || ['release', 'external'].includes(action);

package/scripts/gen-console-images.mjs

@@ -24,7 +24,6 @@ const STYLE = ' — Style: deep near-black background (#0a0c10), sophisticated p
 
 const IMAGES = [
   { slug: 'hero', size: '1536x1024', p: 'A warm amber intelligence gently understanding a computer: soft glowing amber and gold neural filaments and threads of light weaving and resolving out of a faint tangle on the left into an elegant, orderly, translucent crystalline lattice of floating glass panels and cards on the right — the feeling of messy machine settings being calmly brought into clear, beautiful order. Lots of soft dark negative space on the right for text.' },
-  { slug: 'memory', size: '1024x1024', p: 'A single luminous softly-glowing sphere of warm amber and cyan light, made of countless fine interwoven filaments, holding its shape calmly in dark space — an abstract emblem of a mind that remembers; serene, alive, precise.' },
 ];
 
 async function gen(model, prompt, size) {

package/scripts/gen-images.mjs

@@ -15,10 +15,6 @@ const STYLE = ' — Style: dark near-black background (#0b0d0f) with a faint blu
 
 const IMAGES = [
   { slug: 'hero', size: '1536x1024', p: 'A luminous intricate three-dimensional structure resembling a brain fused with a vast interconnected codebase: thousands of glowing amber and cyan filaments forming one elegant organized sphere of intelligence, floating in dark space, a sense of all knowledge made orderly and alive.' },
-  { slug: 'problem-skim', size: '1536x1024', p: 'A vast deep canyon made of densely stacked layers of code and documents descending far into darkness; a single small fragile light hovers at the very top only grazing the surface, never reaching the immense depth below. The feeling of skimming and missing everything underneath.' },
-  { slug: 'point-deeper', size: '1536x1024', p: 'One precise clean beam of warm amber light cutting straight down through many deep translucent strata of a vast structure to perfectly illuminate a single exact point far below; surgical precision locating the one true answer in the depths.' },
-  { slug: 'architecture', size: '1536x1024', p: 'An elegant isometric exploded view of five translucent glass layers floating one above another in dark space, each a slightly different luminous tone, joined by thin vertical conduits of light; a refined premium product render of a clean layered system.' },
-  { slug: 'proof', size: '1536x1024', p: 'Three distinct elegant luminous measuring instruments aim converging beams of light onto a single crystalline object at center that glows confident green, while one beam exposes a hidden flaw glowing warning red; independent rigorous verification against a single source of truth.' },
 ];
 
 async function gen(model, prompt, size) {