ruvnet-brain 4.3.28 → 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/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) {

package/scripts/host-install-matrix.mjs

@@ -37,6 +37,9 @@ export const SELF_STORE_PROOF_K = 1;
 export const RELEASE_SEARCH_QUERY = 'repo:ruvnet-brain How does RuvNet Brain prove a public release artifact?';
 export const HOST_WARMUP_TIMEOUT_MS = 300_000;
 export const RELEASE_SEARCH_DEADLINE_MS = 30_000;
+// The shared model-cache prewarm's own candidate pool size, named so the test asserting on it
+// derives from this constant instead of restating the digit as a second, driftable literal.
+export const PREWARM_POOL_SIZE = 8;
 
 /** Which CLIs each mode is allowed to see. A codex-only box genuinely has no `claude`. */
 export const MODE_HOSTS = Object.freeze({
@@ -261,7 +264,7 @@ export async function runHostMatrixAsync({
   // Mac/Windows/Linux runner speed does not determine whether the later real host searches run.
   // The following MCP matrix remains the measured, source-grounded candidate acceptance.
   const prewarm = await runCommand(process.execPath, [prewarmReader, '--dir', prewarmContext.env.RUVNET_BRAIN_KB,
-    '--q', RELEASE_SEARCH_QUERY, '--k', '1', '--pool', '8',
+    '--q', RELEASE_SEARCH_QUERY, '--k', '1', '--pool', String(PREWARM_POOL_SIZE),
     '--repos', 'ruvnet-brain', '--bounded'], {
     cwd: prewarmContext.env.RUVNET_BRAIN_KB, env: prewarmContext.env, timeout: 300_000,
   });
@@ -310,9 +313,9 @@ export async function runHostMatrixAsync({
         warmupGrounding, error: `MCP search grounding unproven for ${context.mode}` };
       let receipt;
       if (retrieval) {
-        receipt = await runRetrievalCanaries({ ...retrieval,
-          search: async ({ query, k }) => {
-            const result = await searchMcp({ mode: context.mode, serverPath, env: context.env, query, k });
+        receipt = await runRetrievalCanaries({ ...retrieval, searchTimeoutMs: RELEASE_SEARCH_DEADLINE_MS,
+          search: async ({ query, k, timeoutMs }) => {
+            const result = await searchMcp({ mode: context.mode, serverPath, env: context.env, query, k, timeoutMs });
             if (result.error || result.status !== 0) throw new Error(`canary MCP search failed: ${processDiagnostic(result)}`);
             return parseRetrievalResult(result.mcpResult, { query, k });
           },

package/scripts/independent-review-receipt.mjs

@@ -5,12 +5,11 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { canonicalJson, digest } from './coverage-integrity.mjs';
 import { transactionIdFor } from './release-transaction.mjs';
+import { CLAUDE_FABLE_5_ID, GPT_5_6_SOL_ID, LEGACY_REVIEWER_IDENTITIES } from './review-model-defaults.mjs';
 const HEX40 = /^[a-f0-9]{40}$/;
 const HEX64 = /^[a-f0-9]{64}$/;
 const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
-export const ALLOWED_INDEPENDENT_REVIEWERS = Object.freeze([
-  Object.freeze({ identity: 'claude-fable-5', model: 'claude-fable-5', provider: 'firstParty' }),
-  Object.freeze({ identity: 'gpt-5.6-sol', model: 'gpt-5.6-sol', provider: 'openai' })]);
+export const ALLOWED_INDEPENDENT_REVIEWERS = LEGACY_REVIEWER_IDENTITIES;
 
 const INPUT_KEYS = Object.freeze([
   'artifactSha256', 'deductions', 'execution', 'findings', 'id', 'independent', 'model', 'payloadId',
@@ -222,17 +221,17 @@ function reviewerFor(input) {
 }
 
 function normalizeExecution(execution, reviewer) {
-  const required = reviewer.identity === 'gpt-5.6-sol'
+  const required = reviewer.identity === GPT_5_6_SOL_ID
     ? ['catalogRowSha256', 'invocationDigest', 'subscriptionAuthenticated', 'threadId']
     : ['invocationDigest', 'subscriptionAuthenticated'];
-  if (reviewer.identity === 'gpt-5.6-sol'
+  if (reviewer.identity === GPT_5_6_SOL_ID
     && (!Object.hasOwn(execution || {}, 'threadId') || !Object.hasOwn(execution || {}, 'catalogRowSha256'))) {
     throw new Error('GPT review thread and catalog evidence are required');
   }
   exactKeys(execution, required, 'review execution');
   if (execution.subscriptionAuthenticated !== true) throw new Error('review execution is not subscription authenticated');
   hex(execution.invocationDigest, HEX64, 'review invocation digest');
-  if (reviewer.identity === 'gpt-5.6-sol') {
+  if (reviewer.identity === GPT_5_6_SOL_ID) {
     text(execution.threadId, 'GPT review thread');
     hex(execution.catalogRowSha256, HEX64, 'GPT review catalog row');
   }
@@ -479,8 +478,8 @@ export function main(args = process.argv.slice(2), runtime = {}) {
       readJson(options['--sol'], 'Sol review receipt')];
     const ordered = validateIndependentReviewPair(receipts, {
       publicKeysByReviewer: {
-        'claude-fable-5': readRegular(options['--fable-public-key'], 'Fable review public key'),
-        'gpt-5.6-sol': readRegular(options['--sol-public-key'], 'Sol review public key'),
+        [CLAUDE_FABLE_5_ID]: readRegular(options['--fable-public-key'], 'Fable review public key'),
+        [GPT_5_6_SOL_ID]: readRegular(options['--sol-public-key'], 'Sol review public key'),
       },
       expectedIdentity: options['--expected-identity']
         ? readJson(options['--expected-identity'], 'expected review identity') : null,

package/scripts/ingest-repo.mjs

@@ -21,6 +21,7 @@ import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { FULL_HINTS, KEEP_DIRS } from './full-hints.mjs';
 import { storeRoot } from '../kb/store-root.mjs';
+import { applyPrivateOverlay } from './private-overlay.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const arg = (f, d) => { const i = process.argv.indexOf(f); return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : d; };
@@ -118,15 +119,58 @@ const carded = (() => {
 // The stores themselves cannot be committed. The FACT that they were ingested can, so a wipe
 // becomes detectable and replayable instead of silent and permanent. This record is the recipe.
 if (ok) {
+  let rest = [];
   try {
     const ledger = path.join(ROOT, 'kb', 'local-ingests.json');
     const prior = fs.existsSync(ledger) ? JSON.parse(fs.readFileSync(ledger, 'utf8')) : { ingests: [] };
-    const rest = (prior.ingests || []).filter((e) => e.name !== NAME);
+    rest = (prior.ingests || []).filter((e) => e.name !== NAME);
     rest.push({ name: NAME, org: ORG, at: new Date().toISOString(), store: kb });
     rest.sort((a, b) => a.name.localeCompare(b.name));
     fs.writeFileSync(ledger, `${JSON.stringify({ ingests: rest }, null, 2)}\n`);
     console.log(`[record] kb/local-ingests.json — ${rest.length} local ingest(s) recorded. COMMIT THIS.`);
   } catch (e) { console.log(`[record] could not record the ingest: ${e.message}`); }
+
+  // S3 (explicit local ownership): stamp updateManaged:false + origin:'local-ingest' into the LIVE
+  // store root's own SOURCE.json (via scripts/private-overlay.mjs's writer — --from equals --root
+  // here, since forge-refresh.mjs already wrote the bytes directly into KB; the writer degenerates
+  // to registry-stamping only, see its own header). Without this a store built through THIS script
+  // reads exactly like a normal public store to kb/forge-update.mjs — unmarked, and therefore
+  // silently deleted the moment it is absent from an incoming public bundle.
+  //
+  // ONE-TIME MIGRATION for stores this script ingested BEFORE this fix shipped: every OTHER name
+  // this ledger already recorded is retroactively re-stamped too, provided its files still exist and
+  // it is not already an update-managed (public) SOURCE.json entry. This runs HERE — where the
+  // recipe ledger (kb/local-ingests.json, git-tracked in the checkout) and the live store root (KB,
+  // ~/.cache/ruvnet-brain/kb by default — a DIFFERENT, non-git-tracked directory, see kb/store-
+  // root.mjs) are both actually in scope in the same process — rather than inside kb/forge-update.mjs,
+  // which runs against an installed KB tree with no reliable path back to this checkout's ledger.
+  const candidateNames = [...new Set([kb, ...rest.map((e) => e.store).filter(Boolean)])];
+  const sourceFile = path.join(KB, 'SOURCE.json');
+  let liveSourceStores = {};
+  try { liveSourceStores = JSON.parse(fs.readFileSync(sourceFile, 'utf8')).stores || {}; } catch { /* handled by applyPrivateOverlay below */ }
+  const toStamp = candidateNames.filter((name) => {
+    const existing = liveSourceStores[name];
+    if (existing && existing.updateManaged !== false) return false; // a real public store — never shadow it
+    return [`${name}.big.rvf`, `${name}.big.rvf.embed.json`, `${name}.big.rvf.idmap.json`, `${name}.meta.json`, `${name}.passages.jsonl`]
+      .every((file) => fs.existsSync(path.join(KB, file)));
+  });
+  if (toStamp.length) {
+    try {
+      const fenceFile = path.join(KB, 'PRIVATE-STORES.json');
+      const fence = fs.existsSync(fenceFile) ? JSON.parse(fs.readFileSync(fenceFile, 'utf8')) : { privateStores: [] };
+      const fenceNames = new Set((fence.privateStores || []).map((n) => String(n).toLowerCase()));
+      const additions = toStamp.filter((name) => !fenceNames.has(name.toLowerCase()));
+      if (additions.length) {
+        fence.privateStores = [...new Set([...(fence.privateStores || []), ...additions])].sort();
+        fs.writeFileSync(fenceFile, `${JSON.stringify(fence, null, 2)}\n`);
+      }
+      const receipt = applyPrivateOverlay({ root: KB, from: KB, stores: toStamp, origin: 'local-ingest' });
+      const stamped = receipt.stores.filter((entry) => entry.changes.includes('SOURCE.json')).map((entry) => entry.name);
+      if (stamped.length) console.log(`[local-ownership] marked updateManaged:false (origin: local-ingest) — ${stamped.join(', ')}`);
+    } catch (e) {
+      console.log(`[local-ownership] could not stamp local ownership (${e.message}); the next forge-update.mjs --apply may remove ${toStamp.join(', ')} if they are absent from the incoming bundle`);
+    }
+  }
 }
 
 console.log(!ok

package/scripts/learning-replay-cli.mjs

@@ -35,6 +35,7 @@ import {
   writeArtifact,
 } from './learning-replay-proof.mjs';
 import { ROOT } from './learning-replay-contract.mjs';
+import { GPT_5_6_SOL_ID } from './review-model-defaults.mjs';
 
 const usage = () => `Usage:
   node scripts/learning-replay.mjs [--trap ${TRAP.MEMORY_SEARCH}|${TRAP.POST_TASK}] [--n N] [--host codex|claude-code] [--model MODEL]
@@ -94,7 +95,7 @@ export async function main(argv = process.argv.slice(2)) {
   const mutant = arg('--mutant', null);
   const trap = arg('--trap', TRAP.MEMORY_SEARCH);
   const host = arg('--host', 'codex');
-  const model = arg('--model', host === 'codex' ? 'gpt-5.6-sol' : 'haiku');
+  const model = arg('--model', host === 'codex' ? GPT_5_6_SOL_ID : 'haiku');
   const n = Math.max(1, parseInt(arg('--n', mutant ? '1' : '3'), 10) || 1);
   const outFile = arg('--out', mutant
     ? MUTANT_RESULT_FILES[trap]?.[mutant]

package/scripts/learning-replay-fixture.mjs

@@ -19,6 +19,7 @@ import {
   PROJECT_B_MEMORY_VALUE,
   RUFLO_BIN,
 } from './learning-replay-execution.mjs';
+import { GPT_5_6_SOL_ID } from './review-model-defaults.mjs';
 
 const CLAUDE_BIN = process.env.RUVNET_CLAUDE_BIN
   || path.join(os.homedir(), '.npm-global', 'bin', 'claude');
@@ -266,7 +267,7 @@ export function codexReplayInstrumentationError(events, sequence, attempts) {
 }
 
 export function buildCodexArgv({
-  model = 'gpt-5.6-sol',
+  model = GPT_5_6_SOL_ID,
   prompt = REPLAY_PROMPT,
   appendSystemPrompt = null,
   brainHome,

package/scripts/learnings.mjs

@@ -8,13 +8,22 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { learningScope, learnerCwd } from '../plugin/scripts/runtime-preferences.mjs';
 
 const HOME = os.homedir();
 
-/** @param {{statsPath?:string, queueDir?:string, now?:number}} [opts] */
-export function learnings({ statsPath, queueDir, now = Date.now() } = {}) {
-  const sp = statsPath || path.join(HOME, '.claude-flow/neural/stats.json');
-  const qd = queueDir || path.join(HOME, '.cache/ruvnet-brain/learn');
+/** @param {{statsPath?:string, queueDir?:string, now?:number, cwd?:string, env?:object, home?:string}} [opts] */
+export function learnings({ statsPath, queueDir, now = Date.now(), cwd, env, home } = {}) {
+  // The flusher and the console must inspect the same learner. A fixed HOME path made the panel
+  // report a stale global learner while project-scoped captures were fed under the active project.
+  // Keep injectable paths for callers/tests, but derive both defaults from the shared scope owner.
+  const project = cwd || process.env.RUVNET_BRAIN_PROJECT_DIR || process.cwd();
+  const scope = learningScope({ cwd: project, env: env || process.env });
+  const learner = learnerCwd({ cwd: project, env: env || process.env, home: home || HOME });
+  const sp = statsPath || path.join(learner, '.claude-flow', 'neural', 'stats.json');
+  const qd = queueDir || (scope === 'user'
+    ? path.join(home || HOME, '.cache', 'ruvnet-brain', 'learn')
+    : path.join(project, '.swarm', 'ruvnet-brain-learn'));
 
   let stats = {};
   try { stats = JSON.parse(fs.readFileSync(sp, 'utf8')); } catch { /* no learner yet */ }
@@ -53,7 +62,12 @@ export function learnings({ statsPath, queueDir, now = Date.now() } = {}) {
     lastAdaptation: lastMs ? new Date(lastMs).toISOString() : null,
     daysSinceLastAdaptation: daysSince,
     recentWorkflow,
-    note: 'Learnings are how you work — shared across all your projects and getting smarter over time. Project facts stay isolated per project; nothing here is project data.',
+    note: scope === 'user'
+      ? 'Learnings are how you work — shared across your projects and getting smarter over time. Project facts stay isolated per project; nothing here is project data.'
+      : 'Learnings are how you work in this project and getting smarter over time. User-scoped learning remains isolated from this project; nothing here is project data.',
+    scope,
+    statsPath: sp,
+    queueDir: qd,
   };
 }