ruvnet-brain 3.9.134-dev → 4.0.2

package/scripts/eval-brain.mjs

@@ -0,0 +1,244 @@
+#!/usr/bin/env node
+// eval-brain.mjs — the eval flywheel. Ask the frozen held-out questions, and judge the answers by
+// GROUND TRUTH rather than by a model's opinion of them. (ADR-0011 Phase 0.)
+//
+// FIVE STRATA, because a gate that only asks easy questions cannot fail:
+//   named       — the repo is named in the question           pass = grounded AND routed
+//   described   — capability described, no names              pass = grounded AND routed
+//   scenario    — a real-world situation, no names            pass = grounded AND routed
+//   adversarial — the correct answer is NOT in this corpus    pass = ABSTAINED (top ce < 0, or no hits)
+//   provenance  — gist-shaped content                          pass = grounded AND (if the top hit IS a
+//                 gist chunk, it must carry its GIST STATUS banner — better repo grounding also passes)
+//
+// GATING IS ON THE WILSON LOWER BOUND, never the point estimate. With n=12, routed 10/12 had a 95%
+// CI of [55.2%, 95.3%] and 9/12's upper bound (91.1%) overlapped it completely — the gate could not
+// detect the regression it existed to catch. n=120 gives ≥80% power for a 0.90 -> 0.80 drop (n≈69
+// suffices; computed 2026-07-09).
+//
+// FAIL-CLOSED PROMOTION: `--gate` compares each metric's lower bound against evals/baseline.json and
+// exits 1 on any drop. A missing baseline is a failure too — you cannot promote against nothing.
+// Baselines are only ever written deliberately with `--record`.
+//
+// Why no model judge: an LLM panel scored a ZERO-CITATION answer 98/100 on this repo.
+//
+//   node scripts/eval-brain.mjs                 # run + table
+//   node scripts/eval-brain.mjs --gate          # run + exit 1 on regression (or missing baseline)
+//   node scripts/eval-brain.mjs --record        # run + write evals/baseline.json (deliberate)
+//   node scripts/eval-brain.mjs --json          # machine-readable
+//   node scripts/eval-brain.mjs --strata named,adversarial   # subset (never gate on a subset)
+
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const KB = process.env.RUVNET_BRAIN_KB || path.join(os.homedir(), '.cache', 'ruvnet-brain', 'kb');
+const HELD_OUT = path.join(ROOT, 'evals', 'held-out.json');
+const BASELINE = path.join(ROOT, 'evals', 'baseline.json');
+
+// The cross-encoder emits a relevance logit per (query, passage): strongly negative when unrelated.
+// An adversarial question "passes" when the brain effectively found nothing relevant. 0 is the
+// neutral cut; per-question ce values are recorded so this stays inspectable, and the Wilson-gated
+// baseline makes the stratum a regression detector even if the absolute rate is imperfect.
+export const ABSTAIN_CE = 0;
+
+/**
+ * Order-independent, tamper-evident hash of the held-out set — rUv's own frozen-eval pattern
+ * (ruflo harness-frozen-eval: humanEvalHash / FROZEN_HUMAN_EVAL_HASH). The pinned constant lives in
+ * tests/unit/eval-brain-gate.test.mjs; editing ANY question turns that test red, which is what
+ * "frozen" means mechanically. Reordering does not (sorting makes the hash order-independent).
+ */
+export async function heldOutHash(questions) {
+  const { createHash } = await import('node:crypto');
+  const per = questions.map((q) =>
+    createHash('sha256').update(JSON.stringify({ id: q.id, stratum: q.stratum, query: q.query, expectRepo: q.expectRepo ?? null })).digest('hex'));
+  return createHash('sha256').update(per.sort().join('')).digest('hex');
+}
+
+/** Wilson score interval — the same instrument rUv uses on every SWE-bench number. */
+export function wilson(k, n, z = 1.96) {
+  if (!n) return { p: 0, lo: 0, hi: 1 };
+  const p = k / n;
+  const d = 1 + (z * z) / n;
+  const c = (p + (z * z) / (2 * n)) / d;
+  const h = (z * Math.sqrt((p * (1 - p)) / n + (z * z) / (4 * n * n))) / d;
+  return { p, lo: Math.max(0, c - h), hi: Math.min(1, c + h) };
+}
+
+/**
+ * Grade one answered question by its stratum's rule. Pure — takes the verifier verdict, the top
+ * citation (with its ce score), and whether the raw output carried the gist provenance banner.
+ */
+export function gradeQuestion(q, { grounded, citations, bannerPresent }) {
+  const top = citations?.[0] ?? null;
+  const routed = !!(grounded && q.expectRepo?.length && top && q.expectRepo.includes(top.repo));
+  const abstained = !top || (typeof top.ce === 'number' && top.ce < ABSTAIN_CE);
+  switch (q.stratum) {
+    case 'adversarial':
+      return { grounded, routed: null, abstained, pass: abstained };
+    case 'provenance':
+      // The mechanism under test: IF a gist chunk wins, it must carry its own status banner.
+      // A better hit from the real repo is not a failure — it is better grounding.
+      return { grounded, routed: null, abstained, pass: !!grounded && (top?.repo !== 'ruv-gists' || bannerPresent) };
+    default:
+      return { grounded, routed, abstained, pass: !!grounded && routed };
+  }
+}
+
+/** Aggregate graded rows into the four gated metrics, each with its Wilson interval. */
+export function aggregate(rows) {
+  const by = (pred) => rows.filter(pred);
+  const routedStrata = (r) => ['named', 'described', 'scenario'].includes(r.stratum);
+  const groundable = by((r) => r.stratum !== 'adversarial');
+  const routed = by(routedStrata);
+  const adversarial = by((r) => r.stratum === 'adversarial');
+  const provenance = by((r) => r.stratum === 'provenance');
+  const metric = (arr, key) => {
+    const k = arr.filter((r) => r[key]).length;
+    return { k, n: arr.length, ...wilson(k, arr.length) };
+  };
+  return {
+    grounded: metric(groundable, 'grounded'),
+    routed: metric(routed, 'pass'),
+    abstain: metric(adversarial, 'pass'),
+    banner: metric(provenance, 'pass'),
+  };
+}
+
+/** The fail-closed comparison: every metric's lower bound must hold the baseline's lower bound. */
+export function gateAgainst(current, baseline) {
+  if (!baseline) return { pass: false, regressions: ['no baseline to promote against — record one deliberately (--record)'] };
+  // An old-schema baseline (pre-strata counts, no {k,n,lo}) must FAIL, not pass vacuously — a gate
+  // that silently compares against nothing is the decorated-green failure this whole phase kills.
+  if (!['grounded', 'routed', 'abstain', 'banner'].some((m) => baseline[m]?.n)) {
+    return { pass: false, regressions: ['baseline is from an older schema — re-record deliberately (--record)'] };
+  }
+  const regressions = [];
+  for (const m of ['grounded', 'routed', 'abstain', 'banner']) {
+    const cur = current[m];
+    const base = baseline[m];
+    if (!base || !base.n) continue; // metric absent from an older baseline — cannot regress against nothing
+    if (!cur.n) { regressions.push(`${m}: stratum is empty but the baseline has n=${base.n}`); continue; }
+    if (cur.lo < base.lo - 1e-9) regressions.push(`${m}: lower bound ${(cur.lo * 100).toFixed(1)}% < baseline ${(base.lo * 100).toFixed(1)}%`);
+  }
+  return { pass: regressions.length === 0, regressions };
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const GATE = argv.includes('--gate');
+  const RECORD = argv.includes('--record');
+  const JSON_OUT = argv.includes('--json');
+  const strataArg = argv.includes('--strata') ? argv[argv.indexOf('--strata') + 1]?.split(',') : null;
+  const die = (msg) => { console.error(`eval-brain: ${msg}`); process.exit(2); };
+
+  if (!fs.existsSync(path.join(KB, 'forge-ask-all.mjs'))) die(`no brain at ${KB} — run: npx ruvnet-brain`);
+  const verifierPath = path.join(KB, 'verify-citation.mjs');
+  if (!fs.existsSync(verifierPath)) die('this bundle predates verify-citation.mjs — refusing to score grounding without a way to check it');
+  const { verifyGrounding } = await import(pathToFileURL(verifierPath).href);
+
+  let { questions } = JSON.parse(fs.readFileSync(HELD_OUT, 'utf8'));
+  for (const q of questions) if (!q.stratum) die(`question ${q.id} has no stratum`);
+  if (strataArg) {
+    questions = questions.filter((q) => strataArg.includes(q.stratum));
+    if (GATE || RECORD) die('--strata is for local iteration only; never gate or record on a subset');
+  }
+
+  // Each question is an independent subprocess with its own ONNX thread, so the pool parallelizes
+  // cleanly across cores — spawnSync would serialize the whole run on the event loop. Measured
+  // serial cost was ~13.5s/question ≈ 27 min for 120; at concurrency 6 the wall drops ~6×.
+  const { execFile } = await import('node:child_process');
+  const ask = (query) => new Promise((resolve) => {
+    execFile('node', ['forge-ask-all.mjs', '--dir', KB, '--q', query, '--k', '3'],
+      { cwd: KB, timeout: 240000, env: process.env, maxBuffer: 64 * 1024 * 1024 },
+      (err, stdout) => resolve(err ? '' : String(stdout || '')));
+  });
+
+  const CONC = Math.max(1, Number(process.env.EVAL_CONCURRENCY ?? (argv.includes('--concurrency') ? argv[argv.indexOf('--concurrency') + 1] : 6)) || 6);
+  const rows = new Array(questions.length);
+  let cursor = 0;
+  let done = 0;
+  // An empty answer means the SUBPROCESS failed (contention, timeout, OOM) — an infrastructure
+  // event, not a retrieval verdict. Scoring it as "not grounded" pollutes the quality metric with
+  // ops noise: one dead process under 6-wide load dragged grounded's lower bound below baseline and
+  // failed a gate that retrieval never failed (caught live, 2026-07-10, question ho-04 → "ce=—").
+  // Retry once; if it still returns nothing, the row is an INFRA ERROR and the run is inconclusive.
+  const infraErrors = [];
+  const runOne = async () => {
+    while (true) {
+      const i = cursor++;
+      if (i >= questions.length) return;
+      const q = questions[i];
+      let out = await ask(q.query);
+      if (!out) { await new Promise((r) => setTimeout(r, 2000)); out = await ask(q.query); }
+      if (!out) {
+        infraErrors.push(q.id);
+        done++;
+        process.stderr.write(`\r[eval] ${done}/${questions.length} ! ${q.id} (infra)          `);
+        continue;
+      }
+      const v = await verifyGrounding(out, KB);
+      const graded = gradeQuestion(q, { grounded: v.grounded, citations: v.citations, bannerPresent: /GIST STATUS/.test(out) });
+      const top = v.citations?.[0] ?? null;
+      rows[i] = {
+        id: q.id, stratum: q.stratum, query: q.query,
+        citedRepo: top?.repo ?? null, citedPath: top?.fullPath ?? null, ce: top?.ce ?? null,
+        ...graded,
+      };
+      done++;
+      process.stderr.write(`\r[eval] ${done}/${questions.length} ${graded.pass ? '✓' : '✗'} ${q.id}          `);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(CONC, questions.length) }, runOne));
+  process.stderr.write('\n');
+
+  if (infraErrors.length) {
+    console.error(`[eval-brain] INCONCLUSIVE — ${infraErrors.length} infrastructure failure(s) after retry: ${infraErrors.join(', ')}`);
+    console.error('  A dead subprocess is not a retrieval verdict. Re-run (consider EVAL_CONCURRENCY=3 on a loaded machine).');
+    process.exit(2); // never a quality verdict, never a recorded baseline
+  }
+
+  const score = aggregate(rows.filter(Boolean));
+
+  if (JSON_OUT) {
+    console.log(JSON.stringify({ score, rows }, null, 2));
+  } else {
+    console.log(`\n# eval-brain — frozen held-out set (${rows.length} questions)\n`);
+    console.log('| metric | k/n | rate | 95% Wilson |');
+    console.log('|---|---|---|---|');
+    for (const [m, s] of Object.entries(score)) {
+      if (!s.n) continue;
+      console.log(`| ${m} | ${s.k}/${s.n} | ${(s.p * 100).toFixed(1)}% | [${(s.lo * 100).toFixed(1)}%, ${(s.hi * 100).toFixed(1)}%] |`);
+    }
+    const fails = rows.filter((r) => !r.pass);
+    if (fails.length) {
+      console.log(`\nFailures (${fails.length}):`);
+      for (const f of fails) console.log(`  ✗ ${f.id} [${f.stratum}] → ${f.citedRepo ?? '—'} ce=${f.ce ?? '—'}  ${f.query.slice(0, 64)}`);
+    }
+    console.log('\nGrounded = the cited passage exists on disk. Routed = the owning repo answered.');
+    console.log('Abstain = the brain declined an out-of-corpus question. Banner = a winning gist chunk carried its provenance.');
+    console.log('No model graded anything here.\n');
+  }
+
+  if (RECORD) {
+    fs.mkdirSync(path.dirname(BASELINE), { recursive: true });
+    fs.writeFileSync(BASELINE, JSON.stringify({ recorded: new Date().toISOString(), n: rows.length, score }, null, 2) + '\n');
+    console.error(`[eval-brain] baseline recorded (${rows.length} questions)`);
+  }
+
+  if (GATE) {
+    const baseline = fs.existsSync(BASELINE) ? JSON.parse(fs.readFileSync(BASELINE, 'utf8')).score : null;
+    const g = gateAgainst(score, baseline);
+    if (!g.pass) {
+      console.error(`[eval-brain] FAIL (fail-closed): ${g.regressions.join('; ')}`);
+      process.exit(1);
+    }
+    console.error('[eval-brain] PASS: every metric holds its baseline Wilson lower bound');
+  }
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  await main();
+}

package/scripts/fix-metaharness-memretrieve.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+// fix-metaharness-memretrieve.mjs — repair (and guard) a real bug in Ruflo's metaharness plugin.
+//
+// THE BUG
+// -------
+// `audit-list.mjs` and `audit-trend.mjs` read a stored audit record with:
+//     npx @claude-flow/cli memory retrieve --namespace <ns> --key <key>
+// ...WITHOUT `--format json`, then greedily `JSON.parse` whatever `{...}` they can scrape from
+// human-formatted stdout. But `memory retrieve --format json` returns an ENVELOPE:
+//     { id, key, namespace, content: "<the audit record, JSON-stringified>", ... }
+// so the record lives in `.content` (a string) and must be unwrapped. Without both changes,
+// memRetrieve() returns null for EVERY key, and `metaharness_audit_list` /
+// `metaharness_drift_from_history` silently report `records: []` while `totalInNamespace > 0`.
+// (Symptom: "0 audit records" even right after a successful oia-audit persisted one.)
+//
+// WHY THIS SCRIPT EXISTS
+// ----------------------
+// Both files live inside the GLOBAL npm package `@claude-flow/cli`, so `npm update -g` (or any
+// reinstall) silently reverts the patch. This has already happened twice. Rather than hand-edit
+// a third time, this script re-applies it idempotently AND can verify it in CI / a doctor check.
+//
+//   node scripts/fix-metaharness-memretrieve.mjs --check   # exit 1 if reverted (guard)
+//   node scripts/fix-metaharness-memretrieve.mjs --apply   # patch in place (idempotent)
+//
+// The durable fix is upstream; this keeps the local install honest until that lands.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { pathToFileURL } from 'node:url';
+
+const TARGET_DIR =
+  process.env.METAHARNESS_SCRIPTS_DIR ||
+  path.join(os.homedir(), '.npm-global/lib/node_modules/@claude-flow/cli/plugins/ruflo-metaharness/scripts');
+
+export const FILES = ['audit-list.mjs', 'audit-trend.mjs'];
+const SENTINEL = 'outer.content'; // present only when the fix is applied
+
+const FIXED = `function memRetrieve(key) {
+  const r = spawnSync('npx', [
+    CLI_PKG, 'memory', 'retrieve',
+    '--namespace', NS, '--key', key, '--format', 'json',
+  ], { stdio: ['ignore', 'pipe', 'pipe'], encoding: 'utf-8', shell: process.platform === 'win32' });
+  if (r.status !== 0) return null;
+  const m = /\\{[\\s\\S]*\\}/.exec(r.stdout || '');
+  if (!m) return null;
+  try {
+    const outer = JSON.parse(m[0]);
+    // \`memory retrieve --format json\` wraps the record: { id, key, content: "<record JSON>" }.
+    // Unwrap \`content\` — parsing the envelope AS the record is the empty-results bug.
+    const inner = typeof outer.content === 'string' ? outer.content
+                : typeof outer.value === 'string' ? outer.value
+                : null;
+    if (inner) { try { return JSON.parse(inner); } catch { return null; } }
+    return (outer.startedAt || outer.composite) ? outer : null;
+  } catch { return null; }
+}`;
+
+// Match the whole memRetrieve function, up to the first closing brace at column 0.
+const FN_RE = /function memRetrieve\(key\) \{[\s\S]*?\n\}/;
+
+export function statusOf(file, dir = TARGET_DIR) {
+  const p = path.join(dir, file);
+  if (!fs.existsSync(p)) return { file, p, state: 'missing' };
+  const src = fs.readFileSync(p, 'utf-8');
+  if (src.includes(SENTINEL)) return { file, p, state: 'fixed', src };
+  if (FN_RE.test(src)) return { file, p, state: 'reverted', src };
+  return { file, p, state: 'unrecognized', src };
+}
+
+export function apply(dir = TARGET_DIR, log = console.log) {
+  let changed = 0;
+  for (const file of FILES) {
+    const s = statusOf(file, dir);
+    if (s.state === 'missing') { log(`  – ${file}: not installed here — nothing to patch`); continue; }
+    if (s.state === 'fixed') { log(`  ✓ ${file}: already fixed`); continue; }
+    if (s.state === 'unrecognized') { log(`  ⚠ ${file}: memRetrieve() not recognized — upstream changed shape; skipping`); continue; }
+    fs.writeFileSync(s.p, s.src.replace(FN_RE, FIXED), 'utf-8');
+    log(`  ✓ ${file}: PATCHED (envelope unwrap + --format json)`);
+    changed++;
+  }
+  log(changed ? `\napplied to ${changed} file(s).` : '\nnothing to do — already healthy.');
+  return 0;
+}
+
+// A guard that cries wolf gets ignored. `missing` means the metaharness plugin simply isn't
+// installed on this machine (the common case in CI) — that is NOT a failure. Only a file that
+// EXISTS and has lost the fix is a failure, because that is the exact state an `npm update -g`
+// leaves behind, and the symptom is silent (`records: []`, never an error).
+export function check(dir = TARGET_DIR, log = console.log) {
+  let reverted = 0;
+  let present = 0;
+  for (const file of FILES) {
+    const s = statusOf(file, dir);
+    if (s.state === 'missing') { log(`  – ${file}: n/a (metaharness plugin not installed)`); continue; }
+    present++;
+    if (s.state === 'reverted') reverted++;
+    log(`  ${s.state === 'fixed' ? '✓' : '✗'} ${file}: ${s.state}`);
+  }
+  if (!present) {
+    log('\n– metaharness plugin not installed — guard not applicable (pass).');
+    return 0;
+  }
+  if (reverted) {
+    log(`\n✗ ${reverted} file(s) reverted — an npm update wiped the fix.`);
+    log('  Repair: node scripts/fix-metaharness-memretrieve.mjs --apply');
+    return 1;
+  }
+  log('\n✓ metaharness memRetrieve fix intact.');
+  return 0;
+}
+
+// Only act when run directly, so tests can import the pure functions above.
+// Compare in URL space (pathToFileURL), not by decoding a URL into a path: `new URL(...).pathname`
+// yields "/D:/..." on Windows and never matches, so `--apply` would silently no-op there.
+const invokedDirectly = process.argv[1] && pathToFileURL(path.resolve(process.argv[1])).href === import.meta.url;
+if (invokedDirectly) {
+  const mode = process.argv.includes('--check') ? 'check' : 'apply';
+  console.log(`metaharness memRetrieve ${mode} — ${TARGET_DIR}\n`);
+  process.exit(mode === 'check' ? check() : apply());
+}

package/scripts/full-hints.mjs

@@ -0,0 +1,87 @@
+// full-hints.mjs — SHARED per-repo depth configuration for every builder entrypoint.
+//
+// Why this file exists: FULL_HINTS originally lived inline in self-update.mjs only. Any rebuild
+// that went through scripts/ingest-repo.mjs (which never passed --full) silently downgraded a
+// repo's full-body source indexing to doc-comment-only snippets — 2026-07-10 depth-restore run
+// reproduced exactly that: ruvector rebuilt with 18,491 passages and 0 full bodies. One map,
+// imported by BOTH self-update.mjs and ingest-repo.mjs, kills that class of bug.
+//
+// FULL_HINTS: comma-separated path prefixes (relative to repo root) whose source files are
+// indexed with FULL bodies by kb/forge-build.mjs --full. See self-update.mjs history
+// (fc9a178, f17bbf7) for how these were empirically derived from the shipped bundle.
+//
+// KEEP_DIRS: comma-separated directory NAMES that forge-build.mjs must NOT skip for this repo
+// (kb/forge-build.mjs --keep). forge-build's SKIP_DIRS globally excludes 'v2' (noise in most
+// repos), but open-claude-code's entire source lives in v2/src and RuView's active tree is
+// v2/crates — without --keep v2 those repos index almost nothing (open-claude-code: 68 passages
+// total) and their FULL_HINTS can never match.
+
+export const FULL_HINTS = {
+  'ruflo': 'v3/@claude-flow,v3/mcp,ruflo/src',
+  'synthlang': 'proxy/src/cli/synthlang,proxy/src/app/synthlang',
+  'agentdb': 'src',
+  'rulake': 'crates',
+  'daa': 'crates/daa-ai,crates/daa-chain,crates/daa-economy,crates/daa-rules,daa-ai/src,daa-chain/src,daa-cli/src,daa-compute/benches,daa-compute/build.rs,daa-compute/src,daa-compute/tests,daa-economy/src,daa-mcp/src,daa-orchestrator/daa-napi,daa-orchestrator/src,daa-orchestrator/tests,daa-rules/src,daa-sdk/crates,examples/agents,examples/basic-crypto.ts,examples/decentralized-task-scheduler.ts,examples/federated-learning.ts,examples/full-stack-agent.ts,examples/orchestrator.ts,examples/performance-benchmark.ts,prime-rust/crates,prime-rust/prime-napi,prime-rust/tests,src/main.rs,src/security',
+  'qudag': 'benchmarks/benches,benchmarks/cli,benchmarks/dark_addressing,benchmarks/lib.rs,benchmarks/optimized_benchmarks.rs,benchmarks/src,cli-standalone/src,cli-standalone/tests,core/crypto,core/dag,core/health.rs,core/monitoring,core/network,core/optimized,core/protocol,core/swarm,core/vault,examples/bitchat,examples/crypto,examples/dark_addressing_example.rs,examples/dht_discovery_example.rs,examples/nat_traversal_example.rs,examples/onion_routing_example.rs,examples/peer_management_example.rs,examples/persistence_example.rs,examples/shadow_address_example.rs,examples/traffic_obfuscation_example.rs,qudag-exchange/cli,qudag-exchange/core,qudag-exchange/crates,qudag-exchange/src,qudag-exchange/test_core_fee_model.rs,qudag-exchange/test_fee_model.rs,qudag-exchange/tests,qudag-mcp/benches,qudag-mcp/examples,qudag-mcp/src,qudag-mcp/tests,qudag-testnet/configs,qudag-wasm/final-test.mjs,qudag-wasm/simple-test.mjs,qudag-wasm/src,qudag-wasm/test-nodejs.mjs,qudag-wasm/test-setup.ts,qudag-wasm/tests,qudag-wasm/vitest.config.ts,qudag-wasm/vitest.workspace.ts,qudag-wasm/working-features-test.mjs,tools/cli,tools/simulator,tools/swarm-test,vault-standalone/examples,vault-standalone/src,vault-standalone/tests',
+  'ruvector': 'crates/agentic-robotics-core,crates/agentic-robotics-mcp,crates/agentic-robotics-node,crates/agentic-robotics-rt,crates/cognitum-gate-kernel,crates/cognitum-gate-tilezero,crates/emergent-time,crates/emergent-time-wasm,crates/hailort-sys,crates/mcp-brain,crates/mcp-brain-server,crates/mcp-gate,crates/micro-hnsw-wasm,crates/neural-trader-coherence,crates/neural-trader-core,crates/neural-trader-replay,crates/neural-trader-wasm,crates/photonlayer-bench,crates/photonlayer-cli,crates/photonlayer-core,crates/photonlayer-ruvector,crates/photonlayer-wasm,crates/prime-radiant,crates/ruos-thermal,crates/ruvector-acorn,crates/ruvector-acorn-wasm,crates/ruvector-agent-memory,crates/ruvector-attention,crates/ruvector-attention-cli,crates/ruvector-attention-node,crates/ruvector-attention-wasm,crates/ruvector-attn-mincut,crates/ruvector-bench,crates/ruvector-bet4-ivf-bench,crates/ruvector-capgated,crates/ruvector-cli,crates/ruvector-cluster,crates/ruvector-cnn,crates/ruvector-cnn-wasm,crates/ruvector-coherence,crates/ruvector-coherence-hnsw,crates/ruvector-collections,crates/ruvector-consciousness,crates/ruvector-core,crates/ruvector-crv,crates/ruvector-dag,crates/ruvector-dag-wasm,crates/ruvector-decompiler,crates/ruvector-delta-core,crates/ruvector-delta-graph,crates/ruvector-delta-index,crates/ruvector-delta-wasm,crates/ruvector-diskann,crates/ruvector-diskann-node,crates/ruvector-dither,crates/ruvector-economy-wasm,crates/ruvector-exotic-wasm,crates/ruvector-filter,crates/ruvector-gnn,crates/ruvector-gnn-node,crates/ruvector-gnn-rerank,crates/ruvector-gnn-wasm,crates/ruvector-graph,crates/ruvector-graph-condense,crates/ruvector-graph-node,crates/ruvector-graph-wasm,crates/ruvector-hailo,crates/ruvector-hailo-cluster,crates/ruvector-hnsw-repair,crates/ruvector-hybrid,crates/ruvector-kalshi,crates/ruvector-learning-wasm,crates/ruvector-lsm-ann,crates/ruvector-math,crates/ruvector-math-wasm,crates/ruvector-matryoshka,crates/ruvector-maxsim,crates/ruvector-metrics,crates/ruvector-mincut,crates/ruvector-mincut-node,crates/ruvector-mincut-wasm,crates/ruvector-mmwave,crates/ruvector-nervous-system,crates/ruvector-node,crates/ruvector-perception,crates/ruvector-postgres,crates/ruvector-pq-search,crates/ruvector-profiler,crates/ruvector-proof-gate,crates/ruvector-rabitq,crates/ruvector-rabitq-wasm,crates/ruvector-raft,crates/ruvector-rairs,crates/ruvector-replication,crates/ruvector-robotics,crates/ruvector-router-cli,crates/ruvector-router-core,crates/ruvector-router-ffi,crates/ruvector-router-wasm,crates/ruvector-rulake,crates/ruvector-server,crates/ruvector-snapshot,crates/ruvector-solver,crates/ruvector-solver-node,crates/ruvector-solver-wasm,crates/ruvector-sota-bench,crates/ruvector-spann,crates/ruvector-sparsifier,crates/ruvector-tiny-dancer-node,crates/ruvector-verified,crates/ruvector-verified-wasm,crates/ruvector-wasm,crates/ruvix,crates/ruvllm,crates/ruvllm-cli,crates/ruvllm-wasm,crates/ruvllm_sparse_attention,crates/rvAgent,crates/rvf,crates/rvlite,crates/rvm,crates/sona,crates/sonic-ct,crates/sonic-ct-wasm,crates/thermorust,crates/timesfm',
+  'ruv-fann': 'cuda-wasm/.eslintrc.js,cuda-wasm/benches,cuda-wasm/build.rs,cuda-wasm/cli,cuda-wasm/cuda-examples,cuda-wasm/demo,cuda-wasm/examples,cuda-wasm/jest.config.js,cuda-wasm/scripts,cuda-wasm/src,cuda-wasm/tests,examples/basic_usage.rs,examples/cuda_wasm_neural_integration.rs,examples/final_performance_demo.rs,examples/gpu_sweet_spot_benchmark.rs,examples/gpu_training_test.rs,examples/test_adam.rs,examples/test_gpu_detection.rs,examples/test_optimizers_simple.rs,examples/xor.rs,neuro-divergent/src,neuro-divergent/tests,opencv-rust/opencv-core,opencv-rust/opencv-sdk,opencv-rust/opencv-sys,opencv-rust/opencv-wasm,opencv-rust/tests,ruv-swarm/benches,ruv-swarm/benchmarking,ruv-swarm/crates,ruv-swarm/examples,ruv-swarm/ml-training,ruv-swarm/models,ruv-swarm/npm,ruv-swarm/test,ruv-swarm/test-simd-fix.mjs,ruv-swarm/test-wasm.js,ruv-swarm/tests,ruv-swarm/vitest.config.js,src/activation.rs,src/cascade.rs,src/connection.rs,src/errors.rs,src/integration.rs,src/io,src/layer.rs,src/lib.rs,src/memory_manager.rs,src/mock_types.rs,src/network.rs,src/network_gpu.rs,src/neuron.rs,src/simd,src/tests,src/training,src/webgpu',
+  'agentic-flow': 'agentic-flow/.claude,agentic-flow/Python,agentic-flow/add_two_numbers.py,agentic-flow/app,agentic-flow/benchmark,agentic-flow/examples,agentic-flow/path,agentic-flow/scripts,agentic-flow/src,agentic-flow/tests,agentic-flow/validation,agentic-flow/vitest.config.ts,crates/agentic-flow-quic,examples/batch-query.js,examples/batch-store.js,examples/billing-example.ts,examples/cached-query.js,examples/climate-prediction,examples/connection-pool.js,examples/deepseek-direct-api.js,examples/nova-medicina,examples/perf-monitor.js,examples/quic-server-coordinator.js,examples/quic-swarm-coordination.js,examples/reasoningbank-benchmark.js,examples/reasoningbank-learning-demo.js,examples/reasoningbank-optimize.js,examples/research-swarm,examples/verification-example.ts,packages/agent-booster,packages/agentdb-onnx,packages/agentic-jujutsu,packages/agentic-llm,reasoningbank/examples,reasoningbank/tests,src/App.tsx,src/api,src/cli,src/components,src/consent,src/controller,src/controllers,src/main.tsx,src/mcp,src/middleware,src/notifications,src/pages,src/providers,src/routing,src/security,src/services,src/transport,src/types,src/utils,src/verification',
+  'metaharness': 'crates/kernel,crates/kernel-napi,crates/kernel-wasm,crates/poker-darwin,crates/template-catalog,packages/aws-finops,packages/bench,packages/create-agent-harness,packages/darwin-mode,packages/harness,packages/host-claude-code,packages/host-codex,packages/host-copilot,packages/host-github-actions,packages/host-hermes,packages/host-openclaw,packages/host-opencode,packages/host-pi-dev,packages/host-rvm,packages/jujutsu,packages/kernel-js,packages/projects,packages/redblue,packages/router,packages/sdk,packages/vertical-base,packages/vertical-trading,packages/weight-eft',
+  'safla': 'benchmarks/__init__.py,benchmarks/cli_benchmarks.py,benchmarks/core.py,benchmarks/database.py,benchmarks/safla_benchmarks.py,benchmarks/utils.py,examples/01_basic_setup.py,examples/02_simple_memory.py,examples/03_basic_safety.py,examples/05_delta_evaluation.py,examples/12_ai_assistant.py,examples/15_enterprise_integration.py,examples/config_examples.py,examples/hybrid_memory_demo.py,examples/mcp_auth_client.py,examples/mcp_usage,examples/safety_validation_demo.py,safla/__init__.py,safla/__main__.py,safla/api,safla/auth,safla/cli.py,safla/cli_implementations.py,safla/cli_interactive.py,safla/cli_main.py,safla/cli_manager.py,safla/core,safla/exceptions.py,safla/installer.py,safla/integrations,safla/mcp,safla/mcp_stdio_server.py,safla/middleware,safla/security,safla/utils,safla/validation,safla_mcp_enhanced.py,safla_mcp_server.py,safla_mcp_simple.py,scripts/advanced_optimization_engine.py,scripts/agent_swarm_optimizer.py,scripts/build.py,scripts/comprehensive_capability_test.py,scripts/continuous_optimization_engine.py,scripts/debug_enhanced_server.py,scripts/demo_jwt_mcp_client.py,scripts/final_capability_verification.py,scripts/final_system_test.py,scripts/gpu_optimization_benchmark.py,scripts/install.py,scripts/minimal_security_test.py,scripts/quick_capability_test.py,scripts/remote_gpu_benchmarker.py,scripts/save_extreme_optimizations.py,scripts/save_optimized_models.py,scripts/system_status_report.py,scripts/verify_system.py',
+  'ruview': 'firmware/esp32-csi-node,firmware/esp32-hello-world,v2/crates',
+  'open-claude-code': 'v2/src',
+  'ruv-dev': 'bin/index.js,src/cli,src/core,src/index.js,src/utils',
+  'agenticow': 'bin/agenticow.js,examples/_shared.mjs,examples/ab-at-scale.mjs,examples/ab-branches.mjs,examples/checkpointing.mjs,examples/compliance-lineage.mjs,examples/git-workflow.mjs,examples/memory-evolution.mjs,examples/multi-persona-consensus.mjs,examples/multi-tenant-saas.mjs,examples/parallel-agents.mjs,examples/parallel-selves.mjs,examples/personalization.mjs,examples/promotion-pipeline.mjs,examples/red-team-sandbox.mjs,examples/rollback-quarantine.mjs,examples/simulated-org.mjs,examples/time-travel-debug.mjs,src/index.d.ts,src/index.js',
+  // cognitum-cogs (cognitum-one org): thin, scattered full-body coverage — superset of every
+  // top-level dir with ANY full-body content today (see self-update.mjs history for rationale).
+  'cognitum-cogs': 'benches,benchmarks,cognitum-sim,crates,examples,scripts,shared,src,tests',
+  // cognitum-support: 100% docs content, zero full-body entries — no --full prefix needed.
+
+  // ---- Cognitum One flagship-depth sweep, 2026-07-18 (Stuart: "same absolute crisp deep dive as
+  // the other repos — all ADRs, walk all the Rust crates, every markdown"). seed and v0-appliance
+  // were indexed SHALLOW until today — the same one-size-under-indexes-code-rich-repos failure the
+  // v0.5.0 depth audit fixed for qudag/ruv-fann. Prefixes are generic-but-superset (crates,src,…):
+  // forge-build skips prefixes that don't exist, so a superset is safe where a repo lacks a dir. ----
+  'cognitum-seed': 'crates,src,firmware,scripts,tests,examples,benches,docs/adr',
+  'cognitum-v0-appliance': 'crates,src,scripts,tests,examples,deploy,docs/adr',
+  'cognitum-open-design': 'src,app,apps,packages,electron,scripts,tests,server',
+  // cognitum-claude-plugin: REMOVED 2026-07-24. It declared 'src,scripts,plugin,plugins,mcp,tests'
+  // and only `plugins/` exists — but the whole repo, measured, is 233 .md + 108 .json + 1 .yml and
+  // ZERO source files, so it can never produce a full-body SOURCE passage. corpus-qa's S2 check
+  // ("declares --full but has 0 full bodies — silent depth loss") was therefore unsatisfiable by
+  // construction, and it FAILED THE NIGHTLY PUBLISH: self-update aborts fail-closed on any failed
+  // repo build, so no GitHub Release was cut while npm advanced. That is how the release channel
+  // reached v3.9.56 while npm was at 3.9.57 — a correct gate firing on a false declaration.
+  // It belongs with the docs-content group below: default depth IS the right depth here.
+  'cognitum-spoton': 'src,crates,scripts,tests,harness',
+  // cognitum-platform-docs / cognitum-meta-llm-docs / cognitum-meta-proxy-dist: docs/dist content —
+  // default depth is the right depth; no full-body prefixes needed.
+
+  // ---- tier-1 corpus expansion, 2026-07-10 (ADR-0011 Phase 5). Prefixes derived by inspecting
+  // each fresh shallow clone's top-level layout; junk/vendored/build dirs deliberately absent. ----
+  'midstream': 'src,crates,examples,benches,wasm,wasm-bindings,integrations,lean-agentic-js,xtask,AIMDS,fuzz,scripts,tests',
+  'rudevolution': 'src,examples,benches,scripts,npm,dashboard,tests',
+  'marketing': 'src,tests',
+  // flow-nexus: sdk/ is all markdown (platform is closed-source); the runnable JS lives in tutorials/.
+  'flow-nexus': 'sdk,tutorials',
+  'symbolic-scribe': 'src,harness,scripts,wasm',
+  // sublinear-time-solver: archive/, build-temp/, data/ (26MB datasets) intentionally excluded.
+  'sublinear-time-solver': 'src,crates,js,bin,server,benches,benchmarks,examples,integrations,types,validation,optimization,npx,scripts,tests',
+  // synaptic-mesh: src/rs VENDORS full copies of QuDAG (90M), daa (92M), ruv-FANN (19M) and
+  // src/js vendors claude-flow + ruv-swarm — ALL already covered by their own stores. Full-body
+  // only the mesh-specific code; vendored trees still get doc-comment/lead indexing from the walk.
+  'synaptic-mesh': 'src/mcp,src/neural,src/rs/neural-mesh,src/rs/synaptic-mesh-cli,src/rs/synaptic-mesh-p2p,src/rs/qudag-core,src/rs/daa-swarm,src/js/synaptic-cli,standalone-crates,tests,examples,scripts',
+  'agentic-security': 'src,tests,gui,security_pipeline.py,fix_cycle.py',
+};
+
+// Per-repo directory names to EXEMPT from forge-build's SKIP_DIRS walk exclusion.
+export const KEEP_DIRS = {
+  'ruview': 'v2',            // active tree is v2/crates (862 files) — skipped as noise otherwise
+  'open-claude-code': 'v2',  // ALL source lives in v2/src — without this the store is ~68 passages
+};
+
+// CLI helper so shell drivers can read the config:  node scripts/full-hints.mjs <kb-name>
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const kb = (process.argv[2] || '').toLowerCase();
+  console.log(JSON.stringify({ full: FULL_HINTS[kb] || null, keep: KEEP_DIRS[kb] || null }));
+}

package/scripts/gate.sh

@@ -0,0 +1,39 @@
+#!/usr/bin/env bash
+# gate.sh — rebuild the concepts/capability layer and run the three pass/fail routing gates.
+# SEC-0010 #1: this gate must be able to FAIL. Each prove.mjs computes pass!=total -> exit 1
+# (scripts/prove.mjs); previously the grep pipe masked that exit code and the script printed
+# "GATES COMPLETE" (exit 0) even at 0%. Now every gate's real exit code is captured via
+# PIPESTATUS and any miss makes the whole gate exit non-zero. Paths are repo-relative, not
+# hardcoded to one machine.
+set -uo pipefail
+cd "$(dirname "$0")/.." || exit 1
+# Model cache: honor an existing KB_MODEL_CACHE; else default to a repo-local dir (no personal path).
+export KB_MODEL_CACHE="${KB_MODEL_CACHE:-$PWD/kb/models-cache}"
+
+FAILED=0
+run_gate() {  # $1=label  $2..=command
+  local label="$1"; shift
+  echo "== $label =="
+  "$@"
+  local rc="${PIPESTATUS[0]}"
+  if [ "$rc" -ne 0 ]; then echo "  ✗ GATE FAILED (exit $rc)"; FAILED=1; else echo "  ✓ gate passed"; fi
+  echo
+}
+
+echo "== rebuild concepts (L2 + primers + capability cards) =="
+node scripts/build-concepts.mjs 2>&1 | tail -2
+( cd kb && node forge-big.mjs both --dir . --name concepts 2>&1 | tail -2 )
+echo
+
+run_gate "GATE 1 — described-need battery (newcomer, no repo names) · target >=85%" \
+  node scripts/prove.mjs --questions scripts/described-questions.json --k 2 --out DESCRIBED-PROOF
+run_gate "GATE 2 — named/specific battery · must HOLD" \
+  node scripts/prove.mjs --questions scripts/proof-questions.json --k 3 --out PROOF
+run_gate "GATE 3 — Helix-context demo · target >=6/8" \
+  node scripts/prove.mjs --questions scripts/helix-scenario-questions.json --k 2 --out HELIX-DEMO-NOHELIX
+
+if [ "$FAILED" -ne 0 ]; then
+  echo "== GATES FAILED — at least one gate missed its threshold. Read DESCRIBED-PROOF.md / PROOF.md / HELIX-DEMO-NOHELIX.md =="
+  exit 1
+fi
+echo "== GATES COMPLETE — all passed. Read DESCRIBED-PROOF.md, PROOF.md, HELIX-DEMO-NOHELIX.md =="