ruvnet-brain 4.4.0 → 4.5.0

package/scripts/recommendation-real-host.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * recommendation-real-host.mjs — the package recommender in a REAL Claude Code session (ADR-093 rev 3).
+ *
+ * For each selected eval prompt: a fresh `claude -p` with this checkout's UserPromptSubmit runtime as
+ * its only hook (route producer only, flag on), a warm search worker in a throwaway brain home, then the
+ * model's actual answer. Records whether the hook injected a hint, which packages it carried, and which
+ * one (if any) the model named — so the simulated-host judge can be checked against a real host.
+ *
+ * Isolation, following scripts/hook-qualify-hosts.mjs: --no-session-persistence, --setting-sources ''
+ * (no user/project settings, plugins or hooks), --strict-mcp-config (no MCP servers), --tools '' (no
+ * tool can touch anything), a temp cwd, every RUVNET_* state path in a temp dir. Auth is the user's own
+ * login; the run snapshots ~/.claude mtimes before/after and reports anything that changed.
+ *
+ *   node scripts/recommendation-real-host.mjs --key <e2e judge-key.json> --models <d> --xenova <d> --out <dir>
+ *        [--n-pos 12 --n-neg-hinted 6 --n-other 4 | --all-blinds] [--max-load 60 --batch 11] [--claude <bin>]
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const arg = (n, d) => { const i = process.argv.indexOf(n); return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : d; };
+const CLAUDE = arg('--claude', path.join(os.homedir(), '.npm-global', 'bin', 'claude'));
+const POS = new Set(['design', 'diagnosis']);
+
+/** Deterministic stratified sample from the blind sets of an e2e key. */
+export function stratify(key, { nPos = 12, nNegHinted = 6, nOther = 4, floor = 0 } = {}) {
+  const hinted = (k) => k.lane && (k.lane !== 'semantic' || k.topSimilarity >= floor);
+  const blind = key.filter((k) => /blind/.test(k.set)).sort((a, b) => a.qid.localeCompare(b.qid));
+  const every = (list, n) => (list.length <= n ? list : Array.from({ length: n }, (_, i) => list[Math.floor((i * list.length) / n)]));
+  const pos = every(blind.filter((k) => POS.has(k.category) && hinted(k)), nPos);
+  const negHinted = every(blind.filter((k) => !POS.has(k.category) && hinted(k)), nNegHinted);
+  const other = every(blind.filter((k) => !hinted(k)), nOther);
+  return [...pos, ...negHinted, ...other];
+}
+
+/** Which offered package (by full id or short name) the answer names, if any. Pure. */
+export function mentioned(answer, offered) {
+  const text = String(answer || '');
+  const sentences = text.split(/(?<=[.!?])\s+/);
+  for (const id of offered || []) {
+    const short = id.replace(/^@[^/]+\//, '');
+    const re = (s) => new RegExp(`(?<![\\w@/-])${s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?![\\w/-])`, 'i');
+    // A scoped or hyphenated id is unambiguous anywhere. A bare short name ("migration", "typesafe")
+    // counts only in a sentence that also names rUv — "write the migration" is not a recommendation.
+    if (re(id).test(text) && (id.startsWith('@') || id.includes('-'))) return id;
+    if (sentences.some((s) => /\brUv\b|ruvector|ruvnet/i.test(s) && (re(id).test(s) || (short.length >= 5 && re(short).test(s))))) return id;
+  }
+  return null;
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const outDir = arg('--out', null);
+  if (!outDir || !arg('--key', null)) { console.error('--key and --out are required'); process.exit(2); }
+  const key = JSON.parse(fs.readFileSync(arg('--key'), 'utf8'));
+  const items = new Map();
+  for (const f of ['recommendation-eval.blind.v1.json', 'recommendation-eval.blind.v2.json']) {
+    for (const it of JSON.parse(fs.readFileSync(path.join(ROOT, 'evals', f), 'utf8')).items) items.set(`${f}:${it.id}`, it);
+  }
+  // --all-blinds: every blind prompt, in qid order (the decision run); otherwise the stratified sample.
+  const sample = process.argv.includes('--all-blinds')
+    ? key.filter((k) => /blind/.test(k.set)).sort((a, b) => a.qid.localeCompare(b.qid))
+    : stratify(key, { nPos: Number(arg('--n-pos', 12)), nNegHinted: Number(arg('--n-neg-hinted', 6)), nOther: Number(arg('--n-other', 4)), floor: Number(arg('--floor', 0.532)) });
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'reco-host-'));
+  const kb = path.join(home, 'kb'); fs.mkdirSync(kb);
+  const cwd = path.join(home, 'cwd'); fs.mkdirSync(cwd);
+  const marker = path.join(home, 'marker'); fs.writeFileSync(marker, '');
+  const brainEnv = { RUVNET_BRAIN_HOME: home, KB_DIR: kb, KB_MODEL_CACHE: arg('--models', ''), XENOVA_PATH: arg('--xenova', '') };
+  const worker = spawn(process.execPath, [path.join(ROOT, 'kb', 'forge-mcp-all.mjs')],
+    { env: { PATH: process.env.PATH, HOME: home, ...brainEnv, RUVNET_PACKAGE_RECOMMENDER: '1', RUVNET_BRAIN_IDLE_EXIT_MS: '0' }, stdio: ['pipe', 'pipe', 'ignore'] });   // idle exit off: load-gate waits must not retire the worker mid-run
+  for (const sig of ['SIGTERM', 'SIGINT']) process.once(sig, () => { worker.kill('SIGTERM'); fs.rmSync(home, { recursive: true, force: true }); process.exit(1); });
+  const rl = readline.createInterface({ input: worker.stdout });
+  const waiters = new Map();
+  rl.on('line', (l) => { try { const m = JSON.parse(l); waiters.get(m.id)?.(m); } catch { /* not ours */ } });
+  const call = (id, method) => new Promise((r) => { waiters.set(id, r); worker.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params: {} })}\n`); });
+  const settings = path.join(home, 'settings.json');
+  fs.writeFileSync(settings, JSON.stringify({ autoMemoryEnabled: false, hooks: { UserPromptSubmit: [{ hooks: [{ type: 'command', command: `"${process.execPath}" "${path.join(ROOT, 'plugin', 'scripts', 'unprompted-runtime.mjs')}" UserPromptSubmit`, timeout: 3 }] }] } }));
+  const rows = [];
+  try {
+    await call(1, 'initialize');
+    const warm = await call(2, 'brain/warmup');
+    if (!warm.result?.ready) throw new Error('worker warmup failed');
+    // LOAD GATE: never start a batch while the 1-minute load is above --max-load; wait (polling) instead.
+    // Each row records the load it ran at, so delivery can be read against load afterwards.
+    const maxLoad = Number(arg('--max-load', 1e9));
+    const batch = Number(arg('--batch', 11));
+    const waitForLoad = async () => {
+      let waited = 0;
+      while (os.loadavg()[0] > maxLoad) { await new Promise((res) => setTimeout(res, 20_000)); waited += 20; }
+      if (waited) console.log(`[load-gate] waited ${waited}s for load < ${maxLoad}`);
+    };
+    for (const [n, k] of sample.entries()) {
+      if (n % batch === 0) await waitForLoad();
+      const it = items.get(`${k.set}:${k.id}`);
+      const env = {
+        ...process.env, ...brainEnv, CLAUDE_HOOK: '/usr/bin/true', CLAUDE_CODE_DISABLE_AUTO_MEMORY: '1', RUVNET_PACKAGE_RECOMMENDER: '1',
+        RUVNET_UNPROMPTED_PRODUCERS: JSON.stringify([{ argv: [process.execPath, path.join(ROOT, 'plugin', 'scripts', 'advocacy-route.mjs')], feedStdin: true, channels: ['advocacy'] }]),
+        RUVNET_ADVOCACY_ROUTE_STATE: path.join(home, `state-${n}.json`), RUVNET_ADVOCACY_OUTCOMES: path.join(home, `outcomes-${n}.jsonl`),
+        RUVNET_ADVOCACY_ROUTE_ROOTS: path.join(home, 'none'), RUVNET_SETTINGS_FILE: path.join(home, 'user-settings.json'),
+      };
+      const r = spawnSync(CLAUDE, ['-p', it.prompt, '--output-format', 'stream-json', '--verbose', '--include-hook-events',
+        '--no-session-persistence', '--setting-sources', '', '--settings', settings, '--strict-mcp-config', '--tools', '',
+        '--max-turns', '1', '--max-budget-usd', '0.30',
+        '--append-system-prompt', 'This is a quick planning exchange with no tools: answer in at most five sentences with how you would approach the request.'],
+      { cwd, env, encoding: 'utf8', timeout: 240_000, maxBuffer: 64e6 });
+      let injected = ''; let answer = '';
+      for (const line of String(r.stdout || '').split('\n')) {
+        let o; try { o = JSON.parse(line); } catch { continue; }
+        const blob = JSON.stringify(o);
+        // All three advocacy copies: the package lanes AND the closed catalogue ("capability advocacy").
+        const m = blob.match(/\[RuvNet Brain — (?:rUv (?:may already ship|already ships) this|capability advocacy)\][^"]*/);
+        if (m && !injected) injected = m[0];
+        if (o.type === 'result' && typeof o.result === 'string') answer = o.result;
+      }
+      const offered = injected ? [...new Set([...injected.matchAll(/(?:Consider )?(@[a-z0-9-]+\/[a-z0-9._-]+|[a-z0-9][a-z0-9._-]+) — /gi)].map((x) => x[1]))] : [];
+      rows.push({ qid: k.qid, set: k.set, id: k.id, category: k.category, load1m: +os.loadavg()[0].toFixed(1), exit: r.status, injected: Boolean(injected), offered, said: mentioned(answer, offered), answer: answer.slice(0, 1200) });
+      console.log(`${k.qid} ${k.category.padEnd(9)} hint=${injected ? 'yes' : 'no '} said=${rows.at(-1).said || '-'}`);
+    }
+  } finally {
+    worker.kill('SIGTERM');
+    // Other sessions write under ~/.claude all the time; what THIS run could own is a project entry for
+    // its own temp cwd, so that is checked by name as well as the raw mtime list.
+    const ours = [path.join(os.homedir(), '.claude', 'projects')].flatMap((d) => { try { return fs.readdirSync(d).filter((n) => n.includes('reco-host')); } catch { return []; } });
+    let inDotClaudeJson = false; try { inDotClaudeJson = fs.readFileSync(path.join(os.homedir(), '.claude.json'), 'utf8').includes(path.basename(home)); } catch { /* absent */ }
+    const touched = spawnSync('find', [path.join(os.homedir(), '.claude'), '-newer', marker, '-maxdepth', '3'], { encoding: 'utf8' }).stdout.trim().split('\n').filter(Boolean);
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(path.join(outDir, 'real-host.json'), JSON.stringify({ claude: spawnSync(CLAUDE, ['--version'], { encoding: 'utf8' }).stdout.trim(), sample: rows.length, projectEntriesForThisRun: ours, cwdRecordedInDotClaudeJson: inDotClaudeJson, modifiedUnderDotClaudeByAnyProcess: touched.length, rows }, null, 1));
+    console.log(`project entries for this run under ~/.claude/projects: ${ours.length}; temp cwd in ~/.claude.json: ${inDotClaudeJson}; ~/.claude entries modified by ANY process meanwhile: ${touched.length}`);
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+  process.exit(0);
+}

package/scripts/release-channel-kind.mjs

@@ -27,7 +27,7 @@
 
 /** Content-addressed corpus generation: the tag IS the archive's sha256. */
 export const CORPUS_TAG_PATTERN = /^corpus-sha256-[0-9a-f]{64}$/;
-/** Owner-approved product release: a plain semver tag. */
+/** Product (code) release: a plain semver tag. */
 export const CODE_TAG_PATTERN = /^v\d+\.\d+\.\d+$/;
 
 export function releaseKind(tag) {

package/scripts/release-environment-policy.mjs

@@ -0,0 +1,33 @@
+// release-environment-policy.mjs — the ONE verdict on the npm-scoped Production environment
+// ("Production – ruvnet-brain"), as GitHub's environments API reports it.
+//
+// The design (CONTRIBUTING.md, "What replaces a human approval"): the environment is a scoping boundary —
+// a branch policy (protected branches only) and admins cannot bypass — and NO person is part of it. A
+// required reviewer coming back (someone re-adds one in the GitHub UI) silently re-inserts a human click
+// into every release; it must turn single-source C3 red, not pass because the other two rules still hold.
+export const PRODUCTION_ENVIRONMENT = 'Production – ruvnet-brain';
+
+/**
+ * @param {object|null} environment one element of `GET /repos/{o}/{r}/environments` `.environments[]`
+ * @returns {{ ok: boolean, problems: string[], detail: string }}
+ */
+export function productionEnvironmentVerdict(environment) {
+  if (!environment || typeof environment !== 'object') {
+    return { ok: false, problems: [`environment "${PRODUCTION_ENVIRONMENT}" was not found`], detail: 'not found' };
+  }
+  const rules = Array.isArray(environment.protection_rules) ? environment.protection_rules : [];
+  const branchPolicies = rules.filter((rule) => rule?.type === 'branch_policy').length;
+  const reviewerRules = rules.filter((rule) => rule?.type === 'required_reviewers');
+  const reviewers = reviewerRules.flatMap((rule) => (Array.isArray(rule.reviewers) ? rule.reviewers : [])
+    .map((entry) => entry?.reviewer?.login || entry?.reviewer?.slug || entry?.reviewer?.name || entry?.type || 'unknown'));
+  const problems = [];
+  if (environment.can_admins_bypass !== false) problems.push('admins can bypass the environment (can_admins_bypass is not false)');
+  if (branchPolicies === 0) problems.push('no branch_policy rule (any branch could deploy)');
+  if (reviewerRules.length) problems.push(`a required reviewer is back on the environment (${reviewers.join(', ') || 'unnamed'}) — no human approves a release`);
+  return {
+    ok: problems.length === 0,
+    problems,
+    detail: `can_admins_bypass=${environment.can_admins_bypass}; branch_policy rules: ${branchPolicies}; required_reviewers rules: ${reviewerRules.length}`
+      + (problems.length ? `\n${problems.join('\n')}` : ''),
+  };
+}

package/scripts/single-source-check.mjs

@@ -15,6 +15,8 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { readCheckpoint, checkpointStaleness } from './loop-checkpoint.mjs';
+import { PRODUCTION_ENVIRONMENT, productionEnvironmentVerdict } from './release-environment-policy.mjs';
+import { approvalHits, LOCAL_INSTRUCTION_DRIFT } from './human-approval-phrases.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const HOME = os.homedir();
@@ -33,8 +35,6 @@ const HISTORY = /^(docs\/(adr|ddd|research|audits|reviews|qe)\/|CHANGELOG\.md$|P
 // kb/ is corpus content (primers/cards describing OTHER projects' own commands) and docs/issues/
 // are upstream bug reports quoting other configs — both are data, not instructions to this project.
 const instructions = tracked.filter((f) => /\.md$/.test(f) && !HISTORY.test(f) && !/^(kb|docs\/issues)\//.test(f));
-// Phrases that re-introduce a person as a release gate. Negated statements ("no human approval step") are filtered by the caller.
-const HUMAN_APPROVAL_STEP = /(owner|stuart'?s?|maintainer) (approves?|approval|click|must approve)\b[^.]*(deployment|release|publish|gate)|approves? the `?Production|hand (it|the work) over[^.]*click|required[- ]reviewers?\b|standing authori[sz]ation permits/i;
 const grepIn = (files, re) => files.flatMap((f) => read(f).split('\n')
   .map((l, i) => (re.test(l) ? `${f}:${i + 1}: ${l.trim().slice(0, 140)}` : null)).filter(Boolean));
 const none = (hits) => ({ ok: hits.length === 0, detail: hits.slice(0, 8).join('\n') || 'none' });
@@ -85,7 +85,10 @@ const checks = [
   // The owner is not in the release loop (2026-09-30): the gates are machine gates, and no instruction may
   // route a release through a person clicking in GitHub. B12 applies the same idea to the local CLAUDE.md/AGENTS.md.
   { id: 'B6', area: 'rules', scope: 'repo', title: 'No instruction puts a human approval click (or a required reviewer) in the release path',
-    run: () => none(grepIn(instructions, HUMAN_APPROVAL_STEP).filter((l) => !/\bno (human|reviewer)\b|\bnever\b|\bnot asked\b/i.test(l))) },
+    // Matched without markdown emphasis; a negation counts only in the matched phrase's own clause
+    // (scripts/human-approval-phrases.mjs) — "…; never skip it" does not excuse "the owner approves …".
+    run: () => none(instructions.flatMap((f) => read(f).split('\n')
+      .map((l, i) => (approvalHits(l).length ? `${f}:${i + 1}: ${l.trim().slice(0, 140)}` : null)).filter(Boolean))) },
   { id: 'B7', area: 'rules', scope: 'repo', title: 'Model IDs are selected only in their owner modules',
     run: () => {
       const re = /['"`](claude-(fable|opus|sonnet|haiku)-[0-9][a-z0-9.-]*|gpt-[0-9][a-z0-9.-]*)['"`]/;
@@ -131,9 +134,9 @@ const checks = [
   { id: 'B12', area: 'rules', scope: 'machine', title: 'The local (untracked) CLAUDE.md / AGENTS.md carry no contradicting instruction',
     run: () => {
       const main = path.join(HOME, 'Code/ruvnet-brain');
-      const bad = /npx (-y )?(@claude-flow|claude-flow|ruflo)\b|standing authori[sz]ation permits|owner (approves?|click)|Stuart's approval (of|in GitHub)|approves? the `?Production|hand (it|the work) over[^.]*click|npm run (build|dev|test:integration|test:coverage|test:security)\b|not direct Agent tool/i;
       return none(['CLAUDE.md', 'AGENTS.md'].flatMap((f) => readAbs(path.join(main, f)).split('\n')
-        .map((l, i) => (bad.test(l) ? `${f}:${i + 1}: ${l.trim().slice(0, 120)}` : null)).filter(Boolean)));
+        .map((l, i) => (approvalHits(l, LOCAL_INSTRUCTION_DRIFT, { allowNegation: false }).length
+          ? `${f}:${i + 1}: ${l.trim().slice(0, 120)}` : null)).filter(Boolean)));
     } },
 
   // C — one release path
@@ -162,12 +165,14 @@ const checks = [
   { id: 'C4', area: 'release', scope: 'machine', title: 'The corpus gist job has its authenticated token (RUVNET_GISTS_TOKEN)',
     run: () => { const r = spawnSync('gh', ['secret', 'list', '-R', 'stuinfla/ruvnet-brain'], { encoding: 'utf8' }); return { ok: /^RUVNET_GISTS_TOKEN\b/m.test(r.stdout), detail: r.stdout.split('\n').map((l) => l.split(/\s/)[0]).filter(Boolean).join(', ') }; } },
   { id: 'C3', area: 'release', scope: 'machine', title: 'The npm-scoped Production environment is a boundary: branch policy present, admins cannot bypass (no human reviewer is part of the design)',
+    // One verdict (scripts/release-environment-policy.mjs): branch policy present, admins cannot bypass,
+    // and NO required reviewer — a reviewer re-added in the GitHub UI re-inserts a human click into every release.
     run: () => {
-      const r = spawnSync('gh', ['api', 'repos/stuinfla/ruvnet-brain/environments', '-q',
-        '.environments[]|select(.name=="Production – ruvnet-brain")|[(.can_admins_bypass==false),([.protection_rules[]?|select(.type=="branch_policy")]|length)]|@json'], { encoding: 'utf8' });
-      let noBypass = false; let policies = 0;
-      try { [noBypass, policies] = JSON.parse(r.stdout.trim()); } catch { /* unreadable: falls through to fail */ }
-      return { ok: r.status === 0 && noBypass === true && policies > 0, detail: `can_admins_bypass=false: ${noBypass}; branch_policy rules: ${policies}${r.status === 0 ? '' : ` (${r.stderr.trim()})`}` };
+      const r = spawnSync('gh', ['api', 'repos/stuinfla/ruvnet-brain/environments'], { encoding: 'utf8' });
+      let environment = null;
+      try { environment = (JSON.parse(r.stdout).environments || []).find((e) => e?.name === PRODUCTION_ENVIRONMENT) || null; } catch { /* unreadable */ }
+      const verdict = productionEnvironmentVerdict(environment);
+      return { ok: r.status === 0 && verdict.ok, detail: `${verdict.detail}${r.status === 0 ? '' : ` (${r.stderr.trim()})`}` };
     } },
 
   // D — one corpus / update path

package/scripts/sync-commands.mjs

@@ -37,8 +37,11 @@ import { fileURLToPath } from 'node:url';
 
 const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
 const DIR = path.join(ROOT, 'plugin', 'commands');
-const CANONICAL = 'rvbc.md';
-const ALIASES = ['rvcb.md', 'brain-console.md', 'configure.md'];
+// 2026-10-01 (owner): RuvNet Brain abbreviates as RNB, so the console is `/rnbc` and it is the
+// producer now. `/rnb` was added as a short form; the older spellings stay as aliases because people
+// (and the installer's plugin-presence probe, which looks for rvbc.md) still use them.
+export const CANONICAL = 'rnbc.md';
+export const ALIASES = Object.freeze(['rnb.md', 'rvbc.md', 'rvcb.md', 'brain-console.md', 'configure.md']);
 const CHECK = process.argv.includes('--check');
 
 /** Split `---\n…\n---\n` frontmatter from the body. Both are returned verbatim. */

package/scripts/wired-check.mjs

@@ -76,8 +76,23 @@ const STANDALONE = [
     + 'produce-questions, validate-labels) are each wired to a real caller; this driver is the human entry point.'],
   ['gate', 'retired automatic-hook helper and manual benchmark retained for explicit human use; no workflow or scheduler invokes this expensive command'],
   ['route-gold-rank', 'human-run measurement harness: routes question sets through kb/forge-ask-all.mjs planSourceRoute (no model) and reports where the gold store lands, with Wilson intervals; nothing to schedule'],
-  ['route-latency-warm', 'human-run measurement harness: paired warm latency of two or more search runtimes in one process, load-gated, with paired bootstrap intervals; minutes to hours of model time, never scheduled'],
+  ['abstain-trace', 'human-run measurement harness: traces why the reranker abstains on novice needs whose gold repository was searched (pool membership, cross-encoder on production text, best chunk and gold span); minutes of model time, never scheduled'],
+  ['doc2query-generate', 'build-time generator (ADR-099 arm A): newcomer-style questions per documentation file through the subscription host; run where the corpus is built, never on a customer machine; not yet in the corpus pipeline'],
+  ['doc2query-reach', 'human-run measurement harness: builds per-store RVF entry indexes from doc2query output and measures how often they bring the gold file into the pool; nothing to schedule'],
+  ['sona-query-adapter-eval', 'human-run experiment (ADR-099 arm B): trains a SONA MicroLoRA query adapter on the need-set train split and measures held-out dense rank of the gold file; needs @ruvector/sona from a scratch install; nothing to schedule'],
+  ['judge-train', 'human-run trainer: fits the learned judge (ADR-099 arm C) offline on the need-set train split from recorded cross-encoder pools and reports held-out; writes kb/judge-weights.json only on request; nothing to schedule'],
+  ['need-set-split', 'human-run measurement tool: writes the frozen, repository-stratified train / held-out split every learning arm (ADR-099) trains and is measured on; nothing to schedule'],
+  ['abstain-threshold-sweep', 'human-run measurement harness: replays measured runs at other abstain thresholds (no model) and reports confident hits, confident misses, off-topic abstain and held-out routed with Wilson intervals; nothing to schedule'],
+  ['route-latency-warm','human-run measurement harness: paired warm latency of two or more search runtimes in one process, load-gated, with paired bootstrap intervals; minutes to hours of model time, never scheduled'],
   ['route-index-memory', 'human-run measurement harness: retained memory and cold/warm time of the router metadata index (needs node --expose-gc); nothing to schedule'],
+  ['recommendation-eval', 'human-run measurement harness (ADR-0093): scores the package recommender against evals/recommendation-eval*.json with Wilson intervals; its frozen numbers are asserted by tests/unit/package-recommender.test.mjs, which imports evaluate()'],
+  ['recommendation-e2e', 'human-run measurement harness (ADR-0093 rev 2): spawns the real search worker in a temp brain home and the real hook producer per eval prompt; load-gated and model-bound, so never scheduled'],
+  ['recommendation-judge-score', 'human-run measurement harness (ADR-0093 rev 2): scores a host-model judge\'s picks against an e2e judge key with Wilson intervals; nothing to schedule'],
+  ['recommendation-floor', 'human-run measurement harness (ADR-0093 rev 3): derives the semantic similarity floor on the tuning set only and applies it to judged e2e runs; nothing to schedule'],
+  ['recommendation-real-host', 'human-run measurement harness (ADR-0093 rev 3): fresh `claude -p` sessions with this checkout\'s hook against a warm worker; spends model budget, never scheduled'],
+  ['recommendation-real-host-score', 'human-run measurement harness (ADR-0093 rev 3): scores a real-host run and its agreement with the simulated host; nothing to schedule'],
+  ['recommendation-latency','human-run measurement harness (ADR-0093): paired cold-process latency of advocacy-route with the package flag off vs on; load-sensitive, so never scheduled'],
+  ['package-cards', 'ADR-0093 (Proposed) package-card generator, run by hand to refresh plugin/scripts/package-cards.json from the installed corpus. NOT YET NIGHTLY: the bundle step that would seal package-cards.json into the signed corpus is ADR-0093 phase 2 and is deliberately unbuilt while the recommender is default-off'],
   ['dream-issue-gate','pure Dream Cycle disposition policy; invoked by the external issue adapter, never a GitHub writer'],
   ['sync-census', 'explicit maintainer census writer; a destructive source-to-surface refresh is never scheduled'],
   ['customer-state-matrix', 'human-run release-qualification harness (2026-09-30): applies ONE published release through the real '
@@ -116,7 +131,7 @@ const STANDALONE = [
     + '`--window`). Its former automatic 36-hour dump was deliberately retired from the machine-wide '
     + 'SessionStart hook after 61KB of output hid the current checkpoint; SessionStart now prints the '
     + 'checkpoint plus a compact lesson index and directs topic recall through `ruflo memory search`.'],
-  ['onboarding-console', 'human-started local server reached through the shipped `/rvbc`, `/rvcb`, '
+  ['onboarding-console', 'human-started local server reached through the shipped `/rnbc`, `/rnb`, `/rvbc`, `/rvcb`, '
     + '`/brain-console`, and `/ruvnet-brain:configure` command documents. The command host executes '
     + 'those instructions; there is intentionally no in-process source caller for a long-running CLI.'],
   ['ingest-meeting', 'one-shot ingestion, run by hand'],