ruvnet-brain 4.0.8 → 4.0.24

package/scripts/host-install-matrix.mjs

@@ -0,0 +1,155 @@
+// host-install-matrix.mjs — ONE definition of "install this artifact into clean hosts and judge it".
+//
+// WHY THIS EXISTS. Two harnesses did this same job and disagreed about almost everything:
+//
+//   scripts/staged-host-verifier.mjs        scripts/publication-receipt.mjs (installHosts)
+//   ─────────────────────────────────       ────────────────────────────────────────────────
+//   modes: claude / codex / dual            modes: claudeOnly / codexOnly / dual
+//   --local … --no-selfcheck                --version v<X>  (no --local, selfcheck ON)
+//   RUVNET_CLAUDE_MARKETPLACE_SOURCE        RUVNET_STRICT_INSTALL=1
+//   RUVNET_CODEX_HOOK_TRUST_MODE=bypass     RUVNET_BRAIN_PROFILE=complete
+//
+// They could not even be compared: one produced `fixtures.claude`, the other `hosts.claudeOnly`,
+// for the identical fixture. So "the hosts passed" meant two different things depending on which
+// half of the release you asked, and nothing in the system could notice they had drifted apart.
+//
+// Some of that difference is REAL and must survive: a STAGED check runs before publication against
+// local bytes, so it points the marketplace at the unpacked package and skips selfcheck; a
+// PUBLISHED check runs after, against what npm actually serves, so it resolves by version and
+// installs strictly. That is one axis with two values — a parameter. Everything else was accident.
+//
+// So: the modes are named once, the loop is written once, the verdict is classified once, and the
+// only thing a caller chooses is which VARIANT it is running. Same shape as
+// scripts/console-runtime-identity.mjs, where one enumeration serves both the copy list and the
+// digest — a fact stated once cannot drift from itself.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+/** The three host shapes a release must survive. ONE name each, for every consumer. */
+export const HOST_MODES = Object.freeze(['claude', 'codex', 'dual']);
+
+/** Which CLIs each mode is allowed to see. A codex-only box genuinely has no `claude`. */
+export const MODE_HOSTS = Object.freeze({
+  claude: ['claude'],
+  codex: ['codex'],
+  dual: ['claude', 'codex'],
+});
+
+/**
+ * The published-side receipt has always spelled these `claudeOnly` / `codexOnly` / `dual`, and that
+ * name is baked into current-release.json and every receipt already published — renaming it would
+ * invalidate history for a cosmetic win. So the two spellings are reconciled HERE, once, instead of
+ * being silently different in two files. `publication.installed.claudeOnly` and `fixtures.claude`
+ * are now provably the same fixture, which is what made the two halves of a release incomparable.
+ */
+export const RECEIPT_MODE_NAMES = Object.freeze({ claude: 'claudeOnly', codex: 'codexOnly', dual: 'dual' });
+export const MODE_FROM_RECEIPT_NAME = Object.freeze({ claudeOnly: 'claude', codexOnly: 'codex', dual: 'dual' });
+
+/**
+ * The two genuinely different questions, declared once instead of implied by two files.
+ *
+ * `staged`    — before publication, against local bytes. The marketplace is pointed at the unpacked
+ *               package because nothing is on npm yet, and selfcheck is skipped for the same reason.
+ * `published` — after publication, against what npm actually serves. Resolves by version and
+ *               installs strictly, because this is the run that must match a stranger's machine.
+ */
+export const VARIANTS = Object.freeze({
+  staged: Object.freeze({
+    installerArgs: (_v) => ['--local', '--yes', '--force', '--no-nightly-prompt',
+      '--no-telemetry', '--no-stack', '--no-enhance', '--no-statusline', '--no-selfcheck'],
+    env: ({ packageRoot }) => ({
+      RUVNET_CLAUDE_MARKETPLACE_SOURCE: packageRoot,
+      RUVNET_CODEX_HOOK_TRUST_MODE: 'bypass',
+    }),
+  }),
+  published: Object.freeze({
+    installerArgs: (version) => ['--yes', '--force', '--version', `v${version}`, '--no-nightly-prompt',
+      '--no-telemetry', '--no-stack', '--no-enhance', '--no-statusline'],
+    env: () => ({
+      RUVNET_STRICT_INSTALL: '1',
+      RUVNET_BRAIN_PROFILE: 'complete',
+    }),
+  }),
+});
+
+/** A doctor run is ACCEPTED only on a clean exit. One rule, not one per harness. */
+export function classifyDoctor(result) {
+  const output = `${result.stdout || ''}${result.stderr || ''}`;
+  if (!result.error && result.status === 0) return { accepted: true, status: 'PASS', output };
+  return { accepted: false, status: 'FAIL', output };
+}
+
+/** Build a PATH exposing only the CLIs this mode is entitled to see. */
+export function fixturePath(mode, temp, locate) {
+  const bin = path.join(temp, `bin-${mode}`);
+  fs.mkdirSync(bin, { recursive: true });
+  for (const name of ['node', 'npm', ...MODE_HOSTS[mode]]) {
+    const target = locate(name);
+    if (!target) throw new Error(`${name} CLI unavailable for the ${mode} host fixture`);
+    fs.symlinkSync(target, path.join(bin, name));
+  }
+  return `${bin}:/usr/bin:/bin`;
+}
+
+/**
+ * Install `packageRoot` into a clean HOME per mode and run its doctor. Returns a result for EVERY
+ * mode — including the ones that failed — because "which host broke" is the whole diagnostic value,
+ * and the previous harnesses threw on the first failure and lost the rest.
+ *
+ * @returns {{verdict:'PASS'|'FAIL', fixtures:Record<string,object>, error?:string}}
+ */
+export function runHostMatrix({ packageRoot, version, variant = 'staged', locate, temp, run = spawnSync }) {
+  const spec = VARIANTS[variant];
+  if (!spec) throw new Error(`unknown host-matrix variant: ${variant}`);
+  const workspace = temp || fs.mkdtempSync(path.join(os.tmpdir(), 'ruvnet-host-matrix-'));
+  const installer = path.join(packageRoot, 'bin', 'install.mjs');
+  const fixtures = {};
+  let verdict = 'PASS';
+  let error;
+
+  for (const mode of HOST_MODES) {
+    try {
+      const home = path.join(workspace, `home-${mode}`);
+      const codexHome = path.join(home, '.codex');
+      const brainHome = path.join(home, '.cache', 'ruvnet-brain');
+      fs.mkdirSync(path.join(home, '.claude'), { recursive: true });
+      if (mode !== 'claude') fs.mkdirSync(codexHome, { recursive: true });
+      const env = {
+        ...process.env,
+        HOME: home,
+        CODEX_HOME: codexHome,
+        RUVNET_BRAIN_HOME: brainHome,
+        RUVNET_BRAIN_KB: path.join(brainHome, 'kb'),
+        CI: 'true',
+        PATH: fixturePath(mode, workspace, locate),
+        ...spec.env({ packageRoot }),
+      };
+      const install = run(process.execPath, [installer, ...spec.installerArgs(version)], {
+        cwd: packageRoot, env, encoding: 'utf8', timeout: 1_200_000, maxBuffer: 32 * 1024 * 1024,
+      });
+      if (install.error || install.status !== 0) {
+        throw new Error(`install failed for ${mode}: ${(install.stderr || install.error?.message || '').slice(-4000)}`);
+      }
+      const doctor = run(process.execPath, [installer, '--doctor', '--hooks'], {
+        cwd: packageRoot, env, encoding: 'utf8', timeout: 300_000, maxBuffer: 32 * 1024 * 1024,
+      });
+      const classified = classifyDoctor(doctor);
+      fixtures[mode] = { status: classified.status, doctorExit: doctor.status, version };
+      if (!classified.accepted) {
+        verdict = 'FAIL';
+        fixtures[mode].output = classified.output.slice(-5000);
+        // The output belongs IN the error. The previous harness put it there and I dropped it in
+        // the consolidation, so CI reported a bare "doctor failed for claude" and the one thing
+        // needed to act on it — what the doctor actually said — was thrown away.
+        error = error || `doctor failed for ${mode} (exit ${doctor.status}): ${classified.output.slice(-4000)}`;
+      }
+    } catch (e) {
+      verdict = 'FAIL';
+      fixtures[mode] = { status: 'FAIL', error: e.message };
+      error = error || e.message;
+    }
+  }
+  return error ? { verdict, fixtures, error } : { verdict, fixtures };
+}

package/scripts/issue-watch.mjs

@@ -209,6 +209,112 @@ export async function run({ dryRun = false, now = Date.now(), repo = REPO } = {}
   return { results, alertsSent, checkedAt: new Date(now).toISOString() };
 }
 
+/**
+ * AN OPEN PR YOU OPENED IS UNFINISHED WORK. Added 2026-08-06.
+ *
+ * The continuation gate could already see two kinds of outstanding work — an issue past its SLA,
+ * and a red CI run. It could not see the third and most common kind: a pull request that is sitting
+ * open, fully green, one `gh pr merge` from done. Measured that day: PRs #117, #118 and #119 were
+ * opened and the gate said nothing at the Stop boundary, because a PR is neither an issue nor a CI
+ * failure and nobody had called `--commit-to`. The owner's reaction — "why the hell have you
+ * stopped?" — was the gate's blind spot talking, not a missing rule.
+ *
+ * This is the producer half. `issue-watch.mjs` already answers "what is outstanding on GitHub" once
+ * an hour and already writes the artifact the gate reads; it simply only knew about issues. Teaching
+ * it PRs needs no new pipeline, no new writer, and no network call at the Stop boundary — which is
+ * the whole reason to put it here rather than in the gate.
+ *
+ * DELIBERATELY NARROW, for the same reason the issues source reports only breaches: a permanently
+ * non-empty list makes the gate nag forever, which trains people to ignore it.
+ *   - DRAFT PRs are excluded. A draft is explicitly "not ready" — nagging about it is noise.
+ *   - `checksState` is recorded, never filtered on here. The gate decides what is actionable, so
+ *     this stays a plain observation and the policy lives in one place.
+ * Failure is silent-and-empty by design: this is best-effort decoration on a status file whose
+ * absence must never break the watcher, and a PR list that cannot be read is not evidence of work.
+ */
+export function collectOpenPrs() {
+  try {
+    const prs = ghJson(['pr', 'list', '--repo', REPO, '--state', 'open', '--json',
+      'number,title,isDraft,mergeable,statusCheckRollup,url,author']);
+    if (!Array.isArray(prs)) return [];
+    return prs.filter((p) => !p.isDraft).map((p) => {
+      const rollup = Array.isArray(p.statusCheckRollup) ? p.statusCheckRollup : [];
+      // A check is UNRESOLVED while it has no conclusion yet. Same discipline as redCiOpenWork:
+      // a run still in flight is not yet evidence of anything.
+      const unresolved = rollup.filter((c) => {
+        const s = String(c?.status || '').toUpperCase();
+        const concl = String(c?.conclusion || c?.state || '');
+        return s === 'IN_PROGRESS' || s === 'QUEUED' || s === 'PENDING' || (!concl && s !== 'COMPLETED');
+      }).length;
+      const failing = rollup.filter((c) => {
+        const v = String(c?.conclusion || c?.state || '').toUpperCase();
+        return v === 'FAILURE' || v === 'TIMED_OUT' || v === 'CANCELLED' || v === 'ERROR';
+      }).length;
+      let checksState = 'none';
+      if (rollup.length) checksState = unresolved ? 'pending' : (failing ? 'failing' : 'passing');
+      return {
+        number: p.number,
+        title: String(p.title || '').slice(0, 80),
+        author: p.author?.login || '',
+        checksState,
+        failing,
+        mergeable: p.mergeable || 'UNKNOWN',
+        url: p.url || `https://github.com/${REPO}/pull/${p.number}`,
+      };
+    });
+  } catch { return []; }
+}
+
+/**
+ * THE THINGS GITHUB EMAILS THE OWNER ABOUT. Added 2026-08-06, at his request:
+ *
+ *   "That stuff that keeps coming to me as an email that I seem to have to tell you and you don't
+ *    know. I want you to know about anything that would cause GitHub to spit out a notify note."
+ *
+ * That is a real asymmetry: GitHub pushes Dependabot and secret-scanning findings to his inbox, and
+ * nothing pulled them into this session, so he had to relay them by hand. A watcher that already
+ * answers "what is outstanding on GitHub" every hour is the right place to close it.
+ *
+ * Failed workflow runs are deliberately NOT collected here — scripts/signal-watch.mjs is the SINGLE
+ * WRITER of ci-status.json and the continuation gate already reads red CI from it. Duplicating that
+ * signal would give one fact two owners, which is the one-poisoned-predicate hazard ADR-050 exists
+ * to prevent.
+ *
+ * Each endpoint is independent and best-effort: a repo with code scanning disabled 404s, a token
+ * without `security_events` 403s, and neither is evidence of a problem — an alert we cannot read is
+ * not an alert. Never let this fail the watcher.
+ */
+export function collectSecurityAlerts() {
+  const alerts = [];
+  const safe = (args) => { try { const v = ghJson(args); return Array.isArray(v) ? v : []; } catch { return []; } };
+
+  for (const a of safe(['api', `repos/${REPO}/dependabot/alerts?state=open&per_page=50`])) {
+    alerts.push({
+      kind: 'dependabot',
+      severity: String(a?.security_advisory?.severity || 'unknown').toLowerCase(),
+      title: `${a?.dependency?.package?.name || 'dependency'}: ${String(a?.security_advisory?.summary || '').slice(0, 70)}`,
+      url: a?.html_url || `https://github.com/${REPO}/security/dependabot`,
+    });
+  }
+  for (const a of safe(['api', `repos/${REPO}/secret-scanning/alerts?state=open&per_page=50`])) {
+    alerts.push({
+      kind: 'secret-scanning',
+      severity: 'critical', // a live credential in a public repo has exactly one severity
+      title: String(a?.secret_type_display_name || a?.secret_type || 'secret'),
+      url: a?.html_url || `https://github.com/${REPO}/security/secret-scanning`,
+    });
+  }
+  for (const a of safe(['api', `repos/${REPO}/code-scanning/alerts?state=open&per_page=50`])) {
+    alerts.push({
+      kind: 'code-scanning',
+      severity: String(a?.rule?.security_severity_level || a?.rule?.severity || 'unknown').toLowerCase(),
+      title: String(a?.rule?.description || a?.rule?.id || 'code scanning alert').slice(0, 70),
+      url: a?.html_url || `https://github.com/${REPO}/security/code-scanning`,
+    });
+  }
+  return alerts;
+}
+
 async function main() {
   const dryRun = process.argv.includes('--dry-run');
   const asJson = process.argv.includes('--json');
@@ -260,6 +366,8 @@ async function main() {
       fs.writeFileSync(STATUS_PATH, JSON.stringify({
         at: new Date().toISOString(), repo: REPO,
         open: issues.length, breaches: issues.filter((i) => i.breach).length, issues,
+        prs: collectOpenPrs(),
+        securityAlerts: collectSecurityAlerts(),
       }, null, 2));
     } catch { /* status file is best-effort; never break the watcher */ }
   }

package/scripts/learning-enable.mjs

@@ -1,380 +1,4 @@
-#!/usr/bin/env node
-/**
- * learning-enable.mjs — answers "is rUv learning actually ON?" with EVIDENCE, and refuses to
- * pretend there is a switch when there isn't one.
- *
- * ─────────────────────────────────────────────────────────────────────────────────────────────
- * THE FAILURE THIS FILE EXISTS TO PREVENT (2026-07-21, caught before it shipped)
- * ─────────────────────────────────────────────────────────────────────────────────────────────
- * A survey of this machine reported, as the headline finding of the night: "26 rUv learning hooks
- * are installed and ZERO are enabled — learning is off." Stuart had been asking "is learning
- * actually on?" all evening and was told no.
- *
- * That finding was FALSE, in both directions, and it was read straight off `ruflo hooks list`:
- *
- *     | pre-edit  | PreToolUse | No | | | Never |     ← "Enabled: No", 26 times
- *
- * Reading the actual installed source rather than trusting the table
- * (~/.npm-global/lib/node_modules/ruflo/node_modules/@claude-flow/cli/dist/src/
- *  mcp-tools/hooks-tools.js, `export const hooksList`) shows the handler is a HARDCODED STATIC
- * ARRAY. It takes no input (`inputSchema: { properties: {} }`), opens no file, reads no database,
- * and stamps every one of the 26 entries with the literal `status: 'active'`. Confirmed live via
- * `ruflo hooks list --format json` — the payload contains `"status": "active"` and has NO `enabled`
- * key at all.
- *
- * The CLI renderer (commands/hooks.js, `listCommand`) then draws a column keyed `enabled`:
- *
- *     { key: 'enabled', ..., format: (v) => v ? output.success('Yes') : output.dim('No') }
- *
- * `v` is `undefined` for every row, so it prints "No" 26 times. The same mismatch empties the
- * Priority and Executions columns and makes Last Executed read "Never" for everything. Proof the
- * table is inert: `ruflo hooks list --enabled`, which is documented as "show only enabled hooks",
- * returns all 26 rows unchanged — the CLI passes the filter to a handler that accepts no arguments.
- *
- * So BOTH readings of that table are worthless as an answer to "is learning on?":
- *   • "Enabled: No"      → a field-name bug. Not a state. Never was.
- *   • `status: "active"` → a hardcoded literal in a catalog of which subcommands exist. Also not a state.
- *
- * `ruflo hooks list` is a MENU, not a dashboard. It cannot answer the question in either direction.
- *
- * ─────────────────────────────────────────────────────────────────────────────────────────────
- * WHAT "ENABLED" ACTUALLY MEANS
- * ─────────────────────────────────────────────────────────────────────────────────────────────
- * There is no ruflo-side enable flag: `ruflo hooks enable` and `ruflo hooks disable` do not exist
- * (both fall through to the help text, verified live). There is no per-hook config file under
- * ~/.ruflo or ~/.claude-flow — the only file there with an `enabled` key is first-run-enabled.json,
- * which is `{"enabled":{"spinner":true}}`, about a CLI spinner, and a trap for any detector that
- * greps for the word.
- *
- * rUv's learner is driven by the ruflo DAEMON and the `mcp__ruflo__hooks_*` MCP tools that agents
- * call. It is NOT driven by entries in Claude Code's ~/.claude/settings.json. That distinction is
- * the whole ballgame, because it is the second way to get this wrong: this machine has ZERO ruflo
- * learning hooks wired into settings.json (the only `ruflo` command there is a statusline helper)
- * and yet the learner had recorded 457 trajectories and 457 patterns, last adapted 67 minutes
- * before this was written. A detector that concluded "no ruflo hooks in settings.json → learning is
- * off" would be just as wrong as the one that read the table, and far more convincing.
- *
- * The ONLY honest signal is the learner's own accumulated state, which is a real file with real
- * counters that move: ~/.claude-flow/neural/stats.json. scripts/learnings.mjs already treats it as
- * the source of truth for the console's "What I've learned" panel; this agrees with it rather than
- * inventing a second, disagreeing answer.
- *
- * ─────────────────────────────────────────────────────────────────────────────────────────────
- * WHY --enable REFUSES
- * ─────────────────────────────────────────────────────────────────────────────────────────────
- * You cannot enable something that has no enabled state. There is no verified command that turns
- * those 26 rows to "Yes", because nothing reads them. The tempting move — wiring `ruflo hooks
- * post-edit` into every PostToolUse in ~/.claude/settings.json — would be a GUESS dressed as a fix:
- * it edits a file that affects every project on this machine, to solve a problem that does not
- * exist, duplicating capture the daemon is already doing. So --enable writes nothing and prints
- * what actually drives the learner instead.
- *
- * This whole file is therefore READ-ONLY BY CONSTRUCTION. It never opens a file for writing, which
- * is a stronger guarantee than backing one up: there is no write path to get wrong, and the tests
- * assert ~/.claude/settings.json is byte-identical afterwards.
- *
- * Usage:
- *   node scripts/learning-enable.mjs [--status]   report real state with evidence (default)
- *   node scripts/learning-enable.mjs --enable     refuse, and explain what genuinely drives learning
- *   node scripts/learning-enable.mjs --disable    refuse, same reason, inverted
- *   node scripts/learning-enable.mjs --json       machine-readable state
- *
- * Exit codes: 0 = reported. 2 = refused (deliberate non-action, distinct from 1 = error).
- */
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-/**
- * Resolve HOME honestly. os.homedir() consults $HOME on POSIX, but reading it explicitly first
- * means the tests can point this at a temp HOME without depending on that implementation detail
- * — and means a caller can audit a different machine's dotfiles without lying about whose they are.
- */
-const homeOf = (home) => home || process.env.HOME || os.homedir();
-
-/**
- * Staleness threshold: a learner that hasn't adapted in a week is idle, not off.
- *
- * EXPORTED because capability-registry.mjs needs the same number and used to have no staleness check
- * at all — it called a learner last adapted 400 days ago "on", while this file called the identical
- * file "IDLE — nothing in 400 days". One constant, one definition; a second copy is a future
- * disagreement with a delay fuse on it.
- */
-export const STALE_DAYS = 7;
-
-/**
- * Read the learner's accumulated state — the real signal.
- *
- * Rule: if the file is missing or unparseable we return null counters, NEVER 0. "0 patterns" is a
- * claim that the learner ran and learned nothing; "not checked" is the truth when we never found
- * the file. Shipping the former as the latter is how a detector starts lying.
- */
-export function readLearnerState({ home, now = Date.now() } = {}) {
-  const HOME = homeOf(home);
-  const statsPath = path.join(HOME, '.claude-flow', 'neural', 'stats.json');
-
-  let raw = null;
-  let parsed = null;
-  try { raw = fs.readFileSync(statsPath, 'utf8'); } catch { /* no learner on this machine yet */ }
-  if (raw !== null) { try { parsed = JSON.parse(raw); } catch { /* present but corrupt */ } }
-
-  // `Number(v)` was the bug, not the guard around it. Number(null) === 0, Number('') === 0 and
-  // Number(false) === 0 are all finite, so the previous `Number.isFinite(Number(v))` accepted three
-  // non-numbers as a MEASURED ZERO — the precise substitution this function's docstring above forbids.
-  // MEASURED: `{"trajectoriesRecorded": null}` produced the verdict "the learner file exists and
-  // GENUINELY records 0 trajectories", the word "genuinely" attached to a value nobody ever counted.
-  // A counter is a counter only when it arrives as a JSON number.
-  const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
-
-  // Timestamps are NOT counters and must not share their reader. `lastAdaptation` is written as epoch
-  // milliseconds today, but an upstream switch to ISO-8601 is the single most ordinary schema change
-  // there is — and under num() an ISO string returns null, which nulls `days`, which makes the IDLE
-  // branch unreachable. MEASURED: a learner idle 400 days reported "ON — the learner is accumulating"
-  // purely because its timestamp was a string. The staleness check evaporated on exactly the drift it
-  // was written to survive, so this reader accepts both shapes and still refuses everything else.
-  const ts = (v) => {
-    if (typeof v === 'number' && Number.isFinite(v)) return v;
-    if (typeof v === 'string' && v.trim()) {
-      const ms = Date.parse(v);
-      if (Number.isFinite(ms)) return ms;
-    }
-    return null;
-  };
-
-  const trajectories = parsed ? num(parsed.trajectoriesRecorded) : null;
-  const patterns = parsed ? num(parsed.patternsLearned) : null;
-  const lastMs = parsed ? ts(parsed.lastAdaptation) : null;
-
-  return {
-    statsPath,
-    present: raw !== null,
-    corrupt: raw !== null && parsed === null,
-    trajectories,
-    patterns,
-    lastAdaptationMs: lastMs,
-    // `lastMs ? …` treated epoch 0 as "no timestamp"; `=== null` is the only honest test for absence.
-    ageMinutes: lastMs === null ? null : Math.floor((now - lastMs) / 60000),
-  };
-}
-
-/**
- * Is the ruflo daemon alive? This is the process that feeds the learner, so its liveness is
- * corroborating evidence — but NOT proof on its own, and not required: a dead daemon with fresh
- * counters still means learning ran. Reported as a separate line, never folded into the verdict.
- */
-export function readDaemonState({ home } = {}) {
-  const HOME = homeOf(home);
-  const pidPath = path.join(HOME, '.claude-flow', 'daemon.pid');
-  let pid = null;
-  try { pid = Number(String(fs.readFileSync(pidPath, 'utf8')).trim()); } catch { return { pidPath, pid: null, alive: null }; }
-  if (!Number.isInteger(pid) || pid <= 0) return { pidPath, pid: null, alive: null };
-  // Signal 0 probes existence without touching the process.
-  try { process.kill(pid, 0); return { pidPath, pid, alive: true }; }
-  catch (e) { return { pidPath, pid, alive: e.code === 'EPERM' }; }
-}
-
-/**
- * Count ruflo LEARNING hooks wired into Claude Code's settings.json.
- *
- * Reported for completeness and explicitly labelled NOT REQUIRED, because the honest finding is
- * that this number was 0 on a machine that was actively learning. It is here so nobody re-derives
- * the wrong conclusion from its absence later. A statusline helper is not a learning hook, so
- * matching bare "ruflo" would overcount — we match a `ruflo hooks <subcommand>` invocation.
- */
-export function readSettingsWiring({ home } = {}) {
-  const HOME = homeOf(home);
-  const settingsPath = path.join(HOME, '.claude', 'settings.json');
-  let cfg = null;
-  try { cfg = JSON.parse(fs.readFileSync(settingsPath, 'utf8')); } catch { return { settingsPath, present: false, learningHooks: null }; }
-
-  // TWO REAL CRASHES, both from a hand-edited settings.json, both reproduced with exit code 1 and a
-  // raw stack trace — which is the worst possible outcome for a command whose entire job is to tell
-  // a worried person whether learning is on. It left them unable to find out at all.
-  //
-  //   `null`  is valid JSON, so the try above succeeds and cfg is null → `cfg.hooks` threw
-  //           "TypeError: Cannot read properties of null (reading 'hooks')".
-  //   `hooks: {command: …}` written as an object instead of the array the schema wants → the inner
-  //           for..of threw "TypeError: object is not iterable".
-  //
-  // This file invites hand-editing (it prints the path), so malformed shapes are an EXPECTED state,
-  // not an exceptional one. A structural surprise degrades to "not checked" — null, never 0, because
-  // a count of 0 is a claim about their configuration and null is the truth about our reading of it.
-  if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) return { settingsPath, present: true, learningHooks: null };
-  if (cfg.hooks !== undefined && (!cfg.hooks || typeof cfg.hooks !== 'object' || Array.isArray(cfg.hooks))) {
-    return { settingsPath, present: true, learningHooks: null };
-  }
-  const groups = cfg.hooks || {};
-
-  // AN UNREADABLE SUB-STRUCTURE POISONS THE COUNT, and it must. Guarding the iteration with
-  // `Array.isArray(x) ? x : []` stops the crash and then quietly SKIPS the malformed entry — so a
-  // settings.json with one hook group written as an object came back as a confident `0`, meaning
-  // "we looked everywhere and found no ruflo learning hooks." We did not look everywhere; we
-  // skipped the part we could not parse. That is this file's own thesis violated three lines below
-  // where it is stated, and its regression test caught it.
-  //
-  // A partially-read structure yields null ("not checked"), never a total. Losing the count of the
-  // entries we COULD read is the correct trade: an incomplete count presented as a complete one is
-  // the failure mode, and there is no honest way to render "at least 3" in a field documented as
-  // an exact number.
-  let unreadable = false;
-  let count = 0;
-  for (const entries of Object.values(groups)) {
-    if (!Array.isArray(entries)) { unreadable = true; continue; }
-    for (const entry of entries) {
-      if (entry?.hooks !== undefined && !Array.isArray(entry.hooks)) { unreadable = true; continue; }
-      for (const h of Array.isArray(entry?.hooks) ? entry.hooks : []) {
-        if (/\bruflo\b[^"]*\bhooks\b/.test(String(h?.command || ''))) count += 1;
-      }
-    }
-  }
-  return { settingsPath, present: true, learningHooks: unreadable ? null : count };
-}
-
-/** Derive the verdict from the evidence. Never asserted, never cached, never guessed. */
-export function verdict(learner) {
-  if (!learner.present) {
-    return { code: 'NO_LEARNER_STATE', headline: 'NOT LEARNING YET — no learner state on this machine' };
-  }
-  if (learner.corrupt) {
-    return { code: 'CORRUPT', headline: 'UNKNOWN — learner state file exists but is unreadable' };
-  }
-  const t = learner.trajectories;
-  const p = learner.patterns;
-  if (t === null && p === null) {
-    return { code: 'UNKNOWN_SHAPE', headline: 'UNKNOWN — learner state file has no recognisable counters' };
-  }
-
-  // PARTIAL DRIFT IS STILL DRIFT. Upstream does not rename both counters in the same release, and the
-  // half-renamed case is the one that reaches users. Every line below needs BOTH numbers — to compare
-  // them against zero, and to print them — so one unread counter is one unanswerable question.
-  //
-  // The two failures this replaces were mirror images of the same coercion, and both were MEASURED on
-  // real bytes. `{trajectories_recorded: 457, patternsLearned: 0}` fell through `(t || 0) === 0` —
-  // null coerced to 0 — and reported "genuinely records 0 trajectories and 0 patterns" to a machine
-  // holding 457. Read the other way, `{trajectoriesRecorded: null, patternsLearned: 457}` reached the
-  // ON branch and rendered the literal string "null work sessions recorded and 457 patterns learned".
-  // A confident OFF and a printed "null" from one missing field.
-  //
-  // This is the guard num() exists to enable, placed where it survives: the `|| 0` three lines below
-  // it discarded null the instant it was produced, so the correct reader upstream bought nothing.
-  if (t === null || p === null) {
-    const missing = t === null ? 'trajectoriesRecorded' : 'patternsLearned';
-    const seen = t === null ? `patternsLearned=${p}` : `trajectoriesRecorded=${t}`;
-    return {
-      code: 'UNKNOWN_PARTIAL',
-      missingField: missing,
-      headline: `UNKNOWN — learner state file is half-readable (${seen}, but ${missing} is not a number this version can read)`,
-    };
-  }
-
-  if (t === 0 && p === 0) {
-    return { code: 'INITIALISED_EMPTY', headline: 'INITIALISED BUT EMPTY — learner exists, has recorded nothing' };
-  }
-  const days = learner.ageMinutes === null ? null : Math.floor(learner.ageMinutes / 1440);
-  if (days !== null && days >= STALE_DAYS) {
-    return { code: 'IDLE', headline: `IDLE — learned before, but nothing in ${days} days` };
-  }
-  return { code: 'ON', headline: 'ON — the learner is accumulating' };
-}
-
-/**
- * Gather everything, and NEVER throw doing it.
- *
- * The guards inside readSettingsWiring cover the two shapes that actually crashed, but the outer
- * belt matters independently: this function is the entry point for the CLI *and* for
- * capability-registry's learning row, so an unanticipated structural surprise anywhere below must
- * degrade to an honest UNKNOWN rather than take down the page that was asked the question. A
- * crashed probe and a probe reporting "off" are equally useless to the reader; only one of them is
- * also a lie, and neither is acceptable when "I could not tell" is available and true.
- */
-export function gatherState(opts = {}) {
-  const learner = readLearnerState(opts);
-  const safe = (fn, fallback) => { try { return fn(); } catch { return fallback; } };
-  return {
-    learner,
-    daemon: safe(() => readDaemonState(opts), { pidPath: null, pid: null, alive: null }),
-    settings: safe(() => readSettingsWiring(opts), { settingsPath: null, present: false, learningHooks: null }),
-    verdict: safe(() => verdict(learner), { code: 'CORRUPT', headline: 'UNKNOWN — learner state could not be interpreted' }),
-  };
-}
-
-/** "not checked" beats a confident 0. Every rendered number passes through here. */
-const show = (v) => (v === null || v === undefined ? 'not checked' : String(v));
-
-const tilde = (p, HOME) => (p.startsWith(HOME) ? p.replace(HOME, '~') : p);
-
-function renderStatus(state, HOME) {
-  const { learner, daemon, settings, verdict: v } = state;
-  const L = [];
-  L.push('');
-  L.push('rUv learning — actual state');
-  L.push('');
-  L.push(`  ${v.headline}`);
-  L.push('');
-  L.push('  Evidence (all read at render time):');
-  L.push(`    trajectories recorded : ${show(learner.trajectories)}`);
-  L.push(`    patterns learned      : ${show(learner.patterns)}`);
-  L.push(`    last adaptation       : ${learner.ageMinutes === null ? 'not checked' : `${learner.ageMinutes} min ago`}`);
-  L.push(`    source                : ${tilde(learner.statsPath, HOME)}${learner.present ? '' : '  (absent)'}`);
-  L.push(`    ruflo daemon          : ${daemon.alive === null ? 'no pid file' : daemon.alive ? `running (pid ${daemon.pid})` : `pid ${daemon.pid} not running`}`);
-  L.push('');
-  L.push('  Not evidence, despite appearances:');
-  L.push('    `ruflo hooks list` prints "Enabled: No" for all 26 hooks. That column is a');
-  L.push('    field-name bug, not a state — the handler returns `status: "active"` from a');
-  L.push('    hardcoded array and has no `enabled` key for the renderer to read. Proof:');
-  L.push('    `ruflo hooks list --enabled` still returns all 26. Ignore that table.');
-  L.push('');
-  L.push(`    ruflo learning hooks in settings.json: ${show(settings.learningHooks)} — and this is NOT required.`);
-  L.push('    The learner is fed by the ruflo daemon and the mcp__ruflo__hooks_* tools, not by');
-  L.push('    Claude Code hook entries. A count of 0 here does not mean learning is off.');
-  L.push('');
-  return L.join('\n');
-}
-
-function renderRefusal(which) {
-  const L = [];
-  L.push('');
-  L.push(`REFUSING --${which}: there is nothing to ${which}.`);
-  L.push('');
-  L.push('  The 26 hooks in `ruflo hooks list` have no enabled state to toggle. The "Enabled"');
-  L.push('  column is a field-name bug (handler returns `status: "active"`; renderer reads a');
-  L.push('  nonexistent `enabled` key), and `ruflo hooks enable` / `ruflo hooks disable` do not');
-  L.push('  exist — both fall through to the help text.');
-  L.push('');
-  L.push('  This command will not edit ~/.claude/settings.json to fake it. That file affects every');
-  L.push('  project on this machine, and wiring `ruflo hooks ...` into it would duplicate capture');
-  L.push('  the daemon already performs — a guess dressed as a fix.');
-  L.push('');
-  L.push('  What actually drives the learner (verified commands, run them yourself):');
-  L.push('    ruflo hooks intelligence --status    initialise / inspect the intelligence system');
-  L.push('    ruflo hooks intelligence --train     force one training cycle');
-  L.push('    ruflo hooks metrics                  learning metrics dashboard');
-  L.push('');
-  L.push('  To see whether learning is on, with evidence:');
-  L.push('    node scripts/learning-enable.mjs --status');
-  L.push('');
-  return L.join('\n');
-}
-
-function main(argv) {
-  const has = (f) => argv.includes(f);
-  const HOME = homeOf();
-
-  if (has('--enable') || has('--disable')) {
-    process.stdout.write(renderRefusal(has('--enable') ? 'enable' : 'disable'));
-    return 2;
-  }
-
-  const state = gatherState();
-  if (has('--json')) {
-    process.stdout.write(`${JSON.stringify(state, null, 2)}\n`);
-    return 0;
-  }
-  process.stdout.write(`${renderStatus(state, HOME)}\n`);
-  return 0;
-}
-
-if (process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1])) {
-  process.exit(main(process.argv.slice(2)));
-}
+// Compatibility export for repository tools. The executable implementation belongs inside the
+// self-contained plugin payload so Stable Spine and Codex-only installs never depend on a separate
+// Claude marketplace checkout.
+export * from '../plugin/scripts/learning-enable.mjs';