ruvnet-brain 4.0.36 → 4.2.2-dev

package/scripts/health-repair.mjs

@@ -24,7 +24,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { execFileSync, spawnSync } from 'node:child_process';
 import { findStores, diagnose } from './memory-doctor.mjs';
-import { loadRuntimePreferences } from '../plugin/scripts/runtime-preferences.mjs';
+import { learnerCwd, loadRuntimePreferences } from '../plugin/scripts/runtime-preferences.mjs';
 
 const HOME = os.homedir();
 // The SAME project root learn-flush.mjs computes, by the same rule — the two halves of the flush
@@ -195,7 +195,16 @@ function flushLearning() {
 function trainLearning() {
   if (!RUFLO) return { ok: false, log: 'ruflo is not on this machine — install it with `npm i -g ruflo@latest` to enable learning' };
   try {
-    execFileSync(RUFLO, ['hooks', 'intelligence', '--train'], { cwd: HOME, env: RUFLO_ENV, stdio: 'ignore', timeout: 600_000 });
+    // ISSUE #136: train the SAME store the console card reads. With `cwd: HOME` the card read the
+    // project's learner and this trained the home one, so the button could never clear the card it
+    // was offered for — a remedy that cannot resolve its own finding is worse than no button.
+    // PROJECT is the same root learn-flush.mjs and learn-capture.sh resolve (#134).
+    // ISSUE #139 — now that ruflo v3.38.9 made `--train` REAL (ruvnet/ruflo#2940 was a no-op
+    // before), training the wrong store is no longer harmless: it moves that store's
+    // lastAdaptation to 0s and the card SILENTLY SELF-CLEARS while the learner the operator
+    // actually uses is untouched. #136 already moved this off `cwd: HOME`; it now shares the
+    // console's resolver so the remedy provably trains the store the card measured.
+    execFileSync(RUFLO, ['hooks', 'intelligence', '--train'], { cwd: learnerCwd({ cwd: PROJECT }), env: RUFLO_ENV, stdio: 'ignore', timeout: 600_000 });
   } catch (e) { return { ok: false, log: `training cycle failed: ${e.message}` }; }
   return { ok: true, log: 'ran one training cycle in the cross-project learner' };
 }

package/scripts/ingest-new-repos.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * ingest-new-repos.mjs — load what rUv shipped, without being asked.
+ *
+ * THE GAP THIS CLOSES, and it is embarrassing rather than subtle. The owner asked on 2026-08-20
+ * why `ruvnet/ultrasonic` was not in the brain: *"aren't you loading everything Ruv creates every
+ * day?????"* The honest answer was no, and nothing ever had. `nightly-wrapper.sh` refreshed
+ * lessons, health, the release watchdog and the replay proof — and contained ZERO references to
+ * ingestion. New rUv repos only ever entered the brain when a human typed `ingest-repo.mjs` by
+ * hand, so the corpus drifted behind the org silently and the only symptom was a question the
+ * brain could not answer.
+ *
+ * `brain-stamp.mjs` already COMPUTES built-vs-pending every night. Nothing acted on it. Measuring
+ * a gap and never closing it is how 137 repos stayed uningested while the scorecard reported the
+ * number cheerfully.
+ *
+ * WHY IT IS BOUNDED. Ingestion embeds a whole repository; doing 137 in one night would run for
+ * hours and starve everything after it in the nightly. `--max` (default 3) keeps the nightly
+ * bounded and lets the corpus converge over days instead of blocking on one enormous run. That is
+ * a deliberate trade, and the run SAYS how many remain rather than implying it finished.
+ *
+ * WHAT IT WILL NOT DO. It does not write capability cards. An ingested store with no card is DARK —
+ * valid bytes that no by-description query can reach — and `ingest-repo.mjs` already says so on
+ * every run. Inventing a card from a repo name would put a confident description in the routing
+ * layer that nobody grounded in the source, which is worse than an honest gap: it would route real
+ * questions to a corpus that cannot answer them. So this reports the dark stores it created and
+ * leaves the card to someone who reads the repo.
+ *
+ *   node scripts/ingest-new-repos.mjs                 # report only
+ *   node scripts/ingest-new-repos.mjs --apply         # ingest up to --max new repos
+ *   node scripts/ingest-new-repos.mjs --apply --max 5
+ */
+import { execFileSync, spawnSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { storeRoot, storesAt, darkStores } from '../kb/store-root.mjs';
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+const OWNER = process.env.RUVNET_ORG_OWNER || 'ruvnet';
+const APPLY = process.argv.includes('--apply');
+const arg = (n, d) => {
+  const i = process.argv.indexOf(n);
+  return i >= 0 && process.argv[i + 1] ? process.argv[i + 1] : d;
+};
+const MAX = Number(arg('--max', '3'));
+
+/** Every repo the org actually has right now. Live, never a remembered list. */
+function liveOrgRepos() {
+  try {
+    const out = execFileSync('gh', [
+      'repo', 'list', OWNER, '--limit', '500', '--no-archived', '--json', 'name,isFork,pushedAt,diskUsage',
+    ], { cwd: ROOT, encoding: 'utf8', maxBuffer: 1 << 26 });
+    return JSON.parse(out)
+      .filter((r) => !r.isFork)
+      // AN EMPTY REPO IS NOT A FAILURE TO RETRY FOREVER (measured 2026-08-20).
+      //
+      // The first bulk run reported 7 failures; six of them are size=0KB — genuinely empty
+      // repositories (socket, Auto-GPT, CodeGPT, ruvGPT2, rUvGPT, AIConverse). `git fetch` succeeds
+      // and there is simply nothing to embed, so ingestion fails correctly and then the repo stays
+      // "missing", so the NEXT night retries it, forever. A permanent nightly failure that is
+      // actually correct behaviour trains the reader to ignore the failure line — which is how a
+      // real failure would then hide inside it.
+      .filter((r) => Number(r.diskUsage ?? 1) > 0)
+      // Newest first: if the budget only allows a few tonight, spend it on what rUv shipped most
+      // recently, which is what a question is most likely to be about.
+      .sort((a, b) => String(b.pushedAt).localeCompare(String(a.pushedAt)))
+      .map((r) => r.name);
+  } catch (error) {
+    return { error: error?.message || String(error) };
+  }
+}
+
+export function pendingRepos(orgRepos, root = storeRoot()) {
+  const have = new Set(storesAt(root).map((s) => String(s).toLowerCase()));
+  return orgRepos.filter((name) => !have.has(String(name).toLowerCase()));
+}
+
+const isMain = (() => {
+  try { return process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url); }
+  catch { return false; }
+})();
+
+if (isMain) {
+  const repos = liveOrgRepos();
+  if (!Array.isArray(repos)) {
+    // A LIST WE COULD NOT FETCH IS NOT AN EMPTY LIST. Reporting "0 new repos" here would read as
+    // "the brain is current" when the truth is "I could not look" — the exact conflation this
+    // repository keeps paying for.
+    console.error(`[ingest-new] could NOT list ${OWNER}'s repos: ${repos.error}`);
+    console.error('[ingest-new] this is NOT "nothing new" — it is "I could not look". Exiting 1.');
+    process.exit(1);
+  }
+
+  const root = storeRoot();
+  const missing = pendingRepos(repos, root);
+  console.log(`[ingest-new] ${OWNER}: ${repos.length} live repos, ${storesAt(root).length} ingested, ${missing.length} missing`);
+  if (!missing.length) { console.log('[ingest-new] corpus is level with the org.'); process.exit(0); }
+
+  console.log(`[ingest-new] next up (newest first): ${missing.slice(0, MAX).join(', ')}`);
+  if (!APPLY) {
+    console.log(`[ingest-new] report only. Re-run with --apply to ingest up to ${MAX}.`);
+    process.exit(0);
+  }
+
+  let done = 0; let failed = 0;
+  for (const name of missing.slice(0, MAX)) {
+    console.log(`\n[ingest-new] ingesting ${name}`);
+    const r = spawnSync(process.execPath, [path.join(ROOT, 'scripts', 'ingest-repo.mjs'), '--name', name],
+      { cwd: ROOT, stdio: 'inherit', env: process.env, timeout: 45 * 60_000 });
+    if (r.status === 0) done += 1;
+    else { failed += 1; console.log(`[ingest-new] ${name} FAILED — left missing so the next run retries it`); }
+  }
+
+  const stillMissing = missing.length - done;
+  const dark = darkStores(root);
+  console.log(`\n[ingest-new] ingested ${done}, failed ${failed}, ${stillMissing} still missing.`);
+  if (dark.length) {
+    console.log(`[ingest-new] ${dark.length} store(s) are DARK — valid bytes no by-description query can reach.`);
+    console.log('[ingest-new] a card is a claim about what a repo is FOR; write it from the source, not the name.');
+  }
+  process.exit(failed ? 1 : 0);
+}

package/scripts/ingest-repo.mjs

@@ -20,6 +20,7 @@ import fs from 'node:fs';
 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';
 
 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; };
@@ -33,7 +34,26 @@ if (!NAME) {
   process.exit(2);
 }
 
-const KB = path.join(ROOT, 'kb');
+// THE WRITER NOW USES THE SAME RESOLVER AS THE READER. This was `path.join(ROOT, 'kb')` — the
+// repo's build directory — while retrieval (kb/forge-mcp-all.mjs) reads storeRoot(), which defaults
+// to ~/.cache/ruvnet-brain/kb. That split is why on 2026-08-12 three repos were ingested, each
+// printed `roundtrip 3/3 PASS` and "searchable now", and NONE of them could be found by search: the
+// ingest wrote one root and the live brain read another. This file's own header promises "the new
+// repo is searchable immediately", and that promise was false by construction.
+//
+// Two adversarial audits both flagged that fixing the READER alone (kb/store-root.mjs, earlier
+// today) made the split GUARANTEED rather than accidental for a dev checkout. This closes it at the
+// writer, which is the half that was left.
+//
+// The repo's own bundle build still targets ./kb by setting KB_DIR — an explicit override of a
+// stated default, not a second answer to the same question.
+// TWO DIFFERENT THINGS, WHICH THE ORIGINAL `path.join(ROOT,'kb')` CONFLATED and my first fix
+// inherited: where the BUILD SCRIPTS live (forge-refresh.mjs, always in this checkout) and where
+// the STORES go (the root retrieval actually reads). Pointing both at storeRoot() broke immediately
+// with `Cannot find module .../.cache/ruvnet-brain/kb/forge-refresh.mjs` — the tool is not the
+// output. One name for two facts is the same defect as one fact in two names.
+const KB_TOOLS = path.join(ROOT, 'kb');   // where forge-refresh.mjs lives
+const KB = storeRoot();                   // where stores go — the root the reader reads
 const CLONES = path.join(ROOT, 'clones');
 const kb = NAME.toLowerCase();
 const dir = SOURCE ? path.resolve(SOURCE) : path.join(CLONES, NAME);
@@ -62,18 +82,58 @@ const url = process.env.RUVNET_CANONICAL_URL || 'https://raw.githubusercontent.c
 // full-body source indexing (the 2026-07-10 depth-restore run zeroed ruvector this way).
 const FULL = arg('--full', FULL_HINTS[kb] || '');
 const KEEP = arg('--keep', KEEP_DIRS[kb] || '');
-const buildArgs = ['forge-refresh.mjs', '--repo', dir, '--out', '.', '--name', kb, '--canonical-url', url];
+// `--out` is the STORE ROOT, not '.' — cwd is the tools directory now, and '.' would have written
+// the store next to the build script, which is precisely the reader/writer split this change closes.
+const buildArgs = ['forge-refresh.mjs', '--repo', dir, '--out', KB, '--name', kb, '--canonical-url', url];
 if (FULL) buildArgs.push('--full', FULL);
 if (KEEP) buildArgs.push('--keep', KEEP);
 console.log(`[refresh bge-768] ${kb}${FULL ? ' (--full: ' + FULL.split(',').length + ' prefixes)' : ''}${KEEP ? ' (--keep: ' + KEEP + ')' : ''}`);
-run('node', buildArgs, { cwd: KB, env });
+run('node', buildArgs, { cwd: KB_TOOLS, env });
 console.log(`[symbols] ${kb}`);
 try { run('node', ['scripts/build-symbols.mjs', '--name', kb], { cwd: ROOT, env }); } catch { console.log('  (symbols skipped — sparse repo)'); }
 
 const ok = fs.existsSync(path.join(KB, `${kb}.big.rvf`))
   && fs.existsSync(path.join(KB, `${kb}.passages.jsonl`))
   && fs.existsSync(path.join(KB, `${kb}.meta.json`));
-console.log(ok
-  ? `\n[done] ${NAME} ingested → searchable now via search_ruvnet (no restart). For capability-confidence, build its primer next.`
-  : `\n[FAIL] ${NAME}: expected stores missing after build.`);
+// BUILT IS NOT REACHABLE, AND THIS LINE USED TO CLAIM OTHERWISE. It printed "searchable now" on
+// the strength of three files existing. Measured 2026-08-13 on the very next run: helix ingested
+// cleanly, every file present, and `search_ruvnet` answered "Searched 0 RuvNet repos" — the router
+// declined because nothing in capability-cards.md describes the repo, so a by-description query
+// cannot reach it. 26 of 66 stores are in exactly that state. The 2026-08-12 incident (three repos
+// ingested, all reporting success, none findable) was read as a path bug; the path was only half of
+// it. A store with no card is BUILT AND DARK, and saying "searchable" of it is the product lying.
+const carded = (() => {
+  try {
+    return new RegExp(`^##\\s+${kb}\\s*$`, 'im')
+      .test(fs.readFileSync(path.join(KB, 'capability-cards.md'), 'utf8'));
+  } catch { return false; }
+})();
+// AN ARTIFACT WITH NO COMMITTED RECIPE IS NOT DURABLE WORK — it is a local side effect with a
+// countdown on it. Proven overnight 2026-08-13 -> 08-14: a scheduled bundle apply extracted an
+// Aug-8 bundle over the live cache. capability-cards.md SURVIVED because it was committed and the
+// brain was restored from the repo in one command. helix, rvQR, RuCelium and wifi-veil — ingested
+// and VERIFIED ROUTING hours earlier — were gone without a trace, because a .rvf is a 32MB
+// gitignored build artifact that existed in exactly one directory on one machine.
+//
+// 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) {
+  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.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}`); }
+}
+
+console.log(!ok
+  ? `\n[FAIL] ${NAME}: expected stores missing after build.`
+  : carded
+    ? `\n[done] ${NAME} ingested AND routable → answers by-description queries now (no restart).`
+    : `\n[done] ${NAME} ingested, but DARK: no '## ${kb}' section in ${path.join(KB, 'capability-cards.md')}.\n`
+      + `       The store is valid and a by-description query CANNOT reach it. Write a card describing\n`
+      + `       what ${NAME} is for and when to reach for it, then re-check with a real search_ruvnet query.`);
 process.exit(ok ? 0 : 1);

package/scripts/learning-replay-cli.mjs

@@ -132,9 +132,14 @@ export async function main(argv = process.argv.slice(2)) {
   const dirs = buildFixtures(base);
   process.once('exit', () => cleanupFixtureDaemons(dirs));
   const record = recordInProjectA(dirs, { trap });
-  const seed = trap === TRAP.MEMORY_SEARCH
-    ? seedProjectBMemory(dirs)
-    : { key: null, storeExit: null, ok: true, skipped: 'not required' };
+  // Every target fixture needs a real AgentDB file before Codex starts. The global SessionStart
+  // contract otherwise injects an opt-in question and requires the model to wait for an answer,
+  // which prevents both post-task arms from producing the command this trap is meant to compare.
+  // Only the memory-search trap needs the independent cache note; post-task needs an initialized,
+  // otherwise empty store so its control differs solely on the lesson under test.
+  const seed = seedProjectBMemory(dirs, {
+    includeFixtureRecord: trap === TRAP.MEMORY_SEARCH,
+  });
   const refresh = nightlyRefresh(dirs);
   console.log(`  record: ${record.projectCount} sources; promoted=${record.promoted}; ok=${record.ok}`);
   console.log(`  seed: ${seed.skipped || `ok=${seed.ok}`}`);

package/scripts/learning-replay-fixture.mjs

@@ -23,11 +23,16 @@ import {
 const CLAUDE_BIN = process.env.RUVNET_CLAUDE_BIN
   || path.join(os.homedir(), '.npm-global', 'bin', 'claude');
 const CODEX_BIN = process.env.RUVNET_CODEX_BIN || 'codex';
-const sh = (cmd, args, options = {}) => spawnSync(cmd, args, {
-  encoding: 'utf8',
-  timeout: 120_000,
-  ...options,
-});
+const sh = (cmd, args, options = {}) => {
+  const [binary, argv] = /\.[cm]?js$/i.test(cmd)
+    ? [process.execPath, [cmd, ...args]]
+    : [cmd, args];
+  return spawnSync(binary, argv, {
+    encoding: 'utf8',
+    timeout: 120_000,
+    ...options,
+  });
+};
 const remove = (target) => {
   try { fs.rmSync(target, { recursive: true, force: true }); } catch { /* already gone */ }
 };
@@ -143,9 +148,23 @@ export function recordInProjectA(dirs, {
   };
 }
 
-export function seedProjectBMemory(dirs, { ruflo = RUFLO_BIN } = {}) {
+export function seedProjectBMemory(dirs, {
+  ruflo = RUFLO_BIN,
+  includeFixtureRecord = true,
+} = {}) {
   const db = path.join(dirs.projectB, '.swarm', 'memory.db');
   const init = initMemoryDb(ruflo, db, dirs.projectB);
+  if (!includeFixtureRecord) {
+    return {
+      db,
+      key: null,
+      initExit: init.status,
+      storeExit: null,
+      exactReadExit: null,
+      ok: init.status === 0 && fs.existsSync(db),
+      skipped: 'AgentDB initialized; memory-search record not required',
+    };
+  }
   const store = sh(ruflo, [
     'memory', 'store', '-k', PROJECT_B_MEMORY_KEY,
     '--value', PROJECT_B_MEMORY_VALUE, '-n', 'default', '--path', db,

package/scripts/learning-replay-proof.mjs

@@ -454,6 +454,44 @@ export function writeArtifact(file, aggregateResult, meta = {}) {
     runs,
   };
   fs.mkdirSync(path.dirname(file), { recursive: true });
+
+  // AN ENVIRONMENT THAT CANNOT MEASURE MUST NOT OVERWRITE ONE THAT DID.
+  // Measured 2026-08-19: `learning-replay` had been red on main since 2026-08-11 because the
+  // artifact was re-recorded carrying `verdict: UNKNOWN` and "3/3 run(s) could not be measured;
+  // executor error: spawnSync codex ENOENT" — written by a nightly container with no `codex` on
+  // PATH. `codex` resolves fine on the owner's machine (0.148.0), so a real PASS was replaced by
+  // "I could not look", and every later CI run correctly refused the non-PASS verdict. The gate was
+  // right; its INPUT had been destroyed by a host that could never produce one. Same distinction
+  // `restore-local-ingests.mjs` and `degradation-watch` both needed: CANNOT-MEASURE is not
+  // MEASURED-AND-FAILED. A real FAIL still overwrites — that is a measurement, and it must land.
+  // "PARTIALLY MEASURED" IS NOT "COULD NOT MEASURE" either, and the first version of this guard got
+  // that wrong within the hour — the same conflation it exists to prevent, committed inside it. Its
+  // predicate was a substring match on "could not be measured", so a run reporting
+  // "1/3 run(s) could not be measured; 1/3 passed" — a genuine mixed result carrying a live
+  // regression signal — was swallowed, leaving a PASS from 2026-08-03 standing. It suppressed
+  // exactly the finding it should have let through. A host that cannot measure produces NO
+  // measurements: every run unknown. If even one run yielded a pass or a fail, the executor plainly
+  // ran and the result is real, however unwelcome.
+  const runsTotal = Number(artifact.n ?? 0);
+  const runsUnknown = Number(artifact.unknowns ?? 0);
+  const nothingMeasured = runsTotal > 0 && runsUnknown === runsTotal;
+  const unmeasurable = artifact.verdict === 'UNKNOWN'
+    && nothingMeasured
+    && /ENOENT|executor error/i.test(String(artifact.why ?? ''));
+  if (unmeasurable && fs.existsSync(file)) {
+    try {
+      const prior = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (prior?.verdict && prior.verdict !== 'UNKNOWN') {
+        process.stderr.write(
+          `[learning-replay] REFUSING to overwrite a ${prior.verdict} recorded ${prior.at} with an\n`
+          + `  unmeasurable UNKNOWN — this host cannot run the executor (${artifact.why}).\n`
+          + '  The prior measurement stands. Re-record on a host that has the executor.\n',
+        );
+        return prior;
+      }
+    } catch { /* unreadable prior is not a reason to keep a bad one — fall through and write */ }
+  }
+
   fs.writeFileSync(file, `${JSON.stringify(artifact, null, 2)}\n`);
   return artifact;
 }

package/scripts/nightly-wrapper.sh

@@ -7,6 +7,29 @@
 # class a blind retry can fix) -> if it fails AGAIN, loud phone alert + a durable marker file that
 # ground-ruvnet.sh surfaces at the top of the very next session, unprompted. Success or a legitimate
 # "nothing was due tonight" no-op: log only, phone stays silent.
+
+# WHICH NODE RUNS THIS DECIDES WHETHER TONIGHT'S WRITES SURVIVE (measured 2026-08-20).
+#
+# This file hardcoded "$NODE_BIN" in eight places. That is node v22.13.1 (ABI 127), and the
+# better-sqlite3 binding agentdb needs is built for ABI 137 — so under it agentdb SILENTLY falls
+# back to non-persistent sql.js and every write is lost. Silently, because better-sqlite3 is an
+# OPTIONAL dependency (ruvnet/ruflo#2219): the failure never errors and the CLI still prints a
+# success table. `lesson-bridge.mjs --apply` and `learning-replay.mjs` both write, so the nightly
+# was discarding its own results. Measured, same command, same DB, only the interpreter differing:
+#   "$NODE_BIN"   v22.13.1  ->  2 sql.js fallback msgs, DURABLE=NO
+#   /opt/homebrew/bin/node v24.18.0 ->  0 fallback msgs,        DURABLE=YES
+# Resolve a node whose ABI matches the binding, and fail loudly rather than silently losing data.
+NODE_BIN=""
+for _cand in /opt/homebrew/opt/node@24/bin/node /opt/homebrew/bin/node "$(command -v node 2>/dev/null)"; do
+  [ -x "$_cand" ] || continue
+  if [ "$("$_cand" -p 'process.versions.modules' 2>/dev/null)" = "137" ]; then NODE_BIN="$_cand"; break; fi
+done
+if [ -z "$NODE_BIN" ]; then
+  echo "[nightly] FATAL: no node with ABI 137 found — agentdb writes would silently not persist." >&2
+  echo "[nightly] checked: /opt/homebrew/opt/node@24/bin/node /opt/homebrew/bin/node \$(command -v node)" >&2
+  exit 1
+fi
+
 set -u
 # kb/models-cache (the fallback) starts cold every time -> every nightly re-downloads the ONNX
 # embedder from HuggingFace. Point at the already-warm cache instead (verified present).
@@ -55,9 +78,9 @@ run_once() {
   { echo "===== nightly-wrapper rebuild attempt $1 — $(date -u +%FT%TZ) ====="
     if [ "$SMOKE" = "1" ]; then
       echo "[SMOKE] dry-run: exercising the full chain, NOT building"
-      /usr/local/bin/node scripts/self-update.mjs --fresh-window 60
+      "$NODE_BIN" scripts/self-update.mjs --fresh-window 60
     else
-      /usr/local/bin/node scripts/self-update.mjs --apply --fresh-window 60
+      "$NODE_BIN" scripts/self-update.mjs --apply --fresh-window 60
     fi
   } >> "$LOG" 2>&1
   rc=$?
@@ -83,6 +106,19 @@ RUFLO_DAEMON_AUTOSTART=0 ~/.npm-global/bin/ruflo memory distill run --path .swar
 # automatically (keeps last 14), zero risk to the live DB (reads only).
 RUFLO_DAEMON_AUTOSTART=0 ~/.npm-global/bin/ruflo memory backup --db .swarm/memory.db --keep 14 >> "$LOG" 2>&1 || true
 
+# LESSON BRIDGE (ADR-066, 2026-08-10) — carry newly-tagged machine-wide lessons into the store the
+# hooks actually read. Without this the bridge is a command someone has to remember, and a learning
+# system that depends on being remembered is the thing ADR-066 was written to fix: knowledge sat in
+# AgentDB for 18 days while the repo re-made the mistake it described.
+#
+# Safe to run unattended and to run when nothing changed: it is idempotent (bridged rows are replaced
+# wholesale, native rows are never touched), it writes through the store's locked atomic writer, and
+# it REFUSES to apply when it reads zero rows while bridged lessons are installed — so a transient
+# read failure can never strip the store. Best-effort, never blocks the rebuild.
+echo "===== lesson-bridge — $(date -u +%FT%TZ) =====" >> "$LOG"
+"$NODE_BIN" plugin/scripts/lesson-bridge.mjs --apply >> "$LOG" 2>&1 \
+  || echo "===== lesson-bridge: SKIPPED (see line above) =====" >> "$LOG"
+
 # AgentDB drift canary (2026-07-23, P7 wiring sweep) — scripts/memdb-health.sh existed unwired since
 # 2026-07-09/10, the exact nights idx_bridge_key/idx_bridge_ns corruption recurred 3x on this very DB
 # while in WAL mode. Best-effort, same shape as its brain-health/key-health siblings below: never
@@ -128,15 +164,27 @@ sh scripts/memdb-health.sh .swarm/memory.db >> "$LOG" 2>&1 \
 # REPORTS ONLY. It cannot push, merge, close or publish (asserted by test). Exit 1 means a human
 # needs to look, and the reasons print in full rather than as a count.
 echo "===== GITHUB-HEALTH watch — $(date -u +%FT%TZ) =====" >> "$LOG"
-/usr/local/bin/node scripts/github-health-watch.mjs >> "$LOG" 2>&1 \
+# LOAD WHAT rUv SHIPPED, WITHOUT BEING ASKED (added 2026-08-20).
+#
+# The owner: "aren't you loading everything Ruv creates every day?????" The answer was no — this
+# file had ZERO ingestion, so new repos only entered the brain when a human typed the command.
+# Measured the day this landed: 181 live repos, 69 ingested, 125 missing. `brain-stamp.mjs` had
+# been COMPUTING that gap nightly and nothing acted on it.
+#
+# Bounded to 3/night on purpose: ingestion embeds a whole repository, and 125 in one run would
+# starve everything after it here. The corpus converges over days and the run says how many
+# remain rather than implying it finished. A failed repo is left missing so the next night retries.
+"$NODE_BIN" scripts/ingest-new-repos.mjs --apply --max 3 >> "$LOG" 2>&1 || true
+
+"$NODE_BIN" scripts/github-health-watch.mjs >> "$LOG" 2>&1 \
   || echo "[github-health] findings above need attention" >> "$LOG"
 
 echo "===== RELEASE-CONVERGENCE watchdog — $(date -u +%FT%TZ) =====" >> "$LOG"
-/usr/local/bin/node scripts/release-convergence-watchdog.mjs --dispatch >> "$LOG" 2>&1 \
+"$NODE_BIN" scripts/release-convergence-watchdog.mjs --dispatch >> "$LOG" 2>&1 \
   || echo "[release-watchdog] exited non-zero — see above; nightly continues" >> "$LOG"
 
 echo "===== LEARNING-REPLAY counterfactual trap — $(date -u +%FT%TZ) =====" >> "$LOG"
-/usr/local/bin/node scripts/learning-replay.mjs --n 3 --model haiku >> "$LOG" 2>&1
+"$NODE_BIN" scripts/learning-replay.mjs --n 3 --model haiku >> "$LOG" 2>&1
 LR_RC=$?
 case "$LR_RC" in
   0) echo "===== LEARNING-REPLAY: PASS =====" >> "$LOG" ;;
@@ -152,7 +200,7 @@ esac
 BRAIN_KB="$HOME/.cache/ruvnet-brain/kb"
 if [ -f "$BRAIN_KB/forge-ask-all.mjs" ]; then
   echo "===== brain-health canary — $(date -u +%FT%TZ) =====" >> "$LOG"
-  if (cd "$BRAIN_KB" && /usr/local/bin/node forge-ask-all.mjs --dir . --q "HNSW vector index" --k 1) >> "$LOG" 2>&1; then
+  if (cd "$BRAIN_KB" && "$NODE_BIN" forge-ask-all.mjs --dir . --q "HNSW vector index" --k 1) >> "$LOG" 2>&1; then
     echo "===== brain-health canary: OK =====" >> "$LOG"
   else
     echo "===== brain-health canary: DOWN — escalating =====" >> "$LOG"
@@ -168,7 +216,7 @@ fi
 # The canary itself handles urgent pushes on alive->DEAD transitions (and recovery notices), so a
 # known-dead key doesn't re-alarm every night; here we only log.
 echo "===== key-health canary — $(date -u +%FT%TZ) =====" >> "$LOG"
-zsh -lc 'cd /Users/stuartkerr/Code/ruvnet-brain && /usr/local/bin/node scripts/key-canary.mjs --notify' >> "$LOG" 2>&1 \
+zsh -lc 'cd /Users/stuartkerr/Code/ruvnet-brain && "$NODE_BIN" scripts/key-canary.mjs --notify' >> "$LOG" 2>&1 \
   && echo "===== key-health canary: all present keys alive =====" >> "$LOG" \
   || echo "===== key-health canary: at least one key DEAD (push sent on new deaths) =====" >> "$LOG"
 

package/scripts/onboarding-console.mjs

@@ -66,6 +66,7 @@ import { loadLessons, updateLessons, ratify, demote, restore, pending, weightOf,
 import {
   openRouterCredentialStatus,
   saveOpenRouterCredential,
+  learnerCwd,
 } from '../plugin/scripts/runtime-preferences.mjs';
 import { applyNightlyChoice, nightlyStatus } from './nightly-controller.mjs';
 // One canonical answer to "which directory is this, and have I counted it already?" — shared with
@@ -2213,10 +2214,29 @@ function observeLearning() {
 
   let lastTrainSeconds = null; let trajectories = 0;
   try {
+    // ISSUE #136 — THE LEARNER IS PROJECT-SCOPED, so this must ask about the SERVED project.
+    //
+    // `ruflo hooks intelligence --status` reports `Data Dir: <cwd>/.claude-flow/neural`. With
+    // `cwd: SYSTEM_HOME` this measured `~/.claude-flow/neural` — a store nothing writes to on a
+    // machine whose work happens inside project directories. Measured on one machine, one minute:
+    // the home store held 1,216 trajectories last trained 6.9 DAYS ago while the served project held
+    // 9,940 last trained 22 SECONDS ago. The card said "Your learner has gone quiet" about a learner
+    // training every few seconds.
+    //
+    // This file already carries the verdict on this exact mistake at the refresh-child spawn: "cwd =
+    // the SERVED project, NOT REPO … it was a real console-honesty bug". Same rule, same file,
+    // different call site — #104's and #134's residual arriving a third time.
+    // ISSUE #139 (@ObiWanKenobi) — `process.cwd()` was a HARDCODE in the opposite direction from
+    // #136's `SYSTEM_HOME`. Neither asked which scope was in effect; the first was wrong by default
+    // and the second is right only BECAUSE `project` is the default. Under
+    // `RUVNET_LEARNING_SCOPE=user` the flush feeds ~/.claude-flow/neural while this read
+    // <project>/.claude-flow/neural — the same false-positive card, inverted. The writer and this
+    // reader now call ONE resolver (runtime-preferences.learnerCwd), so they agree by construction
+    // instead of by coincidence.
     const r = spawnSync(path.join(SYSTEM_HOME, '.npm-global/bin/ruflo'),
       ['hooks', 'intelligence', '--status'],
       {
-        cwd: SYSTEM_HOME,
+        cwd: learnerCwd(),
         env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' },
         encoding: 'utf8',
         timeout: 20_000,

package/scripts/org-repo-count.mjs

@@ -0,0 +1,119 @@
+/**
+ * org-repo-count.mjs — how many repos rUv actually has, DERIVED, with the source recorded.
+ *
+ * THE DEFECT THIS REPLACES. `orgTotalApprox: 248` was a literal, written twice:
+ *
+ *     scripts/build-bundle.mjs:402   coverage: { …, orgTotalApprox: 248, … }
+ *     scripts/brain-stamp.mjs:77     coverage: { …, orgTotalApprox: 248, … }
+ *
+ * Measured 2026-08-12, two independent ways: `users/ruvnet.public_repos` = 200, and a paginated
+ * `users/ruvnet/repos` fetch = 200 distinct names. So the denominator every coverage percentage in
+ * this product is computed against was wrong by 48 — and wrong in BOTH copies, which is what a
+ * restated fact always does.
+ *
+ * Replacing 248 with 200 would repeat the mistake with a fresher number. The count changes whenever
+ * rUv pushes a new repo, so it is not a constant and must not be stored as one.
+ *
+ * HONESTY OVER AVAILABILITY. A build with no network must not silently invent a total. `source` is
+ * carried alongside the number so every consumer can see whether it is live:
+ *
+ *     { count: 200, source: 'live',     at: '2026-08-12T…' }   ← queried just now
+ *     { count: 200, source: 'recorded', at: '2026-08-12T…' }   ← last live reading, reused offline
+ *     { count: null, source: 'unknown', at: null }             ← never say a number we cannot source
+ *
+ * A consumer that receives `unknown` must omit the claim rather than print a guess — the same rule
+ * sync-census follows when it refuses to write a non-positive census.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+/** The last LIVE reading, so an offline build reuses a real measurement instead of a literal. */
+export const RECORD_PATH = process.env.RUVNET_ORG_COUNT_RECORD
+  || path.join(ROOT, 'data', 'org-repo-count.json');
+
+export const OWNER = process.env.RUVNET_ORG_OWNER || 'ruvnet';
+
+/** Ask GitHub. Returns a positive integer or null — never a guess, never a partial page. */
+export function fetchLiveCount(owner = OWNER, { run = spawnSync } = {}) {
+  // `public_repos` is the account's own count: one request, no pagination to get wrong.
+  const r = run('gh', ['api', `users/${owner}`, '--jq', '.public_repos'], { encoding: 'utf8', timeout: 30_000 });
+  if (r.error || r.status !== 0) return null;
+  const n = Number(String(r.stdout || '').trim());
+  return Number.isInteger(n) && n > 0 ? n : null;
+}
+
+const readRecord = (file) => {
+  try {
+    const j = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return Number.isInteger(j?.count) && j.count > 0 ? j : null;
+  } catch { return null; }
+};
+
+/**
+ * The count, its provenance, and when it was taken.
+ * A successful live read updates the record, so the offline fallback is always a real past reading.
+ */
+/**
+ * READING A NUMBER MUST NOT MUTATE A TRACKED FILE.
+ *
+ * `persist` defaults to FALSE, and that default is the fix for a release that could not ship.
+ * Every call used to write `data/org-repo-count.json` — a TRACKED file — with a fresh `at`
+ * timestamp. Both production callers (`brain-stamp.mjs`, `build-bundle.mjs`) are BUILD scripts, so
+ * building the release candidate dirtied the working tree, and `release-qe`'s stabilization seal
+ * requires `dirty === false`. Measured 2026-08-19, once the seal was made to name its cause:
+ *
+ *     stabilization seal failed: INVALID_LINEAGE
+ *       working tree is dirty (1 path(s)):
+ *         M data/org-repo-count.json
+ *
+ * That single line had blocked EVERY release since 2026-08-08 (issue #141: nothing published in
+ * eleven days while main advanced 46 commits), because the seal previously reported only the code
+ * `INVALID_LINEAGE` and named nothing.
+ *
+ * The committed record still matters — it is the honest offline fallback, so an air-gapped or
+ * rate-limited build reuses the last REAL reading instead of inventing one. It just may not be
+ * written as a side effect of being read. Refreshing it is now a deliberate act (`--record`), the
+ * same separation `refresh-model-catalog.mjs` already uses for the model snapshot.
+ */
+export function orgRepoCount({ owner = OWNER, file = RECORD_PATH, now = new Date(), fetch = fetchLiveCount, persist = false } = {}) {
+  const live = fetch(owner);
+  if (live) {
+    const at = now.toISOString();
+    try {
+      fs.mkdirSync(path.dirname(file), { recursive: true });
+      if (persist) fs.writeFileSync(file, `${JSON.stringify({ owner, count: live, at }, null, 2)}\n`);
+    } catch { /* recording is best-effort; the live number still stands */ }
+    return { count: live, source: 'live', at };
+  }
+  const rec = readRecord(file);
+  if (rec) return { count: rec.count, source: 'recorded', at: rec.at || null };
+  return { count: null, source: 'unknown', at: null };
+}
+
+/**
+ * Refreshing the committed record is a DELIBERATE ACT, never a side effect of a build.
+ *
+ *     node scripts/org-repo-count.mjs --record
+ *
+ * Same separation `refresh-model-catalog.mjs` uses for the model snapshot: a build READS, a human
+ * (or a scheduled refresh that commits its own result) WRITES. That boundary is what keeps the
+ * working tree clean for `release-qe`'s stabilization seal.
+ */
+const isMain = (() => {
+  try { return process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url); }
+  catch { return false; }
+})();
+
+if (isMain) {
+  const record = process.argv.includes('--record');
+  const r = orgRepoCount({ persist: record });
+  process.stdout.write(`${JSON.stringify(r, null, 2)}\n`);
+  if (record && r.source !== 'live') {
+    process.stderr.write('NOT recorded: the live read failed, and a remembered number may not be '
+      + 'rewritten as if it were fresh.\n');
+    process.exit(1);
+  }
+}