ruvnet-brain 4.7.20 → 4.7.22

package/scripts/notify.sh

@@ -1,12 +1,17 @@
 #!/bin/sh
 # notify.sh "<title>" "<message>" [priority] [tags] — push alert to Stuart's phone via ntfy.sh.
-# Topic from $NTFY_TOPIC or the project .env. Fail-silent: alerting must never break a pipeline.
+# Topic from $NTFY_TOPIC or the project .env. Alerting must never break a pipeline (no caller runs under
+# `set -e`), but the exit code now tells the truth so a caller can record delivery (4.7.21):
+#   0 delivered (2xx) · 1 not delivered (network or HTTP error; curl --fail) · 2 paging off (NTFY_TOPIC="" or no topic)
+# NTFY_TOPIC set-but-EMPTY is an explicit opt-out (job-heartbeat.sh's convention): it never falls through to .env.
 DIR=$(dirname "$0")
-TOPIC="${NTFY_TOPIC:-$(grep -m1 '^NTFY_TOPIC=' "$DIR/../.env" 2>/dev/null | cut -d= -f2)}"
-[ -z "$TOPIC" ] && exit 0
-curl -sS --max-time 10 \
+if [ "${NTFY_TOPIC+set}" = "set" ]; then TOPIC="$NTFY_TOPIC"
+else TOPIC="$(grep -m1 '^NTFY_TOPIC=' "$DIR/../.env" 2>/dev/null | cut -d= -f2)"; fi
+[ -z "$TOPIC" ] && exit 2
+curl -sS --fail --max-time 10 \
   -H "Title: ${1:-RuvNet Brain}" \
   -H "Priority: ${3:-default}" \
   -H "Tags: ${4:-brain}" \
-  -d "${2:-（no message)}" \
-  "https://ntfy.sh/$TOPIC" >/dev/null 2>&1 || true
+  -d "${2:-(no message)}" \
+  "${NTFY_URL:-https://ntfy.sh}/$TOPIC" >/dev/null 2>&1 || exit 1
+exit 0

package/scripts/ntfy-inbox.mjs

@@ -23,6 +23,7 @@ import { setTimeout as sleep } from 'node:timers/promises';
 import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { isPersonIssue, judgeIssue } from './issue-watch.mjs';
+import { isDirectInvocation } from '../plugin/scripts/entrypoint.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
 const REPO = 'stuinfla/ruvnet-brain';
@@ -61,14 +62,27 @@ export function classify(msg) {
   let m;
   // job-heartbeat.sh pages "SCHEDULED JOB FAILED: X" / "Recovered: X"; nightly-watchdog.mjs pages "🔴 <STATE>: X" /
   // "✅ X is healthy again". Same cause, same key, so either recovery closes either failure.
-  if ((m = /SCHEDULED JOB FAILED: (\S+)/.exec(title)) || (m = /^\W*(?:FAILING|NEVER-RAN|STALE|MISSING|STALLED): (\S+)/.exec(title))) return { kind: 'job', key: `job:${m[1]}`, label: m[1], actionable: true };
+  if ((m = /SCHEDULED JOB FAILED: (\S+)/.exec(title)) || (m = /^\W*(?:FAILING|NEVER-RAN|STALE|MISSING|STALLED|STUCK): (\S+)/.exec(title))) return { kind: 'job', key: `job:${m[1]}`, label: m[1], actionable: true };
   if ((m = /Recovered: (\S+)/.exec(title)) || (m = /^\W*(\S+) is healthy again/.exec(title))) return { kind: 'job-recovered', key: `job:${m[1]}`, label: m[1], actionable: false, resolves: true };
   if ((m = /CI \w+: (.+)$/.exec(title))) {
     const b = /branch ([\w./-]{1,100})/.exec(body);
     // Keyed by workflow AND branch: a green main must never close a still-red release branch (review round 4).
     return { kind: 'ci', key: `ci:${m[1].trim()}@${b ? b[1] : 'main'}`, workflow: m[1].trim(), ...(b ? { branch: b[1] } : {}), actionable: true };
   }
-  if ((m = /(?:New issue|SLA breach: issue) #(\d+)/.exec(title))) return { kind: 'issue', key: `issue:${m[1]}`, number: Number(m[1]), actionable: true };
+  if ((m = /(?:New issue|SLA breach: issue) #(\d+)/.exec(title))) {
+    // ONE combined SLA page names every breaching issue (scripts/issue-watch.mjs: a "#N (age) title" line each, and
+    // "…and K more: #a #b" past 8). Each named issue is its own alert, so a 17-issue breach counts 17, not 1.
+    const numbers = [Number(m[1])];
+    if (/^SLA breach/.test(title)) {
+      for (const line of body.split('\n')) {
+        const listed = /^#(\d+) \(/.exec(line);
+        if (listed) numbers.push(Number(listed[1]));
+        else if (/^…and \d+ more:/.test(line)) for (const x of line.matchAll(/#(\d+)/g)) numbers.push(Number(x[1]));
+      }
+    }
+    const unique = [...new Set(numbers.filter((n) => Number.isSafeInteger(n) && n > 0))].slice(0, MAX_OPEN_ALERTS);
+    return { kind: 'issue', key: `issue:${unique[0]}`, number: unique[0], actionable: true, ...(unique.length > 1 ? { numbers: unique } : {}) };
+  }
   if ((m = /New PR #(\d+)/.exec(title))) return { kind: 'pr', key: `pr:${m[1]}`, number: Number(m[1]), actionable: true };
   if (/^Waiting on a reply/.test(title)) return { kind: 'digest', key: 'digest:issues', actionable: false };
   if (/New star/.test(title)) return { kind: 'info', key: `info:${msg.id}`, actionable: false };
@@ -115,23 +129,32 @@ export function fold(open, messages, { now = Date.now(), resolver = resolvedNow,
   for (const msg of messages) {
     if (!msg || typeof msg.id !== 'string' || folded.has(msg.id)) continue;
     folded.add(msg.id);
-    const c = classify(msg);
+    const classified = classify(msg);
     const at = new Date((msg.time || now / 1000) * 1000).toISOString();
-    if (c.resolves) {
-      const a = byKey.get(c.key);
-      if (a && !a.closedAt && Date.parse(at) >= Date.parse(a.lastAt) && resolver(a)) { a.closedAt = at; a.closedBy = 'recovered notice (confirmed)'; a.closedByMsg = msg.id; }
-      continue;
-    }
-    if (!c.actionable) continue;
-    const existing = byKey.get(c.key);
-    if (existing && !existing.closedAt) {
-      // lastAt only moves forward: a delayed older message must not make a newer failure look resolved.
-      existing.count += 1;
-      if (Date.parse(at) > Date.parse(existing.lastAt)) { existing.lastAt = at; existing.lastTitle = msg.title; }
-      existing.msgIds = [...(existing.msgIds || []), msg.id].slice(-10);
-      continue;
+    // A combined SLA page becomes one alert per issue it names; the first keeps the message id, the rest get id-N.
+    const parts = classified.numbers ? classified.numbers.map((n, i) => {
+      const one = { ...classified, key: `issue:${n}`, number: n, alertId: i === 0 ? msg.id : `${msg.id}-${n}` };
+      delete one.numbers;
+      return one;
+    }) : [classified];
+    for (const c of parts) {
+      if (c.resolves) {
+        const a = byKey.get(c.key);
+        if (a && !a.closedAt && Date.parse(at) >= Date.parse(a.lastAt) && resolver(a)) { a.closedAt = at; a.closedBy = 'recovered notice (confirmed)'; a.closedByMsg = msg.id; }
+        continue;
+      }
+      if (!c.actionable) continue;
+      const existing = byKey.get(c.key);
+      if (existing && !existing.closedAt) {
+        // lastAt only moves forward: a delayed older message must not make a newer failure look resolved.
+        existing.count += 1;
+        if (Date.parse(at) > Date.parse(existing.lastAt)) { existing.lastAt = at; existing.lastTitle = msg.title; }
+        existing.msgIds = [...(existing.msgIds || []), msg.id].slice(-10);
+        continue;
+      }
+      const { alertId, ...fields } = c;
+      byKey.set(c.key, { id: alertId || msg.id, ...fields, firstAt: at, lastAt: at, count: 1, title: msg.title || '', body: String(msg.message || '').slice(0, 200), msgIds: [msg.id], attempts: 0 });
     }
-    byKey.set(c.key, { id: msg.id, ...c, firstAt: at, lastAt: at, count: 1, title: msg.title || '', body: String(msg.message || '').slice(0, 200), msgIds: [msg.id], attempts: 0 });
   }
   const byOldestCheck = [...byKey.values()].sort((x, y) => Date.parse(x.lastCheckedAt || 0) - Date.parse(y.lastCheckedAt || 0));
   for (const a of byOldestCheck) {
@@ -506,7 +529,7 @@ export function formatOpen(alerts) {
     + `${a.count > 1 ? `  (×${a.count}, since ${clean(a.firstAt, 30)})` : ''}\n    ${clean(String(a.body || '').split('\n')[0], 160)}`).join('\n') + tail;
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+if (isDirectInvocation(import.meta.url)) {
   const args = process.argv.slice(2);
   try {
     if (args[0] === '--open') {

package/scripts/onboarding-console.mjs

@@ -64,7 +64,7 @@ import {
 } from '../kb/brain-profile.mjs';
 // Lessons: read model + the two user verbs. Every mutation goes through lesson-store's own
 // updateLessons/ratify/demote/restore — this file adds a SURFACE, never a second writer.
-import { loadLessons, updateLessons, ratify, demote, restore, pending, weightOf, TRIGGERS, ENFORCEMENT, ORIGIN, SOURCE_CLASS, STATUS } from './lesson-store.mjs';
+import { loadLessons, lessonApplies, projectNameFor, STORE_PATH as LESSON_STORE_PATH, updateLessons, ratify, demote, restore, pending, weightOf, TRIGGERS, ENFORCEMENT, ORIGIN, SOURCE_CLASS, STATUS } from './lesson-store.mjs';
 import {
   openRouterCredentialStatus,
   saveOpenRouterCredential,
@@ -430,8 +430,31 @@ function wiringSurvey() {
 }
 
 // ── Memory health (read-only probes for the project the console was launched from) ────────────────
+// Dream Cycle 2026-09-18 (memory-durability, round-trip-proof): this used to also pass on ANY
+// `.claude/hooks` directory existing, so a machine whose hooks folder holds only an unrelated
+// script (a different plugin, a stale leftover) scored `sessionSurfacing: ok` and printed "the
+// global SessionStart hook surfaces project state at launch" — a claim about a hook that was never
+// installed. Only the specific recall hook's presence can support that claim.
+//
+// Dream Cycle 2026-09-19 (memory-durability, managed-boundary): the fix above still checked only
+// the LEGACY standalone `agentdb-ensure.sh` global hook. It ignored the mechanism this very repo
+// ships and documents as the automatic one — `plugin/hooks/hooks.json`'s own SessionStart entry,
+// which every session restores via `project-progression-session-start.mjs` (wired through
+// `session-start-core.mjs`) whenever the `ruvnet-brain` plugin itself is enabled. A machine that
+// installed this plugin the real, current way (Claude Code's marketplace flow) and never separately
+// placed the legacy global shell hook scored `sessionSurfacing: warn` — a false negative, flagged
+// as an open scope question by PR #296's independent critic, not chased there to keep that change
+// to one conceptual fix. `pluginEnabled()` mirrors the exact `k.startsWith('ruvnet-brain@')` check
+// `capability-registry.mjs`'s `wiredForRoute()` already uses for the same "is our plugin the one
+// Claude Code will actually load" question, rather than re-deriving a second way to ask it.
+function pluginEnabled() {
+  const settings = readJSON(path.join(CONSOLE_ROOT, '.claude', 'settings.json'));
+  return Object.entries(settings?.enabledPlugins || {}).some(([k, v]) => k.startsWith('ruvnet-brain@') && v === true);
+}
 function sessionHookExists() {
-  return fs.existsSync(path.join(CONSOLE_ROOT, '.claude/hooks/agentdb-ensure.sh')) || fs.existsSync(path.join(CONSOLE_ROOT, '.claude/hooks'));
+  if (fs.existsSync(path.join(CONSOLE_ROOT, '.claude/hooks/agentdb-ensure.sh'))) return 'agentdb-ensure';
+  if (pluginEnabled()) return 'ruvnet-brain-plugin';
+  return null;
 }
 // WHICH FILE IS THE PROJECT'S MEMORY STORE IS NOT A CONSTANT (issue #127).
 //
@@ -496,7 +519,12 @@ function probeMemory(projectDir, { now = Date.now() } = {}) {
   // Compaction survival is a ruflo write at PreCompact (project-state-auto-* + exact readback); a refusal
   // reaches the hook-failures summary. It is not re-probed at render.
   probes.compactionSurvival = { status: 'notTested', detail: 'PreCompact stores a project-state-auto-* checkpoint through ruflo and reads it back; failures appear in the SessionStart hook-failures summary' };
-  probes.sessionSurfacing = sessionHookExists() ? { status: 'ok', detail: 'the global SessionStart hook surfaces project state at launch' } : { status: 'warn', detail: 'no SessionStart recall hook found' };
+  const sessionHookVia = sessionHookExists();
+  probes.sessionSurfacing = sessionHookVia === 'agentdb-ensure'
+    ? { status: 'ok', detail: 'the global SessionStart hook surfaces project state at launch', via: sessionHookVia }
+    : sessionHookVia === 'ruvnet-brain-plugin'
+      ? { status: 'ok', detail: 'the ruvnet-brain plugin\'s own SessionStart hook surfaces project state at launch', via: sessionHookVia }
+      : { status: 'warn', detail: 'no SessionStart recall hook found', via: null };
   // recall quality: honestly NOT probed at render (a true probe needs an embedding query; left for an explicit deep test)
   probes.recallQuality = { status: 'notTested', detail: 'not checked this session — a real recall probe needs an embedding round-trip, which render deliberately avoids' };
 
@@ -1373,6 +1401,8 @@ function setLesson(body) {
 // --refresh-cache child. A request never scans — not inline on a first-ever run, and not via
 // setImmediate either (deferring synchronous work still blocks the loop when it runs). A machine with
 // no fleet scan yet is reported `warming`, never as a fabricated zero.
+// #500: bump when the meaning of the cached fleet changes. 2 = one entry per resolved store; 3 = + stable `id`.
+const ACTIVITY_CACHE_SCHEMA = 3; // 3 = each project also carries `id`, the store's dev:inode identity
 let ACTIVITY_MACHINE_CACHE = null;
 const CONSOLE_CACHE_PATH = path.join(CONSOLE_ROOT, '.cache/ruvnet-brain/console-cache.json');
 
@@ -1834,7 +1864,9 @@ function loadConsoleCache() {
   let restored = false;
   try {
     const j = JSON.parse(fs.readFileSync(CONSOLE_CACHE_PATH, 'utf8'));
-    if (j.activity && j.activity.at) { ACTIVITY_MACHINE_CACHE = j.activity; restored = true; }
+    // #500: a cache written before the fleet scan deduped by store identity can hold one database
+    // counted twice (a nested docs/adr/.swarm beside its parent). Never trust it — re-measure.
+    if (j.activity && j.activity.at && j.activity.schema === ACTIVITY_CACHE_SCHEMA) { ACTIVITY_MACHINE_CACHE = j.activity; restored = true; }
     if (j.trust && j.trust.at) { TRUST_CACHE = j.trust; restored = true; }
   } catch { /* no cache yet — first ever boot */ }
   return restored;
@@ -1868,7 +1900,7 @@ function saveConsoleCache() {
 function adoptFleetFromDisk() {
   try {
     const j = readJSON(CONSOLE_CACHE_PATH);
-    if (j && j.activity && j.activity.at && (!ACTIVITY_MACHINE_CACHE || j.activity.at > ACTIVITY_MACHINE_CACHE.at)) {
+    if (j && j.activity && j.activity.at && j.activity.schema === ACTIVITY_CACHE_SCHEMA && (!ACTIVITY_MACHINE_CACHE || j.activity.at > ACTIVITY_MACHINE_CACHE.at)) {
       ACTIVITY_MACHINE_CACHE = j.activity;
     }
   } catch { /* no cache yet — the caller kicks a child and reports `warming` */ }
@@ -1884,8 +1916,10 @@ function refreshFleetCache() {
       // pathIdentity, not path.resolve: resolve() normalises `.`/`..` and nothing else, so a project
       // reached through a symlink OR through the other capitalisation of a case-insensitive volume
       // was two distinct strings for one directory, and its memories were summed twice (#107).
-      const resolved = pathIdentity(s.project) ?? path.resolve(s.project);
-      if (seen.has(resolved)) continue; // a project visible under two roots counts once
+      // #500: dedupe on the DATABASE, which is what holds the memories. Two directories (a repo and its
+      // nested docs/adr/.swarm, or a linked worktree) can resolve to one store; project paths differ.
+      const resolved = pathIdentity(s.db) ?? path.resolve(s.db);
+      if (seen.has(resolved)) continue; // a store visible twice counts once
       seen.add(resolved);
       const n = Number(robustRead(s.db, "SELECT COUNT(*) FROM memory_entries WHERE status='active'").value || 0);
       if (n > 0) {
@@ -1894,17 +1928,25 @@ function refreshFleetCache() {
         const lastTouched = Number(robustRead(s.db, 'SELECT MAX(updated_at) FROM memory_entries').value || 0);
         // rel = the root-relative path — the SAME key reconcile:<id> recommendations use (wiringSurvey
         // computes projName the same way, relative to whichever root the project was found under).
-        projects.push({ name: path.basename(s.project), rel: path.relative(root, s.project), memories: n, lastTouched });
+        // Name from the RESOLVED project root. A linked worktree whose main checkout lies outside this
+        // scan root would give a '..'-prefixed rel, but reconcile:<id> keys (wiringSurvey) are relative to
+        // the directory found under the root — so fall back to the found directory in that case.
+        const inRoot = path.relative(root, s.project);
+        const rel = (inRoot === '' || inRoot.startsWith('..') || path.isAbsolute(inRoot)) ? path.relative(root, s.found || s.project) : inRoot;
+        // `id` = the store's own dev:inode identity (pathIdentity follows symlinks and sees hard links), so a
+        // client can tell WHICH project is "you" without comparing folder names (two repos can share one).
+        projects.push({ id: resolved, name: path.basename(s.project), rel, memories: n, lastTouched });
         total += n;
       }
     }
   }
   projects.sort((a, b) => b.memories - a.memories);
-  ACTIVITY_MACHINE_CACHE = { at: Date.now(), projects, totalMemories: total };
+  ACTIVITY_MACHINE_CACHE = { schema: ACTIVITY_CACHE_SCHEMA, at: Date.now(), projects, totalMemories: total };
   saveConsoleCache();
 }
-function findMemoryStores(root) {
+export function findMemoryStores(root) {
   const out = [];
+  const seenDb = new Set();
   const walk = (dir, depth) => {
     if (depth > 3) return;
     let ents; try { ents = fs.readdirSync(dir, { withFileTypes: true }); } catch { return; }
@@ -1916,8 +1958,12 @@ function findMemoryStores(root) {
         // Fleet activity is project memory, so resolve the canonical store rather than selecting a
         // coordination database by size. The latter is diagnostic-only and can contain unrelated rows.
         try {
-          const resolved = resolveProjectStore({ projectDir: dir }).canonicalAgentDbPath;
-          if (fs.existsSync(resolved)) out.push({ project: dir, db: resolved });
+          const store = resolveProjectStore({ projectDir: dir });
+          const resolved = store.canonicalAgentDbPath;
+          // #500: record the RESOLVED project root and one entry per database. A nested docs/adr/.swarm
+          // resolves to its parent's store; recording `dir` listed that one database twice.
+          const id = pathIdentity(resolved) ?? path.resolve(resolved);
+          if (fs.existsSync(resolved) && !seenDb.has(id)) { seenDb.add(id); out.push({ project: store.projectRoot, found: dir, db: resolved }); }
         } catch { /* an unresolvable directory is not a project store */ }
         continue;
       }
@@ -1928,6 +1974,38 @@ function findMemoryStores(root) {
   walk(root, 0);
   return out;
 }
+// #499: approved lessons are the ratified rules in the lesson store (the SAME active rule as
+// gatherLessons().counts.active). `available:false` means the store could not be read — unknown, never 0.
+//   count      = machine-wide (every ratified/active, non-demoted lesson)
+//   applicable = the subset that applies to THIS project, by the SAME rule plugin/scripts/lesson-gate.mjs
+//                uses (lesson-store.lessonApplies): unscoped, or scoped to this project, or proven in >=2 projects.
+//   items      = per-lesson id/title/scope/enforcement/status for the applicable ones, bounded (the metadata
+//                the reporter asked to keep), `itemsTruncated` says when the bound cut the list.
+const APPROVED_ITEMS_MAX = 25;
+function approvedLessonsFigure(here) {
+  try {
+    // loadLessons() swallows a parse failure and returns [] — which would read as "0 approved". A file
+    // that exists but does not parse is UNKNOWN; only an absent file is a true zero.
+    if (fs.existsSync(LESSON_STORE_PATH)) JSON.parse(fs.readFileSync(LESSON_STORE_PATH, 'utf8'));
+    const approved = loadLessons().filter((l) => (l.status === STATUS.RATIFIED || l.status === STATUS.ACTIVE) && !l.demoted);
+    const mine = approved.filter((l) => lessonApplies(l, here)); // the gate's own rule (lesson-store.lessonApplies)
+    const items = mine.slice(0, APPROVED_ITEMS_MAX).map((l) => {
+      const ps = Array.isArray(l.projects) ? l.projects : [];
+      const text = String(l.statement || '');
+      return { id: l.id, title: text.length > 140 ? `${text.slice(0, 139)}…` : text,
+        scope: ps.length ? ps.join(', ') : 'all projects', enforcement: l.enforcement ?? null,
+        ratified: l.status === STATUS.RATIFIED || l.status === STATUS.ACTIVE, status: l.status };
+    });
+    return { available: true, count: approved.length, applicable: mine.length, items, itemsTruncated: mine.length > items.length };
+  } catch { return { available: false, count: null, applicable: null, items: [], itemsTruncated: false }; }
+}
+// #499: a count that could not be read is null, not 0 — "0" would claim the store is empty.
+function readCount(db, sql) {
+  const r = robustRead(db, sql);
+  if (!r.ok) return null;
+  const n = Number(r.value ?? 0);
+  return Number.isFinite(n) ? n : null;
+}
 function gatherActivity(cwd) {
   let project;
   let db;
@@ -1937,19 +2015,27 @@ function gatherActivity(cwd) {
     db = resolved.canonicalAgentDbPath;
   } catch {
     const measuredAt = new Date().toISOString();
-    return { generatedAt: measuredAt, project: path.basename(cwd), hasStore: false, continuity: 'unavailable', ...freshnessOf(measuredAt) };
+    return { generatedAt: measuredAt, project: path.basename(cwd), hasStore: false, continuity: 'unavailable', approvedLessons: approvedLessonsFigure(projectNameFor(cwd)), ...freshnessOf(measuredAt) };
   }
   if (!fs.existsSync(db)) {
     // No store to read — the existence check above IS the entire measurement, so it IS the
     // observation instant. Stamped here, not with a value taken before the check ran.
     const measuredAt = new Date().toISOString();
-    return { generatedAt: measuredAt, project: path.basename(project), hasStore: false, ...freshnessOf(measuredAt) };
+    return { generatedAt: measuredAt, project: path.basename(project), hasStore: false, approvedLessons: approvedLessonsFigure(path.basename(project)), ...freshnessOf(measuredAt) };
   }
-  const out = { project: path.basename(project), hasStore: true };
+  // projectId = the same dev:inode identity the fleet entries carry, so the client matches on identity, not the folder name.
+  const out = { project: path.basename(project), projectId: pathIdentity(db) ?? path.resolve(db), hasStore: true, approvedLessons: approvedLessonsFigure(path.basename(project)) };
   const rows = (sql) => robustReadJSON(db, sql).rows;
+  const agentdbLessons = readCount(db, "SELECT COUNT(*) FROM memory_entries WHERE namespace='lessons' AND status='active'");
   out.totals = {
-    memories: Number(robustRead(db, "SELECT COUNT(*) FROM memory_entries WHERE status='active'").value || 0),
-    lessons: Number(robustRead(db, "SELECT COUNT(*) FROM memory_entries WHERE namespace='lessons' AND status='active'").value || 0),
+    memories: readCount(db, "SELECT COUNT(*) FROM memory_entries WHERE status='active'"),
+    agentdbLessons,
+    lessons: agentdbLessons, // legacy alias of agentdbLessons
+    // #499: the learning pipeline's OWN measurements (null = unreadable, shown as Unknown, never 0). Distillation
+    // writes patterns/episodes, never `lessons` rows; observations are the namespace it mines.
+    observations: readCount(db, "SELECT COUNT(*) FROM memory_entries WHERE namespace='learning-observations' AND status='active'"),
+    patterns: readCount(db, 'SELECT COUNT(*) FROM reasoning_patterns'),
+    episodes: readCount(db, 'SELECT COUNT(*) FROM episodes'),
   };
   out.lessons = rows("SELECT key, access_count, date(created_at/1000,'unixepoch') AS learned, substr(content,1,600) AS excerpt FROM memory_entries WHERE namespace='lessons' AND status='active' ORDER BY created_at DESC");
   out.recent = rows("SELECT key, namespace, type, datetime(updated_at/1000,'unixepoch','localtime') AS at FROM memory_entries WHERE status='active' ORDER BY updated_at DESC LIMIT 18");
@@ -2613,12 +2699,8 @@ function apply(ids) {
     } : {});
     if (res.ok && learningBefore) {
       const after = observeLearning();
-      // `ruflo memory distill run` owns the patterns; progress here is a known, readable learner afterwards.
-      const progressed = learningBefore.statusKnown && after.statusKnown;
-      if (!progressed) {
-        res.ok = false;
-        res.log += `\nNo measured learning progress: queue ${after.queueDir}; learner ${after.learnerCwd}. Reload to inspect the remaining evidence.`;
-      }
+      res.ok = learningProgressed(learningBefore, after);
+      if (!res.ok) res.log += `\nNo measured learning progress: ${learningProgressDetail(learningBefore, after)}. Reload to inspect the remaining evidence.`;
     }
     phaseMs.childRemedyMs += elapsedMs(remedyStartedAt);
     results.push({ id, ...res, undoToken });
@@ -2628,6 +2710,21 @@ function apply(ids) {
   return { results, timings: { ...phaseMs, totalMs: elapsedMs(startedAt) } };
 }
 
+/**
+ * #377: Apply on "Your learner has gone quiet" counts as progress only when `ruflo memory distill
+ * status` shows the learner's last distillation moved FORWARD. A readable store alone is not progress.
+ */
+export function learningProgressed(before, after) {
+  const was = Date.parse(before?.lastDistillAt || '');
+  const now = Date.parse(after?.lastDistillAt || '');
+  return !!(before?.statusKnown && after?.statusKnown && after.distillKnown === true
+    && Number.isFinite(now) && (!Number.isFinite(was) || now > was));
+}
+export function learningProgressDetail(before, after) {
+  return `learner ${after?.learningDb || before?.learningDb || 'unresolved'}; last distillation `
+    + `${before?.lastDistillAt || 'not recorded'} → ${after?.distillKnown === true ? (after.lastDistillAt || 'not recorded') : 'unknown'}`;
+}
+
 function autoEligibleIds(recommendations = []) {
   return recommendations
     .filter((rec) => rec?.scope === 'project')
@@ -3511,6 +3608,9 @@ export {
   saveBrainProfile,
   setLesson,
   gatherLessons,
+  gatherActivity,
+  refreshFleetCache,
+  loadConsoleCache,
   gatherRouterEngine,
   autoEligibleIds,
   gatherConfig,

package/scripts/oracle/abstain-threshold-sweep.mjs

@@ -20,6 +20,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { wilson } from '../eval-brain.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 const rate = (k, n) => { const w = wilson(k, n); return { k, n, p: +w.p.toFixed(4), lo: +w.lo.toFixed(4), hi: +w.hi.toFixed(4) }; };
 const within5 = (r) => (r.fileRank != null && r.fileRank <= 5) || (r.altFileRank != null && r.altFileRank <= 5);
@@ -59,4 +60,4 @@ async function main() {
   }
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();
+if (isDirectInvocation(import.meta.url)) await main();

package/scripts/oracle/abstain-trace.mjs

@@ -28,6 +28,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import readline from 'node:readline';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 const args = process.argv.slice(2);
 const arg = (n, d) => { const i = args.indexOf(n); return i >= 0 ? args[i + 1] : d; };
@@ -136,4 +137,4 @@ async function main() {
   process.exit(0);
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();
+if (isDirectInvocation(import.meta.url)) await main();

package/scripts/oracle/doc2query-generate.mjs

@@ -23,6 +23,7 @@ import os from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { claudeArgs, spawnHost, isQuotaRefusal } from './producer-hosts.mjs';
 import { subscriptionOnlyEnv } from '../subscription-hosts.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 export const EXCERPT_CHARS = 1500;
 export const D2Q_SCHEMA = Object.freeze({
@@ -159,4 +160,4 @@ async function main() {
   console.log(JSON.stringify({ files: docs.length, written, stopped: stop }));
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();
+if (isDirectInvocation(import.meta.url)) await main();

package/scripts/oracle/doc2query-reach.mjs

@@ -22,6 +22,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { wilson } from '../eval-brain.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 /** Collapse ranked entry hits (each pointing at a file) to the first `files` distinct files. */
 export function filesFromEntries(hits, pathOfId, files) {
@@ -107,4 +108,4 @@ async function main() {
   process.exit(0);
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();
+if (isDirectInvocation(import.meta.url)) await main();

package/scripts/oracle/judge-train.mjs

@@ -21,6 +21,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { wilson } from '../eval-brain.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 const { JUDGE_FEATURES, judgeFeatures, judgeLogit } = await import(pathToFileURL(path.join(ROOT, 'kb/judge-rank.mjs')).href);
@@ -155,4 +156,4 @@ async function main() {
   console.log(JSON.stringify({ threshold: tau, trainedOn: model.trainedOn, heldout: report.heldout }, null, 1));
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();
+if (isDirectInvocation(import.meta.url)) await main();

package/scripts/oracle/need-set-split.mjs

@@ -13,6 +13,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 export function splitNeedSet(questions, { salt = 'v1', trainFraction = 0.5 } = {}) {
   const byRepo = new Map();
@@ -45,4 +46,4 @@ async function main() {
   console.log(JSON.stringify({ train: split.train.length, heldout: split.heldout.length, contentHash: set.contentHash }));
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();
+if (isDirectInvocation(import.meta.url)) await main();

package/scripts/oracle/produce-questions.mjs

@@ -34,6 +34,7 @@ import {
   DEFAULT_ROLES, LABEL_SCHEMA, PRODUCER_MODELS, VERDICT_SCHEMA, generatorPrompt, hostAdapters, isQuotaRefusal,
   judgePrompt, spawnHost,
 } from './producer-hosts.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 export {
   CLAUDE_SYSTEM_PROMPT, CLAUDE_TIMEOUT_MS, CODEX_TIMEOUT_MS, DEFAULT_ROLES, JUDGE_SYSTEM_PROMPT, LABEL_SCHEMA,
@@ -275,19 +276,4 @@ export async function main(argv = process.argv.slice(2)) {
   return labels.suspended ? 75 : 0;
 }
 
-// Entry-point guard. Compares REALPATHS on both sides: path.resolve() normalizes a path but does
-// NOT follow symlinks, while import.meta.url IS symlink-resolved by Node. Through a symlink (npm bin
-// shims, wrapper scripts, and every os.tmpdir() path on macOS) the two sides disagree, so main()
-// never runs -- and because nothing throws, the process exits 0. A silent exit 0 is indistinguishable
-// from "ran, found nothing", which is how prepareCorpusCandidate once reported SUCCESS with no
-// archive on disk. Reproduced live 2026-07-27; pinned by tests/unit/entrypoint-symlink.test.mjs.
-function isDirectInvocation() {
-  try {
-    if (!process.argv[1]) return false;
-    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
-  } catch {
-    return false;
-  }
-}
-
-if (isDirectInvocation()) process.exitCode = await main();
+if (isDirectInvocation(import.meta.url)) process.exitCode = await main();

package/scripts/oracle/repo-recall.mjs

@@ -36,6 +36,7 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import { extractZip } from '../../kb/zip-extract.mjs';
 import { validateCoverageLedger } from '../coverage-integrity.mjs';
 import { retiredFixtureStores } from '../fixture-denominator.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
 
@@ -556,8 +557,7 @@ export async function main(argv = process.argv.slice(2), { searchAll = null } =
 // archive on disk (measured 2026-09-14).
 function isMain() {
   try {
-    if (!process.argv[1]) return false;
-    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+    return isDirectInvocation(import.meta.url);
   } catch { return false; }
 }
 

package/scripts/oracle/retrieval-accuracy.mjs

@@ -54,6 +54,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { extractZip } from '../../kb/zip-extract.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(HERE, '..', '..');
@@ -871,8 +872,7 @@ export async function main(argv = process.argv.slice(2)) {
 // with no archive and no receipt on disk. Same defect, same fix as plugin/scripts/hook-input.mjs:518.
 function isMain() {
   try {
-    if (!process.argv[1]) return false;
-    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
+    return isDirectInvocation(import.meta.url);
   } catch {
     return false;
   }

package/scripts/oracle/sona-query-adapter-eval.mjs

@@ -22,6 +22,7 @@ import path from 'node:path';
 import { createRequire } from 'node:module';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { wilson } from '../eval-brain.mjs';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 /** Rank (1-based) of the first hit whose path is `gold`, or null within the list. */
 export function rankOf(paths, gold) {
@@ -136,4 +137,4 @@ async function main() {
   process.exit(0);
 }
 
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) await main();
+if (isDirectInvocation(import.meta.url)) await main();

package/scripts/oracle/source-tree.mjs

@@ -20,6 +20,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 export const SOURCE_TREE_VERSION = 'oracle-source-tree/1';
 export const LFS_POINTER_PREFIX = 'version https://git-lfs.github.com/spec/v1';
@@ -148,18 +149,4 @@ export function main(argv = process.argv.slice(2)) {
   return 0;
 }
 
-// Entry-point guard. Compares REALPATHS on both sides: path.resolve() normalizes a path but does
-// NOT follow symlinks, while import.meta.url IS symlink-resolved by Node. Through a symlink (npm bin
-// shims, wrapper scripts, and every os.tmpdir() path on macOS) the two sides disagree, so main()
-// never runs -- and because nothing throws, the process exits 0. Pinned by
-// tests/unit/entrypoint-symlink.test.mjs.
-function isDirectInvocation() {
-  try {
-    if (!process.argv[1]) return false;
-    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
-  } catch {
-    return false;
-  }
-}
-
-if (isDirectInvocation()) process.exitCode = main();
+if (isDirectInvocation(import.meta.url)) process.exitCode = main();

package/scripts/oracle/source-units.mjs

@@ -25,6 +25,7 @@ import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { parse as babelParse } from '@babel/parser';
+import { isDirectInvocation } from '../../plugin/scripts/entrypoint.mjs';
 
 export const RULES_VERSION = 'oracle-source-units/1';
 export const MAX_SELECTED = 100;
@@ -373,19 +374,4 @@ export function main(argv = process.argv.slice(2)) {
   return 0;
 }
 
-// Entry-point guard. Compares REALPATHS on both sides: path.resolve() normalizes a path but does
-// NOT follow symlinks, while import.meta.url IS symlink-resolved by Node. Through a symlink (npm bin
-// shims, wrapper scripts, and every os.tmpdir() path on macOS) the two sides disagree, so main()
-// never runs -- and because nothing throws, the process exits 0. A silent exit 0 is indistinguishable
-// from "ran, found nothing", which is how prepareCorpusCandidate once reported SUCCESS with no
-// archive on disk. Reproduced live 2026-07-27; pinned by tests/unit/entrypoint-symlink.test.mjs.
-function isDirectInvocation() {
-  try {
-    if (!process.argv[1]) return false;
-    return fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url));
-  } catch {
-    return false;
-  }
-}
-
-if (isDirectInvocation()) process.exitCode = main();
+if (isDirectInvocation(import.meta.url)) process.exitCode = main();