ruvnet-brain 4.6.4 → 4.7.1

package/plugin/host-adapters/grok.json

@@ -0,0 +1,11 @@
+{
+  "schemaVersion": 1,
+  "kind": "ruvnet-brain-host-adapter",
+  "id": "grok",
+  "displayName": "Grok CLI",
+  "os": ["linux", "macos", "windows"],
+  "modes": [],
+  "manifest": "plugin/.grok-plugin/plugin.json",
+  "hooks": "plugin/hooks/grok-hooks.json",
+  "loader": "plugin/scripts/grok-hook-adapter.mjs"
+}

package/plugin/mcp/managed-cli-interface.mjs

@@ -7,9 +7,6 @@ import { managedGenerationIdentity } from './managed-cli-generation.mjs';
 import { loadRuntimePreferences, runtimeChildEnv } from '../scripts/runtime-preferences.mjs';
 import { projectDirectory } from '../scripts/project-identity.mjs';
 import { recordManagedCliObservation, recordRegistryLatestObservation } from '../scripts/capability-claim-evidence.mjs';
-import { runSessionSnapshotHook } from '../scripts/session-snapshot-hook.mjs';
-import { resolveProjectStore } from '../scripts/project-store-resolver.mjs';
-import { isAutomaticProgressionSuspension } from '../scripts/project-progression-suspension.mjs';
 
 export const MANAGED_EXECUTABLES = Object.freeze([
   'ruflo',
@@ -275,40 +272,6 @@ export function normalizeManagedExecution(execution) {
   return { outcome: execution.code === 0 ? 'success' : 'failure', output, contradictoryFailure };
 }
 
-function managedSessionId(env) {
-  const supplied = env.RUVNET_BRAIN_SESSION_ID || env.RUVNET_HOOK_SESSION_ID;
-  return typeof supplied === 'string' && supplied.trim() ? supplied.trim() : `managed-cli-${process.pid}`;
-}
-
-/** Bind managed CLI execution to the existing progression writer when this project has adopted it. */
-function managedProgressionCapture({ executable, argv, projectRoot, env, event, execution, normalized }) {
-  const adopted = fs.existsSync(path.join(projectRoot, '.swarm'));
-  if (!adopted) return { adopted: false, skipped: 'project has not adopted the canonical store' };
-  const host = String(env.RUVNET_HOOK_HOST || '').toLowerCase();
-  if (!['claude', 'codex'].includes(host)) return { adopted: true, error: 'managed host identity unavailable' };
-  let resolution;
-  try { resolution = resolveProjectStore({ projectDir: projectRoot }); }
-  catch (error) { return { adopted: true, error: `project store could not be resolved: ${error?.message || error}` }; }
-  const payload = {
-    session_id: managedSessionId(env),
-    hook_event_name: event,
-    tool_name: executable,
-    tool_input: { command: [executable, ...argv].join(' ') },
-    ...(execution ? {
-      tool_response: {
-        stdout: execution.stdout,
-        stderr: execution.stderr,
-        exit_code: execution.code,
-        ...(execution.signal ? { signal: execution.signal, interrupted: true } : {}),
-        outcome: normalized?.outcome,
-        ...(execution.error ? { error: execution.error } : {}),
-      },
-    } : {}),
-  };
-  const result = runSessionSnapshotHook(projectRoot, event, { rawInput: JSON.stringify(payload), host, env });
-  return isAutomaticProgressionSuspension(result) ? result : { adopted: true, ...result };
-}
-
 function resultOf(executable, argv, result) {
   const output = [result.stdout, result.stderr].filter(Boolean).join(result.stdout && result.stderr ? '\n' : '');
   const normalized = normalizeManagedExecution(result);
@@ -406,35 +369,16 @@ export async function callManagedCli(toolName, args, env = process.env, fetchImp
       const childEnv = (executable === 'agentic-flow' || executable === 'agentic-qe')
         ? runtimeChildEnv({ env, cwd: projectRoot })
         : env;
-      const capture = typeof lifecycle.capture === 'function' ? lifecycle.capture : managedProgressionCapture;
-      const beforeCapture = await capture({ executable, argv, projectRoot, env: childEnv, event: 'PreToolUse' });
-      if (beforeCapture?.error || (beforeCapture?.adopted && beforeCapture.progressionCaptured !== true
-        && !isAutomaticProgressionSuspension(beforeCapture))) {
-        const reason = beforeCapture.error || beforeCapture.skipped || 'pre-execution progression was not durably captured';
-        return { content: [{ type: 'text', text: `managed execution refused: ${reason}` }], isError: true };
-      }
       if (lifecycle && typeof lifecycle.beforeExecute === 'function') {
         await lifecycle.beforeExecute({ executable, argv, projectRoot, env: childEnv });
       }
       const execution = await execute(executable, argv, childEnv);
       const normalized = normalizeManagedExecution(execution);
-      const afterCapture = await capture({ executable, argv, projectRoot, env: childEnv, event: 'PostToolUse', execution, normalized });
       if (lifecycle && typeof lifecycle.afterExecute === 'function') {
         await lifecycle.afterExecute({ executable, argv, projectRoot, env: childEnv, execution, normalized });
       }
       recordManagedCliObservation({ toolName, executable, argv, execution, env });
-      if (afterCapture?.adopted && afterCapture.progressionCaptured !== true
-        && !isAutomaticProgressionSuspension(afterCapture)) {
-        return {
-          content: [{ type: 'text', text: `managed command ${normalized.outcome}; continuity result was not durably captured: ${afterCapture.skipped || 'unknown reason'}` }],
-          isError: true,
-        };
-      }
       const result = resultOf(executable, argv, execution);
-      if (isAutomaticProgressionSuspension(beforeCapture) || isAutomaticProgressionSuspension(afterCapture)) {
-        result.content.push({ type: 'text', text: 'Automatic project progression is operator-suspended; suspended captures produced no progression receipt. Ordinary AgentDB memory and explicit checkpoints remain available.' });
-        result.structuredContent.continuity = 'operator-suspended';
-      }
       return result;
     }
 

package/plugin/scripts/agentdb-recall-reader.mjs

@@ -1,8 +1,15 @@
-/** Bounded read-only projection of canonical Ruflo rows; never opens a second store.
- * Run as an owned child so SQLite/filesystem stalls can be retired at the recall deadline.
- * Unsupported schema stands down to global Ruflo; malformed/duplicate rows fail closed.
+/** Bounded read-only projection of canonical Ruflo rows THROUGH THE RUFLO CLI — never direct SQLite
+ * (owner ruling 2026-10-12: hooks call rUv's tools, they do not reimplement them). Run as an owned child
+ * so a stalled CLI is retired at the recall deadline. Output contract unchanged: {ok, value}.
  */
-import { withProgressionReader } from './project-progression-reader.mjs';
+import { execFile } from 'node:child_process';
+import { resolveRuflo } from './ruflo-bin.mjs';
+
+const call = (bin, args, deadline) => new Promise((resolve) => {
+  const timeout = Math.max(1, deadline - Date.now());
+  execFile(bin, args, { timeout, killSignal: 'SIGKILL', encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } },
+    (error, stdout) => resolve(error ? null : String(stdout || '')));
+});
 
 try {
   const [storePath, input] = process.argv.slice(2);
@@ -12,11 +19,24 @@ try {
       || requests.some(row => typeof row?.namespace !== 'string' || typeof row?.key !== 'string' || !row.key))
     || namespaces && (!Array.isArray(namespaces) || namespaces.length > 8 || namespaces.some(value => typeof value !== 'string'))
     || Boolean(requests) === Boolean(namespaces)) throw new Error('invalid bounded read');
-  const result = withProgressionReader(storePath, reader => requests
-    ? requests.map(({ namespace, key }) => reader.readContent(namespace, key))
-    : Object.fromEntries(namespaces.map(namespace => [namespace, reader.listKeys(namespace, { maxEntries: 100000 })])),
-  { deadlineAt: deadline });
-  process.stdout.write(JSON.stringify(result));
+  const bin = resolveRuflo();
+  if (!bin) throw new Error('global Ruflo unavailable');
+  let value;
+  if (requests) {
+    value = await Promise.all(requests.map(async ({ namespace, key }) => {
+      const out = await call(bin, ['memory', 'retrieve', '--key', key, '--namespace', namespace, '--value-only', '--path', storePath], deadline);
+      return out === null ? null : out.trim();
+    }));
+  } else {
+    const lists = await Promise.all(namespaces.map(async (namespace) => {
+      const out = await call(bin, ['memory', 'list', '--namespace', namespace, '--limit', '100000', '--format', 'json', '--path', storePath], deadline);
+      if (out === null) throw new Error('list failed');
+      const at = out.indexOf('[');
+      return [namespace, at < 0 ? [] : JSON.parse(out.slice(at)).map((row) => row.key).filter((key) => typeof key === 'string')];
+    }));
+    value = Object.fromEntries(lists);
+  }
+  process.stdout.write(JSON.stringify({ ok: true, value }));
 } catch {
   process.stdout.write(JSON.stringify({ ok: false, fatal: true }));
 }

package/plugin/scripts/agentdb-recall.mjs

@@ -12,12 +12,12 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { resolveRuflo } from './ruflo-bin.mjs';
-import { rufloCwdFor, rufloScratchRoot } from './project-progression-store.mjs';
+import { rufloCwdFor, rufloScratchRoot } from './ruflo-bin.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { isHarnessGenerated, readStdinBounded } from './hook-input.mjs';
 import { learningContext } from './runtime-preferences.mjs';
 import { learningTarget, LEARNING_NAMESPACE } from './learning-store.mjs';
-import { safeAction } from './learning-queue.mjs';
+import { safeAction } from './learn-capture.mjs';
 
 import { redactText } from './continuity-events.mjs';
 import { resolveTurnDb } from './turn-outcome-capture.mjs';
@@ -25,11 +25,16 @@ import { maskExcludedPaths } from './turn-capture-privacy.mjs';
 import { searchOnce, nativeRead, exactReads, searchJsonResult } from './agentdb-recall-process.mjs';
 import { makeLesson } from './lesson-store.mjs';
 import { supersededKeys, tombstonedKeys } from './decision-record.mjs';
+import { checkpointMs, checkpointNamespaces, newestCheckpoint } from './checkpoint-keys.mjs';
 export const STORE_FILES = Object.freeze(['memory.db']);
 export const DEFAULT_DEADLINE_MS = 1900;
 export const BLOCK_MAX_BYTES = 600;
 export const CONSEQUENTIAL_BLOCK_MAX_BYTES = 1800;
 export const MIN_RELEVANCE = 0.45;
+/** Exact-read requests one bounded reader child accepts (agentdb-recall-reader.mjs). */
+export const MAX_EXACT_READS = 32;
+
+export { checkpointMs, checkpointNamespaces, newestCheckpoint };
 
 export function recallBinding({ binding = {}, projectRoot, storePath, prompt } = {}) {
   const allowed = ['projectRoot', 'storePath', 'sessionId', 'workflowId', 'phase', 'workerId', 'requestDigest'];
@@ -140,7 +145,7 @@ export function turnOutcomeExcerpt(value, prompt) {
 /** Quote a substantive exact-value passage, including the remedy in structured lessons. */
 export function evidenceExcerpt(value, key, prompt = '') {
   const text = redactText(value);
-  if (/^project-state-current/i.test(key)) {
+  if (/^project-state-(?:current|auto)/i.test(key)) {
     // Checkpoints often lead with version/hash metadata. Quote one actual field,
     // selected by task terms, instead of spending the evidence budget on identity.
     const first = text.indexOf('{'); const last = text.lastIndexOf('}');
@@ -190,6 +195,8 @@ export function learningObservationExcerpt(raw) {
 export function pickRows(results, limit = 3) {
   const candidates = results.flatMap((r) => r.rows.filter((p) => p.namespace === r.namespace && (!NOISE_KEY.test(p.key) || p.namespace === 'turns' && /^turn[-_]/i.test(p.key) || p.namespace === 'continuity-events' && /^cevt-.*-(?:decision|lesson|open-item)-/i.test(p.key))
     && (!r.family || p.key.toLowerCase().includes(r.family))
+    // State comes only from the newest exact checkpoint read; a semantic hit on an older one is never shown.
+    && (r.family || !/^project-state-/i.test(p.key))
     && Number.isFinite(p.score) && p.score >= MIN_RELEVANCE).map((p) => ({ ...p, storePath: r.storePath, targeted: Boolean(r.family) })));
   const signal = (p) => SIGNAL_NAMESPACES.has(p.namespace) ? 2 : p.namespace === 'turns' ? 1 : p.namespace === LEARNING_NAMESPACE ? -1 : 0;
   const ranked = candidates.sort((a, b) => Number(b.targeted) - Number(a.targeted) || signal(b) - signal(a) || b.score - a.score);
@@ -227,13 +234,14 @@ export function searchDeadlineFor(started, deadline) { return Math.min(deadline,
 async function consequentialRecall({ prompt, root, store, bin, scratch, env, deadline, binding, signal, enumerateKeys, exclusions, rankedSearch = true }) {
   const searchDeadline = searchDeadlineFor(Date.now(), deadline);
   const phaseBinding = recallBinding({ binding, projectRoot: root, storePath: store.path, prompt });
-  const namespaces = [...new Set([path.basename(root), 'default', 'lessons', 'continuity-events'])];
+  const stateNamespaces = checkpointNamespaces(root);
+  const namespaces = [...new Set([...stateNamespaces, 'lessons', 'continuity-events'])];
   const enumeration = await enumerateKeys({ storePath: store.path, namespaces, deadline, signal, env, scratch });
   if (!enumeration?.ok || signal?.aborted || Date.now() >= deadline) return { block: formatBlock({ picks: [], status: 'unavailable structural enumeration' }), picks: [], stores: [store],
     status: { 'memory.db': 'unavailable' }, outcome: signal?.aborted ? 'unavailable' : Date.now() >= deadline ? 'timed-out' : 'unavailable', categories: { state: 'unavailable', decisions: 'unavailable', lessons: 'unavailable' } };
-  const keys = enumeration.value;
-  const stateKeys = keys[path.basename(root)].filter(key => /^project-state-current-\d+$/.test(key) && Number.isSafeInteger(Number(key.split('-').at(-1))))
-    .sort((a, b) => Number(b.split('-').at(-1)) - Number(a.split('-').at(-1)));
+  const keys = Object.fromEntries(namespaces.map(namespace => [namespace, Array.isArray(enumeration.value?.[namespace]) ? enumeration.value[namespace] : []]));
+  // Newest by the epoch-ms in the key, across every namespace spelling: never insertion order, score or one namespace.
+  const latestState = newestCheckpoint(keys, stateNamespaces);
   const decisionNamespaces = namespaces.filter(namespace => namespace !== 'lessons');
   const decisionKeys = decisionNamespaces.flatMap(namespace => keys[namespace].filter(key => /^decision[-_]|^cevt-.*-decision-/i.test(key)).map(key => ({ category: 'decisions', namespace, key })));
   let relevantDecisions = decisionKeys;
@@ -255,13 +263,17 @@ async function consequentialRecall({ prompt, root, store, bin, scratch, env, dea
     }
     if (!relevantDecisions.length) decisionAvailability = 'unavailable'; // semantic miss is not absent history
   }
-  const candidates = [
-    ...stateKeys.slice(0, 1).map(key => ({ category: 'state', namespace: path.basename(root), key })),
-    ...keys.lessons.filter(key => /^lesson[-_]/i.test(key)).map(key => ({ category: 'lessons', namespace: 'lessons', key })),
-    ...relevantDecisions,
-  ];
-  if (candidates.length > 32) return { block: formatBlock({ picks: [], status: 'unavailable bounded category selection' }), picks: [], stores: [store], status: { 'memory.db': 'unavailable' }, outcome: 'unavailable', categories: { state: 'unavailable', decisions: 'unavailable', lessons: 'unavailable' } };
-  const categories = { state: !stateKeys.length && keys[path.basename(root)].includes('project-state-current') ? 'unavailable' : 'ok-empty', decisions: decisionAvailability, lessons: 'ok-empty' };
+  const stateCandidates = latestState ? [{ category: 'state', namespace: latestState.namespace, key: latestState.key }] : [];
+  let lessonCandidates = keys.lessons.filter(key => /^lesson[-_]/i.test(key)).map(key => ({ category: 'lessons', namespace: 'lessons', key }));
+  // The exact-read budget is bounded. Too many lessons must never cost the state record: lessons alone become
+  // unavailable (an honest marker), the newest checkpoint and the decisions are still read.
+  let lessonAvailability = 'ok-empty';
+  if (stateCandidates.length + lessonCandidates.length + relevantDecisions.length > MAX_EXACT_READS) { lessonCandidates = []; lessonAvailability = 'unavailable'; }
+  const candidates = [...stateCandidates, ...lessonCandidates, ...relevantDecisions];
+  if (candidates.length > MAX_EXACT_READS) return { block: formatBlock({ picks: [], status: 'unavailable bounded category selection' }), picks: [], stores: [store], status: { 'memory.db': 'unavailable' }, outcome: 'unavailable', categories: { state: 'unavailable', decisions: 'unavailable', lessons: 'unavailable' } };
+  // Checkpoint keys that exist but none of which carries an orderable epoch-ms: history we cannot date, not absence.
+  const unorderedState = !latestState && stateNamespaces.some(namespace => keys[namespace].some(key => /^project-state-(?:current|auto)/.test(key)));
+  const categories = { state: unorderedState ? 'unavailable' : 'ok-empty', decisions: decisionAvailability, lessons: lessonAvailability };
   const records = [];
   candidates.forEach(candidate => { candidate.storePath = store.path; });
   const exactResults = await exactReads({ candidates, bin, deadline, env, scratch, signal });
@@ -344,12 +356,9 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
     const query = recallQuery(prompt);
     const scratchFor = scratch || ((storePath) => rufloCwdFor(storePath, { root: rufloScratchRoot(env) }));
     if (consequential) return await consequentialRecall({ prompt, root, store, bin, scratch: scratchFor, env, deadline, binding, signal, enumerateKeys, exclusions });
-    const namespaces = [...new Set(['lessons', 'patterns', 'pattern', 'turns', 'continuity-events', path.basename(root), 'default'])];
-    const family = /\bhooks?\b|hook.harness/i.test(prompt) ? 'decision-hook-harness-index'
-      : /score|grade|north.star/i.test(prompt) ? 'scorecard'
-      : /where are we|status|catch me up/i.test(prompt) ? 'project-state-current'
-      : /releas|publish|workflow run|dispatch/i.test(prompt) ? 'release'
-      : /requirement|always|every prompt/i.test(prompt) ? 'decision-agentdb' : null;
+    // Only namespaces something below reads: curated lessons/decisions, the checkpoint namespaces (dirname, its
+    // lowercase form, default) and turns for the single ranked search. Each one is a `ruflo memory list` process.
+    const namespaces = [...new Set(['lessons', 'turns', 'continuity-events', ...checkpointNamespaces(root)])];
     // This machine runs loaded (load average 30-60 measured 2026-10-10) and ranked search spawns one Ruflo process
     // per namespace; run concurrently they starve every other read past the deadline. So: ONE native enumeration
     // (reused for the curated pass and for pruning empty namespaces), then exact curated state/lessons/decisions,
@@ -362,13 +371,12 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
       enumerateKeys: sharedKeys, exclusions, rankedSearch: false }).catch(() => null) : null;
     const searchDeadline = searchDeadlineFor(Date.now(), deadline);
     const activeNamespaces = presence?.ok ? namespaces.filter(namespace => presence.value[namespace]?.length) : namespaces;
-    const jobs = (store ? activeNamespaces : []).flatMap((namespace) => [{ store, namespace, family: null, args: ['--format', 'json', '-q', query, '-n', namespace, '--limit', '12'] },
-      ...(family && !SIGNAL_NAMESPACES.has(namespace) && namespace !== 'turns' ? [{ store, namespace, family, args: ['--format', 'json', '-q', family, '-n', namespace, '-t', 'keyword', '--limit', '4'] }] : [])]);
-    const words = promptKeywords(prompt, 14);
-    const workflowQuery = words.map(word => safeAction('Bash', word))
-      .find(action => action && action !== 'command');
-    if (learningStore && workflowQuery) jobs.push({ store: learningStore, namespace: LEARNING_NAMESPACE, family: null,
-      args: ['--format', 'json', '-q', workflowQuery, '-n', LEARNING_NAMESPACE, '-t', 'keyword', '--limit', '4'] });
+    // ONE supplementary search (owner ruling 2026-10-12). Measured on a live-size store at load 17: ~10
+    // concurrent `ruflo memory search` processes took 1.34-1.45 s each against a ~1.1 s window, so every
+    // ranked search timed out. Curated state/lessons/decisions already came from exact reads above.
+    const searchNamespace = [path.basename(root), 'default', 'turns'].find((namespace) => activeNamespaces.includes(namespace));
+    const jobs = store && searchNamespace ? [{ store, namespace: searchNamespace, family: null,
+      args: ['--format', 'json', '-q', query, '-n', searchNamespace, '--limit', '12'] }] : [];
     const results = await Promise.all(jobs.map(async ({ store: jobStore, namespace, family: recordFamily, args }) => ({ namespace, family: recordFamily, storePath: jobStore.path,
       ...await searchOnce({ ruflo: bin, store: jobStore, deadline: searchDeadline, env, scratch: scratchFor, args, signal }) })));
     let status = results.every((r) => r.state === 'ok') ? 'ok'

package/plugin/scripts/automated-run.mjs

@@ -0,0 +1,42 @@
+/**
+ * automated-run.mjs — is this Stop hook running inside an automated, machine-read run?
+ *
+ * Automated runs keep their exact output (4.7.1, check 2f). Measured: `claude -p` returned a
+ * "Correction to my previous reply ... Verified:" paragraph and `codex exec` returned "UNVERIFIED: ..."
+ * because the continuation gate asked for a correction, which corrupted callers that parse the answer.
+ *
+ * The approach is copied from the owner's own Stop gate, ~/.claude/hooks/owner-review-gate.mjs:
+ *   line 19   — `CLAUDE_CODE_ENTRYPOINT` starting with `sdk-` (scripted `claude -p` / Agent SDK runs);
+ *   lines 20-24 — `/bin/ps -o args= -p <ppid>` and the regex `(^|\/)codex(\s+\S+)*\s+exec(\s|$)`;
+ *                 an unknown parent keeps gating.
+ * One difference, and why: that gate is registered directly, so Codex is its parent. This gate runs at
+ * the end of a chain (node -e wrapper -> codex-hook.mjs -> codex-hook-adapter.mjs -> hook-shim.mjs ->
+ * this), so the Codex check walks a bounded number of ancestors, and only when the hook host is Codex.
+ * Interactive Claude (`cli`, desktop, VS Code entrypoints) and interactive Codex stay gated.
+ */
+import { execFileSync } from 'node:child_process';
+
+const CODEX_EXEC = /(^|\/)codex(\s+\S+)*\s+exec(\s|$)/;
+const MAX_ANCESTORS = 12;
+
+function psRow(pid) {
+  const out = execFileSync('/bin/ps', ['-o', 'ppid=,command=', '-p', String(pid)], { encoding: 'utf8', timeout: 1000 });
+  const m = /^\s*(\d+)\s+(.*)$/s.exec(out.trim());
+  return m ? { ppid: Number(m[1]), args: m[2].trim() } : null;
+}
+
+/** True when the hook belongs to an automated run. `ps` is injectable for tests. */
+export function isAutomatedRun({ env = process.env, ppid = process.ppid, ps = psRow } = {}) {
+  if (/^sdk-/.test(env.CLAUDE_CODE_ENTRYPOINT || '')) return true;
+  if (env.RUVNET_HOOK_HOST !== 'codex') return false;
+  try {
+    let pid = ppid;
+    for (let i = 0; i < MAX_ANCESTORS && pid > 1; i++) {
+      const row = ps(pid);
+      if (!row) return false;
+      if (CODEX_EXEC.test(row.args)) return true;
+      pid = row.ppid;
+    }
+  } catch { /* unknown parent: keep gating */ }
+  return false;
+}

package/plugin/scripts/brain-footprint.mjs

@@ -41,7 +41,7 @@ export const FOOTPRINT_POLICY = Object.freeze({
   staleStageMs: 2 * 3_600_000,       // an install stage nobody activated in 2h is debris
   staleForgeCandidateMs: 24 * 3_600_000,
   staleLeaseMs: 6 * 3_600_000,       // plugin/scripts/update-apply.mjs LEASE_FRESH_MS
-  staleRufloRunMs: 3_600_000,        // plugin/scripts/project-progression-store.mjs STALE_RUN_MS
+  staleRufloRunMs: 3_600_000,        // plugin/scripts/ruflo-bin.mjs STALE_RUN_MS
 });
 
 /** Every full-KB copy name this product (or a recovery) has ever created beside the live KB. A superset of

package/plugin/scripts/checkpoint-keys.mjs

@@ -0,0 +1,46 @@
+/**
+ * Which project-state checkpoint is the newest — decided by the epoch-ms in the KEY, never by `ruflo memory list`
+ * order, createdAt/updatedAt, semantic score or a list limit. Shared by the per-prompt recall
+ * (agentdb-recall.mjs) and SessionStart restore (ruflo-memory-hooks.mjs). Pure: no I/O.
+ */
+import path from 'node:path';
+
+/**
+ * Namespaces that hold a project's checkpoints. `ruflo memory list -n` is case-sensitive, and owners write
+ * both the dirname and its lowercase form (measured 2026-10-13: AppealArmor's newest checkpoints are all in
+ * `appealarmor`), plus `default` when no -n was given.
+ */
+export function checkpointNamespaces(root) {
+  const base = path.basename(root);
+  return [...new Set([base, base.toLowerCase(), 'default'])];
+}
+
+const CHECKPOINT_KEY = /^project-state-(current|auto)-(\d{13})(?:-[A-Za-z0-9][A-Za-z0-9._-]{0,63})?$/;
+const MIN_CHECKPOINT_MS = Date.UTC(2020, 0, 1);
+const FUTURE_SKEW_MS = 24 * 3600 * 1000;
+
+/** The epoch-ms a checkpoint key carries ({family, ms}), or null for a key that cannot be ordered by time. */
+export function checkpointMs(key, now = Date.now()) {
+  const match = CHECKPOINT_KEY.exec(String(key));
+  if (!match) return null;
+  const ms = Number(match[2]);
+  return ms >= MIN_CHECKPOINT_MS && ms <= now + FUTURE_SKEW_MS ? { family: match[1], ms } : null;
+}
+
+/** Newest key of one family ('current' | 'auto') across {namespace: keys[]}; ties go to the earlier namespace. */
+export function newestOfFamily(keysByNamespace, namespaces, family, now = Date.now()) {
+  let best = null;
+  namespaces.forEach((namespace, rank) => {
+    for (const key of keysByNamespace?.[namespace] ?? []) {
+      const parsed = checkpointMs(key, now);
+      if (!parsed || parsed.family !== family) continue;
+      if (!best || parsed.ms > best.ms || parsed.ms === best.ms && rank === best.rank && key > best.key) best = { namespace, key, ms: parsed.ms, rank };
+    }
+  });
+  return best && { namespace: best.namespace, key: best.key, ms: best.ms };
+}
+
+/** The newest curated project-state-current-*; an automatic project-state-auto-* only when no curated one exists. */
+export function newestCheckpoint(keysByNamespace, namespaces, now = Date.now()) {
+  return newestOfFamily(keysByNamespace, namespaces, 'current', now) ?? newestOfFamily(keysByNamespace, namespaces, 'auto', now);
+}

package/plugin/scripts/codex-hook-wrapper.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
 
 // New installs colocate the helper. Older standalone fixtures/installations can omit it;
 // they retain their prior behavior until the installer upgrades both files.
@@ -44,8 +45,8 @@ const blockingHooks = new Set([
  *
  *     warning: clamping SessionEnd hook timeout to 3s in .../hooks.json
  *
- * SessionEnd is HARD-CAPPED at 3 seconds and no registration can ask for more. learn-flush needs
- * 18s: measured with a real 10-entry queue and the real `ruflo`, 18342 / 18347 / 18384 ms, because
+ * SessionEnd is HARD-CAPPED at 3 seconds and no registration can ask for more. The former learning
+ * flusher needed 18s: measured with a real 10-entry queue and the real `ruflo`, 18342 / 18347 / 18384 ms, because
  * one `ruflo hooks` call alone costs seconds and it self-bounds at LEARN_FLUSH_DEADLINE_MS.
  *
  * So the arithmetic never closes, and what shipped was the worst version of that: this wrapper
@@ -57,7 +58,8 @@ const blockingHooks = new Set([
  * exactly — the hook returns immediately — while the flush runs to its own deadline and does its
  * own write-back. Raising the number instead would have been a fiction the host silently clamps.
  */
-const DETACHED_HOOKS = new Set(['learn-flush']);
+// Empty since the learning flusher was deleted (2026-10-12): learning writes directly through ruflo.
+const DETACHED_HOOKS = new Set([]);
 
 /** THE BUDGET IS DERIVED FROM WHAT THE HOOK MEASURABLY COSTS, never from what looks tidy. */
 function timeoutFor(hookId, event = '', sessionBudgetMs = 0) {
@@ -226,6 +228,14 @@ const result = spawnSync(process.execPath, [adapter, ...process.argv.slice(2)],
   timeout: budgetMs,
   killSignal: 'SIGKILL',
 });
+// Review N5: Codex has no shim watchdog in front of the body, so a kill here was silent. One ledger row,
+// read by the next SessionStart (same writer and file as the shim's own rows). Never throws.
+if (result.error?.code === 'ETIMEDOUT' || result.signal === 'SIGKILL') {
+  try {
+    const { recordHookFailure } = await import(pathToFileURL(path.join(root, 'scripts', 'hook-failures.mjs')).href);
+    recordHookFailure({ hook: hookId, event: process.argv[3] || '', error: 'killed-by-codex-wrapper', limitMs: budgetMs }, { brainHome });
+  } catch { /* an unrecordable failure must not become a second one */ }
+}
 if (hookId === 'session-start' && result.status !== 0) {
   process.stderr.write('[RuvNet Brain — PROJECT CONTINUITY UNKNOWN] SessionStart did not complete inside its host deadline; no restoration success is claimed.\n');
 }

package/plugin/scripts/completion-claim-evidence.mjs

@@ -18,7 +18,7 @@
  *
  * HOSTS. Claude Code transcripts (`transcript_path`, JSONL) are parsed. Codex's Stop payload also
  * carries `transcript_path`, but its rollout format is NOT parsed anywhere in this repository
- * (project-progression-sources.mjs and turn-outcome-capture.mjs both decline it), so on Codex the
+ * (turn-outcome-capture.mjs declines it), so on Codex the
  * transcript half is UNKNOWN and only the answer-side half (2)+(3) is enforced — disclosed in the
  * correction text, never silently treated as proven.
  */

package/plugin/scripts/continuation-gate.mjs

@@ -42,6 +42,7 @@ import path from 'node:path';
 import os from 'node:os';
 import crypto from 'node:crypto';
 import { readStopHookInput } from './hook-input.mjs';
+import { isAutomatedRun } from './automated-run.mjs';
 import {
   auditCapabilityClaims,
   buildCapabilityInventoryReceipt,
@@ -336,6 +337,11 @@ if (has('--clear')) { save({ items: [] }); console.log('ledger cleared'); proces
  */
 const hookInput = await readStopHookInput(); // shared with grounding-turn-gate: hook-input.mjs (ADR-043)
 
+// AUTOMATED RUNS KEEP THEIR EXACT OUTPUT (4.7.1): scripted `claude -p` / SDK runs and `codex exec` are
+// read by machines, and a correction request rewrote their answers. Same rule as the owner's
+// owner-review-gate.mjs lines 15-24; see automated-run.mjs. Interactive sessions are still gated.
+if (isAutomatedRun()) process.exit(EXIT_ALLOW);
+
 // LOOP-SAFETY 1 (ADR-043 / Fable #1) — only an affirmatively-parsed hook payload may force. A 'tty' or
 // 'unreadable' source cannot be confirmed a fresh stop, so it never forces.
 if (hookInput.__source !== 'stdin') process.exit(EXIT_ALLOW);

package/plugin/scripts/continuity-events.mjs

@@ -18,7 +18,7 @@
  *   lesson     an owner correction / standing rule, or explicit        explicit only is authoritative
  *   open-item  explicit only (the work ledger is read live, not copied) authoritative
  *
- * Each event is redacted (redactProgression), bounded (SUMMARY_LIMIT), and carries a content-derived
+ * Each event is redacted (redactProgression, below), bounded (SUMMARY_LIMIT), and carries a content-derived
  * `id` so the same commit, decision or lesson is recorded once however many boundaries see it.
  *
  * PRIVACY. Turn capture never stores user text (a 2026-07-13 measurement: prompt echoes were 87% of a
@@ -31,7 +31,95 @@
 import { nativeTurnLines } from './native-turn-transcript.mjs';
 import crypto from 'node:crypto';
 import { execFileSync } from 'node:child_process';
-import { redactProgression } from './project-progression-contract.mjs';
+
+// Secret redaction for event payloads: pure functions, no storage.
+function canonicalize(value) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') return value;
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (value && typeof value === 'object' && Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalize(value[key])]));
+  }
+  throw new TypeError('progression values must be JSON-compatible');
+}
+
+function secretKind(key) {
+  const normalized = key.replace(/[^a-z0-9]/gi, '').toLowerCase();
+  if (normalized.includes('privatekey')) return 'private-key';
+  if (normalized.includes('apikey')) return 'api-key';
+  if (normalized.includes('authorization')) return 'authorization';
+  if (normalized.includes('password') || normalized.includes('passwd')) return 'password';
+  if (normalized.includes('token')) return 'token';
+  if (normalized.includes('secret')) return 'secret';
+  if (normalized.includes('credential')) return 'credential';
+  return null;
+}
+
+const INLINE_SECRETS = Object.freeze([
+  {
+    kind: 'private-key',
+    pattern: /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+    replace: '[REDACTED:private-key]',
+  },
+  {
+    kind: 'bearer-token',
+    pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/gi,
+    replace: 'Bearer [REDACTED:bearer-token]',
+  },
+  {
+    kind: 'api-key',
+    pattern: /\b(?:sk|api-key|ghp|github_pat)[-_][A-Za-z0-9._-]{8,}/gi,
+    replace: '[REDACTED:api-key]',
+  },
+  {
+    kind: 'password',
+    pattern: /\b(password|passwd)\s*[:=]\s*[^\s;,]+/gi,
+    replace: '$1=[REDACTED:password]',
+  },
+  {
+    kind: 'token',
+    pattern: /\b(token|secret|credential)\s*[:=]\s*[^\s;,]+/gi,
+    replace: '$1=[REDACTED:token]',
+  },
+]);
+
+export function redactProgression(value) {
+  const redactions = [];
+  const mark = (path, kind) => {
+    if (!redactions.some((row) => row.path === path && row.kind === kind)) redactions.push({ path, kind });
+  };
+  const walk = (current, currentPath) => {
+    if (typeof current === 'string') {
+      let output = current;
+      for (const rule of INLINE_SECRETS) {
+        rule.pattern.lastIndex = 0;
+        const replaced = output.replace(rule.pattern, rule.replace);
+        if (replaced !== output) {
+          mark(currentPath, rule.kind);
+          output = replaced;
+        }
+      }
+      return output;
+    }
+    if (Array.isArray(current)) return current.map((item, index) => walk(item, `${currentPath}[${index}]`));
+    if (current && typeof current === 'object' && Object.getPrototypeOf(current) === Object.prototype) {
+      return Object.fromEntries(Object.keys(current).sort().map((key) => {
+        const path = `${currentPath}.${key}`;
+        const kind = secretKind(key);
+        if (kind && current[key] !== null && current[key] !== undefined) {
+          if (current[key] !== `[REDACTED:${kind}]`) mark(path, kind);
+          return [key, `[REDACTED:${kind}]`];
+        }
+        return [key, walk(current[key], path)];
+      }));
+    }
+    return canonicalize(current);
+  };
+  const redacted = walk(value, '$');
+  redactions.sort((left, right) => left.path.localeCompare(right.path) || left.kind.localeCompare(right.kind));
+  return { value: redacted, redactions };
+}
+
 
 export const CONTINUITY_NAMESPACE = 'continuity-events';
 export const EVENT_SCHEMA = 'ruvnet-brain.continuity-event';

package/plugin/scripts/continuity-hook-policy.mjs

@@ -20,9 +20,10 @@
  *   session-start       continuity recovery   at SessionStart       claude, codex
  *   unprompted-speech   advisory delivery     at UserPromptSubmit   claude, codex
  *   continuation-gate   continuation nudge    at turn end           claude, codex
- *   session-snapshot    continuity capture    at turn end           claude, codex
- *   session-snapshot    continuity capture    at PreCompact         claude
- *   session-snapshot    continuity capture    at SessionEnd         claude, codex
+ *   session-snapshot    turn outcome (ruflo)  at Stop               claude, codex
+ *   session-snapshot    checkpoint (ruflo)    at PreCompact         claude, codex
+ *   session-snapshot    checkpoint (ruflo)    at SessionEnd         claude, codex
+ *   session-snapshot    learning (opt-in)     at PostToolUse        claude, codex
  *   ground-ruvnet       grounding injection   at UserPromptSubmit   claude, codex
  *   capacity-aware-parallel-work coordination guidance at UserPromptSubmit claude, codex
  *   decision-gate       write authorization   at PreToolUse (write) claude, codex
@@ -122,11 +123,9 @@ const registration = (id, matcher, hosts) => Object.freeze({ id, matcher, hosts:
  */
 export const CONTINUITY_EVENTS = Object.freeze({
   SessionStart: Object.freeze([
-    // learn-flush is no longer its own registration (ADR-106): session-start schedules it detached.
     registration('session-start', 'startup|resume|clear|compact|fork', ['claude', 'codex']),
   ]),
   UserPromptSubmit: Object.freeze([
-    registration('session-snapshot', '*', ['claude', 'codex']),
     registration('unprompted-speech', '*', ['claude', 'codex']),
     registration('ground-ruvnet', '*', ['claude', 'codex']),
     // Context-only recommendation for clearly substantial, independently splittable work. The
@@ -144,7 +143,6 @@ export const CONTINUITY_EVENTS = Object.freeze({
   // Claude's `Edit` shape for decision-gate.mjs's own policies (protect-state, hijack-ruvnet,
   // ground-before-write, adr-currency all then see tool_name:"Edit" exactly as on Claude).
   PreToolUse: Object.freeze([
-    registration('session-snapshot', '*', ['claude', 'codex']),
     registration('decision-gate', '^(Write|Edit|MultiEdit|NotebookEdit|apply_patch)$', ['claude', 'codex']),
   ]),
   // Extended to Codex 2026-09-12: a real MCP `search_ruvnet` call was measured to fire PostToolUse
@@ -154,16 +152,10 @@ export const CONTINUITY_EVENTS = Object.freeze({
   // no change either (proven live: the real MCP tool_response's `content[0].text` carries the exact
   // "Searched N RuvNet repos" banner and query text the script already looks for).
   PostToolUse: Object.freeze([
-    // learn-capture runs in-process inside session-snapshot's PostToolUse boundary (ADR-106).
+    // Learning observation (consent-gated `ruflo memory store`) runs inside session-snapshot's PostToolUse body.
     registration('session-snapshot', '*', ['claude', 'codex']),
     registration('grounding-stamp', '^(?:.*__)?search_ruvnet$', ['claude', 'codex']),
   ]),
-  PostToolUseFailure: Object.freeze([
-    registration('session-snapshot', '*', ['claude']),
-  ]),
-  SubagentStop: Object.freeze([
-    registration('session-snapshot', '*', ['claude', 'codex']),
-  ]),
   Stop: Object.freeze([
     registration('continuation-gate', '*', ['claude', 'codex']),
     // Codex added 2026-09-29 (owner requirement: every turn's outcome recorded on BOTH hosts —
@@ -186,7 +178,6 @@ export const CONTINUITY_EVENTS = Object.freeze({
     registration('session-snapshot', '*', ['claude', 'codex']),
   ]),
   SessionEnd: Object.freeze([
-    // learn-flush is scheduled by session-snapshot's SessionEnd boundary (ADR-106).
     registration('session-snapshot', '*', ['claude', 'codex']),
   ]),
 });