ruvnet-brain 4.7.20 → 4.7.22

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

@@ -5,6 +5,7 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { managedGenerationIdentity } from './managed-cli-generation.mjs';
 import { loadRuntimePreferences, runtimeChildEnv } from '../scripts/runtime-preferences.mjs';
+import { resolveRuflo } from '../scripts/ruflo-bin.mjs';
 import { projectDirectory } from '../scripts/project-identity.mjs';
 import { recordManagedCliObservation, recordRegistryLatestObservation } from '../scripts/capability-claim-evidence.mjs';
 
@@ -180,12 +181,19 @@ function writeStamps(executable, argv, env, binding) {
 
 export function resolveManagedExecutable(executable, env = process.env) {
   if (executable !== 'ruflo') return executable;
-  const home = env.HOME || os.homedir();
-  const candidates = [path.join(home, '.npm-global', 'bin', 'ruflo')];
-  if (process.platform === 'win32') candidates.push(`${candidates[0]}.cmd`);
-  return candidates.find((candidate) => {
-    try { fs.accessSync(candidate, fs.constants.X_OK); return true; } catch { return false; }
-  }) || executable;
+  // #420 item 5: same rules as every other Brain caller (RUFLO_BIN is authoritative, then ~/.npm-global/bin, then PATH); this used to check ~/.npm-global only and ignored RUFLO_BIN.
+  return resolveRuflo({ env, home: env.HOME || os.homedir() }) || executable;
+}
+
+/**
+ * ruflo (and claude-flow, the same @claude-flow/cli) self-updates at startup by running `npm install` in its
+ * working directory, which here is the user's project: measured 2026-10-22, a 1.3 GB install landed there.
+ * ruflo-bin.mjs promises every Brain spawn sets CLAUDE_FLOW_AUTO_UPDATE=false; this boundary is a Brain spawn
+ * too. RUFLO_DAEMON_AUTOSTART=0 keeps a background daemon from being left behind in that project.
+ */
+export function managedChildEnv(executable, env) {
+  if (executable !== 'ruflo' && executable !== 'claude-flow') return env;
+  return { ...env, CLAUDE_FLOW_AUTO_UPDATE: 'false', RUFLO_DAEMON_AUTOSTART: '0' };
 }
 
 function quoteWindowsCommandArg(value) {
@@ -323,7 +331,7 @@ export async function callManagedCli(toolName, args, env = process.env, fetchImp
     if (toolName === 'ruvnet_cli_help') {
       stampKeysForHelp(executable, argv);
       const commandArgv = [...argv, '--help'];
-      const execution = await execute(executable, commandArgv, env);
+      const execution = await execute(executable, commandArgv, managedChildEnv(executable, env));
       if (normalizeManagedExecution(execution).outcome === 'success') writeStamps(executable, argv, env, binding);
       recordManagedCliObservation({ toolName, executable, argv: commandArgv, execution, env });
       return resultOf(executable, commandArgv, execution);
@@ -368,7 +376,7 @@ export async function callManagedCli(toolName, args, env = process.env, fetchImp
       // host by supplying an arbitrary `host` property.
       const childEnv = (executable === 'agentic-flow' || executable === 'agentic-qe')
         ? runtimeChildEnv({ env, cwd: projectRoot })
-        : env;
+        : managedChildEnv(executable, env);
       if (lifecycle && typeof lifecycle.beforeExecute === 'function') {
         await lifecycle.beforeExecute({ executable, argv, projectRoot, env: childEnv });
       }

package/plugin/scripts/adr-currency-gate.mjs

@@ -33,6 +33,7 @@ import fs from 'node:fs';
 import { execFileSync, spawn } from 'node:child_process';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { isDirectInvocation } from './entrypoint.mjs';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const REPO = path.resolve(HERE, '..', '..');
@@ -128,7 +129,7 @@ An ADR describing a world the code left is worse than no ADR: the next reader tr
 }
 
 const isMain = (() => {
-  try { return process.argv[1] && fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url); }
+  try { return isDirectInvocation(import.meta.url); }
   catch { return false; }
 })();
 

package/plugin/scripts/advisory-contract.mjs

@@ -0,0 +1,21 @@
+/**
+ * The delivery contract for OPTIONAL Brain advice (#489).
+ *
+ * A capability recommendation, a package recommendation or a routine stack-update notice is
+ * information, not a decision the user must make now. Phrased as a question ("want me to update
+ * it?"), it was promoted by Codex into a structured question dialog that suspended an already
+ * authorized task. So optional advice is worded as statements, and the model-visible context
+ * carries this one line saying so. Real permission gates and genuinely missing information keep
+ * their normal question behaviour; this applies only to optional advisory channels.
+ *
+ * ground-ruvnet.sh cannot import this module and carries the same sentence verbatim;
+ * tests/unit/advisory-contract.test.mjs fails if the two drift.
+ */
+export const ADVISORY_CONTRACT = 'Optional, informational advice: mention it at most once as a statement and continue the current task. '
+  + 'Do not open a question or approval dialog because of it; it grants no authority to install or update anything.';
+
+/**
+ * Question-shaped wording that invites a decision dialog, including the "say X to proceed, or ignore
+ * this" choice prompt the advocacy copy used to carry. Optional advice must match none of it.
+ */
+export const QUESTION_SHAPED = /\?|\b(want me to|would you like|should i|shall i|do you want|can i|to proceed|or ignore this)\b/i;

package/plugin/scripts/advocacy-route.mjs

@@ -61,6 +61,7 @@ import {
   ACTIONS, record, shouldStillOffer, stateHashOf, precision, pendingOffers, reconcileIgnored, loadOutcomes,
 } from './advocacy-outcomes.mjs';
 import { packageRecommenderEnabled, offerNames } from './package-recommender-flag.mjs';
+import { isDirectInvocation } from './entrypoint.mjs';
 // Matcher + socket client load only when the flag is on at process start: default-off pays nothing.
 const PKG = packageRecommenderEnabled() ? { ...(await import('./package-recommender.mjs')), ...(await import('./package-recommender-client.mjs')) } : null;
 
@@ -341,9 +342,9 @@ export function buildCandidate({ prompt, match, availability }) {
     ? `It is already installed here.`
     : `Install state unknown from here — say so rather than claiming it is available.`;
   const copy = [
-    `[RuvNet Brain — capability advocacy] If it genuinely fits, tell the user in ONE sentence: `
-      + `"Consider ${cap.id} — ${cap.benefit}. Say 'use ${cap.id}' to proceed, or ignore this." ${avail}`,
-    `If they accept, the safe first step is \`${cap.nextAction}\` (undo: ${cap.undo}); confirm it with `
+    `[RuvNet Brain — capability advocacy] If it genuinely fits, state it in ONE sentence: `
+      + `"${cap.id} fits here — ${cap.benefit}; 'use ${cap.id}' adopts it." ${avail}`,
+    `If the user later says to use it, the safe first step is \`${cap.nextAction}\` (undo: ${cap.undo}); confirm it with `
       + `search_ruvnet before you build. Say it once, do not expand it, then carry on with the actual work.`,
   ].join('\n');
   return {
@@ -429,7 +430,7 @@ export function decide({ prompt, sessionId, file, state, now = Date.now(), start
 }
 
 // ── CLI ───────────────────────────────────────────────────────────────────────────────────────────
-const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+const isMain = isDirectInvocation(import.meta.url);
 
 async function main() {
   const startedAt = Date.now();

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

@@ -2,8 +2,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { rufloInvocation } from './ruflo-bin.mjs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { rufloInvocation, nativeNodeFor } from './ruflo-bin.mjs';
 export function searchJsonResult(stdout) {
   const s = String(stdout || '');
   // Live Ruflo prints warnings AFTER the JSON object as well as logs before it.
@@ -20,6 +20,105 @@ function killGroup(child) {
   catch { try { child.kill('SIGKILL'); } catch { /* already gone */ } }
 }
 
+const readJson = (file) => { try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return null; } };
+const inside = (root, file) => { const rel = path.relative(root, file); return rel && !rel.startsWith('..') && !path.isAbsolute(rel); };
+
+/**
+ * Can reads go through Ruflo's own published code instead of one CLI process per read (#429)? Only when the resolved
+ * `ruflo` is the real package entry AND the `@claude-flow/cli` it loads (found as bin/ruflo.js finds it) declares a
+ * `./memory` export that resolves to a file inside it. Otherwise null and the caller keeps the per-read CLI route.
+ * The three functions and result shapes are checked again inside the child, where they are actually loaded.
+ */
+export function resolveBatchTarget(bin, { env = process.env, deadlineAt } = {}) {
+  try {
+    if (!bin || process.platform === 'win32') return null; // npm .cmd shims are not inspected here
+    const entry = fs.realpathSync(bin);
+    const pkgRoot = path.dirname(path.dirname(entry));
+    const pkg = readJson(path.join(pkgRoot, 'package.json'));
+    const declared = typeof pkg?.bin === 'string' ? pkg.bin : pkg?.bin?.ruflo;
+    if (pkg?.name !== 'ruflo' || typeof declared !== 'string' || fs.realpathSync(path.resolve(pkgRoot, declared)) !== entry) return null;
+    let cliRoot = null;
+    for (let dir = pkgRoot, i = 0; i < 10 && !cliRoot; i += 1, dir = path.dirname(dir)) {
+      const candidate = path.join(dir, 'node_modules', '@claude-flow', 'cli');
+      if (fs.existsSync(path.join(candidate, 'package.json'))) cliRoot = candidate;
+      if (path.dirname(dir) === dir) break;
+    }
+    const cli = cliRoot && readJson(path.join(cliRoot, 'package.json'));
+    const target = cli?.name === '@claude-flow/cli' ? (cli.exports?.['./memory']?.import ?? cli.exports?.['./memory']) : null;
+    if (typeof target !== 'string') return null;
+    const file = fs.realpathSync(path.resolve(cliRoot, target));
+    if (!inside(fs.realpathSync(cliRoot), file) || !fs.statSync(file).isFile()) return null;
+    return { node: nativeNodeFor(bin, { env, deadlineAt })?.node ?? process.execPath, moduleUrl: pathToFileURL(file).href };
+  } catch { return null; }
+}
+
+/**
+ * ONE owned child answering `list` / `get` for a store through Ruflo's public memory export. Spawned on first use,
+ * killed (whole process group) at the absolute deadline or on close(). Every op resolves, never rejects:
+ * { state: 'ok' | 'unavailable' | 'timed out' | 'fallback', rows?, value? } — 'fallback' means this route cannot
+ * answer (capability or shape mismatch) and the caller must use the per-read CLI route. `{success:false}` from
+ * Ruflo is 'unavailable', never an empty result.
+ */
+export function openBatchSession({ bin, storePath, env, deadline, makeCwd, signal }) {
+  const target = resolveBatchTarget(bin, { env, deadlineAt: deadline });
+  if (!target || !storePath) return null;
+  let child = null, cwd = null, ready = null, resolveReady = null, seq = 0, closed = false, timer;
+  const pending = new Map();
+  const settleAll = (state) => { for (const finish of [...pending.values()]) finish({ state }); };
+  const close = (state = 'unavailable') => {
+    if (closed) return; closed = true; clearTimeout(timer);
+    settleAll(state);
+    if (child) { killGroup(child); try { child.stdin.destroy(); } catch { /* gone */ } }
+    cwd?.cleanup?.();
+  };
+  const start = () => {
+    if (child || closed) return;
+    try {
+      cwd = makeCwd();
+      child = spawn(target.node, [fileURLToPath(new URL('./agentdb-recall-reader.mjs', import.meta.url)), '--session', storePath, target.moduleUrl],
+        { cwd: cwd.cwd, env: { ...env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_AUTO_UPDATE: 'false', CLAUDE_FLOW_MEMORY_PATH: undefined },
+          stdio: ['pipe', 'pipe', 'ignore'], detached: process.platform !== 'win32', windowsHide: true });
+    } catch { child = null; close(); return; }
+    ready = new Promise((resolve) => {
+      resolveReady = resolve;
+      child.once('close', () => { resolve(false); if (!closed) settleAll('unavailable'); });
+      child.once('error', () => resolve(false));
+    });
+    let buffer = '';
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      buffer += chunk;
+      for (let at = buffer.indexOf('\n'); at >= 0; at = buffer.indexOf('\n')) {
+        const line = buffer.slice(0, at); buffer = buffer.slice(at + 1);
+        let row; try { row = JSON.parse(line); } catch { continue; }
+        if (typeof row.ready === 'boolean') resolveReady(row.ready);
+        else pending.get(row.id)?.(row);
+      }
+    });
+    child.stdin.on('error', () => {});
+    timer = setTimeout(() => close('timed out'), Math.max(1, deadline - Date.now()));
+    signal?.addEventListener('abort', () => close('unavailable'), { once: true });
+  };
+  const ask = (request, opDeadline = deadline) => new Promise((resolve) => {
+    if (closed || signal?.aborted) return resolve({ state: signal?.aborted ? 'unavailable' : 'timed out' });
+    if (opDeadline - Date.now() <= 0) return resolve({ state: 'timed out' });
+    start();
+    if (!child) return resolve({ state: 'unavailable' });
+    const id = ++seq;
+    const opTimer = opDeadline < deadline ? setTimeout(() => finish({ state: 'timed out' }), Math.max(1, opDeadline - Date.now())) : null;
+    const finish = (row) => { if (!pending.delete(id)) return; clearTimeout(opTimer); const { id: _id, ...rest } = row; resolve(rest); };
+    pending.set(id, finish);
+    ready.then((ok) => {
+      if (!pending.has(id)) return;
+      if (!ok) return finish({ state: closed ? 'unavailable' : 'fallback' });
+      try { child.stdin.write(JSON.stringify({ id, ...request }) + '\n'); } catch { finish({ state: 'unavailable' }); }
+    });
+  });
+  return { storePath, close,
+    list: (namespace, limit, opDeadline) => ask({ op: 'list', namespace, limit }, opDeadline),
+    get: async (namespace, key, opDeadline) => { const r = await ask({ op: 'get', namespace, key }, opDeadline); return r.state === 'ok' ? { ...r, value: r.value.trim() } : r; } };
+}
+
 /** One ruflo search, bounded by an absolute deadline. Resolves { rows, state } — never rejects. */
 export function searchOnce({ ruflo, store, args, deadline, env, scratch, operation = 'search', signal, invocation }) {
   return new Promise((resolve) => {
@@ -82,7 +181,18 @@ export function searchOnce({ ruflo, store, args, deadline, env, scratch, operati
 }
 
 /** Isolate synchronous read-only SQLite work inside the same cancellable process budget. */
-export async function nativeRead({ store, requests, namespaces, deadline, env, scratch, signal }) {
+export async function nativeRead({ store, requests, namespaces, deadline, env, scratch, signal, session }) {
+  if (session && session.storePath === store.path) {
+    const rows = requests ? await Promise.all(requests.map(({ namespace, key }) => session.get(namespace, key)))
+      : await Promise.all(namespaces.map((namespace) => session.list(namespace, 100000)));
+    const states = rows.map((row) => row.state);
+    if (!states.includes('fallback')) {
+      const dead = states.find((state) => state === 'timed out') ?? (!requests && states.find((state) => state !== 'ok'));
+      if (dead) return { ok: false, fatal: true, state: dead };
+      return { ok: true, state: 'ok', value: requests ? rows.map((row) => (row.state === 'ok' ? row.value : null))
+        : Object.fromEntries(namespaces.map((namespace, i) => [namespace, rows[i].rows.map((row) => row.key).filter((key) => typeof key === 'string')])) };
+    }
+  }
   const result = await searchOnce({ store, deadline, env, scratch, signal, operation: 'native',
     invocation: { executable: process.execPath, args: [fileURLToPath(new URL('./agentdb-recall-reader.mjs', import.meta.url)),
       store.path, JSON.stringify({ requests, namespaces, deadline })] } });
@@ -94,7 +204,7 @@ export async function nativeRead({ store, requests, namespaces, deadline, env, s
   } catch { return { ok: false, fatal: true, state: 'unavailable' }; }
 }
 
-export async function exactReads({ candidates, bin, deadline, env, scratch, signal }) {
+export async function exactReads({ candidates, bin, deadline, env, scratch, signal, session }) {
   const groups = new Map();
   for (const candidate of candidates) {
     const storePath = candidate.storePath;
@@ -104,7 +214,7 @@ export async function exactReads({ candidates, bin, deadline, env, scratch, sign
   const results = new Map();
   await Promise.all([...groups].map(async ([storePath, rows]) => {
     const native = await nativeRead({ store: { path: storePath }, requests: rows.map(({ namespace, key }) => ({ namespace, key })),
-      deadline, env, scratch, signal });
+      deadline, env, scratch, signal, session });
     await Promise.all(rows.map(async (row, index) => {
       const result = native.ok ? { state: 'ok', value: native.value[index] ?? '' }
         : native.fatal ? { state: native.state, value: '' }

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

@@ -3,8 +3,46 @@
  * so a stalled CLI is retired at the recall deadline. Output contract unchanged: {ok, value}.
  */
 import { execFile } from 'node:child_process';
+import readline from 'node:readline';
 import { resolveRuflo, rufloInvocationOrPlain } from './ruflo-bin.mjs';
 
+/** Batch session (#429): ONE process answering line-based `list` / `get` requests by calling the installed Ruflo
+ * package's own public `@claude-flow/cli/memory` export — the functions its `memory list` / `memory retrieve`
+ * commands call. argv: --session <storePath> <moduleUrl>. Replies are single JSON lines on the real stdout. */
+async function session(storePath, moduleUrl) {
+  const write = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (chunk, ...rest) => process.stderr.write(chunk, ...rest); // module chatter must not corrupt the protocol
+  const reply = (row) => write(JSON.stringify(row) + '\n');
+  let mod;
+  try { mod = await import(moduleUrl); } catch { mod = null; }
+  if (!mod || typeof mod.listEntries !== 'function' || typeof mod.getEntry !== 'function' || typeof mod.resolveDbPath !== 'function') {
+    reply({ ready: false }); process.exit(0);
+  }
+  const dbPath = mod.resolveDbPath(storePath);
+  reply({ ready: true });
+  const run = async ({ op, namespace, key, limit }) => {
+    if (typeof namespace !== 'string') return { state: 'fallback' };
+    if (op === 'list') {
+      const r = await mod.listEntries({ namespace, limit, offset: 0, dbPath });
+      if (r?.success === false) return { state: 'unavailable' };
+      // Every entry must carry a string key. If Ruflo renames the field the list is UNREADABLE by this route, never
+      // an empty namespace: fall back to the CLI route rather than report no memory (#429).
+      return r?.success === true && Array.isArray(r.entries) && r.entries.every((e) => e && typeof e === 'object' && typeof e.key === 'string')
+        ? { state: 'ok', rows: r.entries.map((e) => ({ key: e.key, createdAt: e.createdAt })) } : { state: 'fallback' };
+    }
+    if (op === 'get' && typeof key === 'string' && key) {
+      const r = await mod.getEntry({ key, namespace, dbPath });
+      if (r?.success === false || r?.success === true && r.found === false) return { state: 'unavailable' };
+      return r?.success === true && typeof r.entry?.content === 'string' ? { state: 'ok', value: r.entry.content } : { state: 'fallback' };
+    }
+    return { state: 'fallback' };
+  };
+  readline.createInterface({ input: process.stdin }).on('line', (line) => {
+    let request; try { request = JSON.parse(line); } catch { return; }
+    run(request).catch(() => ({ state: 'unavailable' })).then((out) => reply({ id: request.id, ...out }));
+  }).on('close', () => process.exit(0));
+}
+
 const call = (bin, args, deadline) => new Promise((resolve) => {
   const timeout = Math.max(1, deadline - Date.now());
   const inv = rufloInvocationOrPlain(bin, args, { env: process.env });
@@ -12,7 +50,8 @@ const call = (bin, args, deadline) => new Promise((resolve) => {
     (error, stdout) => resolve(error ? null : String(stdout || '')));
 });
 
-try {
+if (process.argv[2] === '--session') await session(process.argv[3], process.argv[4]);
+else try {
   const [storePath, input] = process.argv.slice(2);
   const { requests, namespaces, deadline } = JSON.parse(input);
   if (!Number.isFinite(deadline) || Date.now() >= deadline
@@ -33,7 +72,10 @@ try {
       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')];
+      const rows = at < 0 ? [] : JSON.parse(out.slice(at));
+      // A list whose entries lack a string key is a changed contract, not an empty namespace: fail the read.
+      if (!Array.isArray(rows) || rows.some((row) => typeof row?.key !== 'string')) throw new Error('list shape changed');
+      return [namespace, rows.map((row) => row.key)];
     }));
     value = Object.fromEntries(lists);
   }

package/plugin/scripts/agentdb-recall.mjs

@@ -22,10 +22,11 @@ import { safeAction } from './learn-capture.mjs';
 import { redactText } from './continuity-events.mjs';
 import { resolveTurnDb } from './turn-outcome-capture.mjs';
 import { maskExcludedPaths } from './turn-capture-privacy.mjs';
-import { searchOnce, nativeRead, exactReads, searchJsonResult } from './agentdb-recall-process.mjs';
+import { searchOnce, nativeRead, exactReads, searchJsonResult, openBatchSession } 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';
+import { isDirectInvocation } from './entrypoint.mjs';
 export const STORE_FILES = Object.freeze(['memory.db']);
 export const DEFAULT_DEADLINE_MS = 1900;
 export const BLOCK_MAX_BYTES = 600;
@@ -49,8 +50,8 @@ export function recallBinding({ binding = {}, projectRoot, storePath, prompt } =
 }
 
 /** Bounded structural enumeration uses the same cancellable read-only canonical provider. */
-export function enumerateCanonicalKeys({ storePath, namespaces, deadline, signal, env, scratch }) {
-  return nativeRead({ store: { path: storePath }, namespaces, deadline, signal, env, scratch });
+export function enumerateCanonicalKeys({ storePath, namespaces, deadline, signal, env, scratch, session }) {
+  return nativeRead({ store: { path: storePath }, namespaces, deadline, signal, env, scratch, session });
 }
 
 export function applicableRecallLesson(value, projectRoot) {
@@ -115,7 +116,9 @@ function clean(value, limit) {
   return out;
 }
 
-const NOISE_KEY = /^(?:verify[-_]|probe[-_]|test[-_]|rnb-quality-probe|session[-_]|turn[-_]|project-progress[-_]|cevt[-_])/i;
+const MISSING_KNOWLEDGE = /\b(?:cannot\s+(?:be\s+determined|determine)|can(?:'|’)?t\s+(?:be\s+)?determined?|do\s+not\s+know|don(?:'|’)?t\s+know|cannot\s+answer|no\s+(?:verified\s+|supplied\s+|historical\s+)?(?:record|memory|evidence)\s+(?:is\s+)?(?:available|found))\b/i;
+const MISSING_KNOWLEDGE_QUERY = /\b(?:fail(?:ed|ing|ures?)?|missing|unavailable|unknown)\b/i;
+const NOISE_KEY =/^(?:verify[-_]|probe[-_]|test[-_]|rnb-quality-probe|session[-_]|turn[-_]|project-progress[-_]|cevt[-_])/i;
 const SIGNAL_NAMESPACES = new Set(['lessons', 'patterns', 'pattern']);
 /** Turn knowledge is the actual redacted outcome, never its session/transcript wrapper. */
 function turnOutcomeClauses(value, prompt) {
@@ -231,12 +234,12 @@ export function formatBlock({ picks, status, withheld = 0 }) {
 export const SEARCH_BUDGET_SHARE = 0.8;
 export function searchDeadlineFor(started, deadline) { return Math.min(deadline, started + Math.floor((deadline - started) * SEARCH_BUDGET_SHARE)); }
 
-async function consequentialRecall({ prompt, root, store, bin, scratch, env, deadline, binding, signal, enumerateKeys, exclusions, rankedSearch = true }) {
+async function consequentialRecall({ prompt, root, store, bin, scratch, env, deadline, binding, signal, enumerateKeys, exclusions, rankedSearch = true, session }) {
   const searchDeadline = searchDeadlineFor(Date.now(), deadline);
   const phaseBinding = recallBinding({ binding, projectRoot: root, storePath: store.path, prompt });
   const stateNamespaces = checkpointNamespaces(root);
   const namespaces = [...new Set([...stateNamespaces, 'lessons', 'continuity-events'])];
-  const enumeration = await enumerateKeys({ storePath: store.path, namespaces, deadline, signal, env, scratch });
+  const enumeration = await enumerateKeys({ storePath: store.path, namespaces, deadline, signal, env, scratch, session });
   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 = Object.fromEntries(namespaces.map(namespace => [namespace, Array.isArray(enumeration.value?.[namespace]) ? enumeration.value[namespace] : []]));
@@ -276,7 +279,7 @@ async function consequentialRecall({ prompt, root, store, bin, scratch, env, dea
   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 });
+  const exactResults = await exactReads({ candidates, bin, deadline, env, scratch, signal, session });
   // ADR-105 §8: supersession is a link on the NEWER record, computed from every decision record read, plus
   // the tombstones already in the enumeration so a superseder that was not read still retires its target.
   const superseded = tombstonedKeys(keys[path.basename(root)]);
@@ -335,6 +338,8 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
   binding = {}, signal, absoluteDeadline, consequential = false, enumerateKeys = enumerateCanonicalKeys } = {}) {
   const started = Date.now();
   const empty = { block: '', picks: [], stores: [], status: {} };
+  let session = null;
+  let specAbort = null;   // hoisted so `finally` can stop a speculative search that a later throw would orphan
   try {
     if (signal?.aborted) return { ...empty, outcome: 'unavailable', reason: 'cancelled' };
     if (!agentdbFirstEnabled(env)) return { ...empty, outcome: 'disabled' };
@@ -367,7 +372,15 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
     const store = stores[0];
     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 });
+    // ONE owned child answers every list/get of this recall through Ruflo's public memory export (#429); null
+    // (not the real package, no ./memory export, an injected `ruflo`) keeps the per-read CLI route.
+    if (store) {
+      session = openBatchSession({ bin, storePath: store.path, env, deadline, signal, makeCwd: () => {
+        const cwd = fs.mkdtempSync(path.join(scratchFor(store.path), 'run-'));
+        return { cwd, cleanup: () => { try { fs.rmSync(cwd, { recursive: true, force: true }); } catch { /* swept later */ } } };
+      } });
+    }
+    if (consequential) return await consequentialRecall({ prompt, root, store, bin, scratch: scratchFor, env, deadline, binding, signal, enumerateKeys, exclusions, session });
     // 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)])];
@@ -375,12 +388,21 @@ export async function recall({ prompt, projectDir = process.cwd(), env = 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,
     // then spend what remains on ranking.
-    const presence = store ? await nativeRead({ store, namespaces, deadline, env, scratch: scratchFor, signal }) : null;
-    if (presence?.fatal) { return { ...empty, stores, outcome: presence.state === 'timed out' ? 'timed-out' : 'unavailable',
+    // The batch child's start-up (loading Ruflo's memory module, ~0.4 s) and the ranked search are independent, so with a
+    // session the search for the first-choice namespace starts NOW instead of after enumeration (#429 probe: the
+    // sequence left a 1.3-1.6 s tail against the 1.9 s budget). Still ONE search: it is cancelled and replaced only if
+    // enumeration shows that namespace is empty.
+    const specNamespace = path.basename(root);
+    specAbort = new AbortController();
+    const specSignal = signal ? AbortSignal.any([signal, specAbort.signal]) : specAbort.signal;
+    const specArgs = ['--format', 'json', '-q', query, '-n', specNamespace, '--limit', '12'];
+    const spec = session && store ? searchOnce({ ruflo: bin, store, deadline: searchDeadlineFor(Date.now(), deadline), env, scratch: scratchFor, args: specArgs, signal: specSignal }) : null;
+    const presence = store ? await nativeRead({ store, namespaces, deadline, env, scratch: scratchFor, signal, session }) : null;
+    if (presence?.fatal) { specAbort.abort(); return { ...empty, stores, outcome: presence.state === 'timed out' ? 'timed-out' : 'unavailable',
       block: formatBlock({ picks: [], status: presence.state }), reason: 'namespace enumeration failed' }; }
     const sharedKeys = presence?.ok ? async () => ({ ok: true, value: presence.value }) : enumerateCanonicalKeys;
     const curated = store ? await consequentialRecall({ prompt, root, store, bin, scratch: scratchFor, env, deadline, binding, signal,
-      enumerateKeys: sharedKeys, exclusions, rankedSearch: false }).catch(() => null) : null;
+      enumerateKeys: sharedKeys, exclusions, rankedSearch: false, session }).catch(() => null) : null;
     const searchDeadline = searchDeadlineFor(Date.now(), deadline);
     const activeNamespaces = presence?.ok ? namespaces.filter(namespace => presence.value[namespace]?.length) : namespaces;
     // ONE supplementary search (owner ruling 2026-10-12). Measured on a live-size store at load 17: ~10
@@ -389,16 +411,19 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
     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 useSpec = spec && jobs[0]?.namespace === specNamespace;
+    if (!useSpec) specAbort.abort();
     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 }) })));
+      ...await (useSpec ? spec : searchOnce({ ruflo: bin, store: jobStore, deadline: searchDeadline, env, scratch: scratchFor, args, signal })) })));
     let status = results.every((r) => r.state === 'ok') ? 'ok'
       : results.some((r) => r.state === 'timed out') ? 'timed out' : 'unavailable';
-    // Overfetch a bounded six exact values so rejected turn metadata cannot hide
-    // the next useful outcome; at most three verified excerpts are delivered.
-    const candidates = pickRows(results, 6);
+    // Overfetch a bounded twelve exact values (the one search already returns twelve; the exact reads are
+    // one batched reader, so this adds no Ruflo startup) so rejected turn metadata and repeated "cannot
+    // determine" answers cannot hide the next useful outcome (#429); at most three excerpts are delivered.
+    const candidates = pickRows(results, 12);
     // Ruflo previews are ~60 characters. Read the actual selected values within
     // the same deadline so the block contains useful evidence rather than titles.
-    const exactResults = await exactReads({ candidates, bin, deadline, env, scratch: scratchFor, signal });
+    const exactResults = await exactReads({ candidates, bin, deadline, env, scratch: scratchFor, signal, session });
     const retrieved = await Promise.all(candidates.map(async (p) => {
       const r = exactResults.get(p);
       if (r.state === 'ok' && r.value && !r.value.startsWith('[WARN]')) {
@@ -417,6 +442,12 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
       }
       return { pick: null, state: r.state === 'ok' ? 'unavailable' : r.state };
     }));
+    // A turn that admitted it could not answer is evidence of a failed recall, not the missing fact (#429).
+    // It stays available, after concrete outcomes; a query about failures keeps the ranked order.
+    if (!MISSING_KNOWLEDGE_QUERY.test(prompt)) {
+      const rank = ({ pick }) => Number(pick?.namespace === 'turns' && MISSING_KNOWLEDGE.test(pick.preview));
+      retrieved.sort((a, b) => rank(a) - rank(b));
+    }
     const seenClauses = new Set();
     const picks = retrieved.flatMap(({ pick }) => {
       if (!pick) return [];
@@ -452,6 +483,7 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
       authority: false };
     return { block: formatBlock({ picks, status, withheld: curated?.withheld || 0 }), picks, stores, status: { 'memory.db': status }, outcome, receipt };
   } catch (error) { return { ...empty, outcome: 'unavailable', reason: 'canonical recall failed: ' + clean(error.message, 180) }; }
+  finally { specAbort?.abort(); session?.close(); }
 }
 
 async function main() {
@@ -470,7 +502,7 @@ async function main() {
 }
 
 function isMain() {
-  try { return Boolean(process.argv[1]) && fs.realpathSync(process.argv[1]) === fs.realpathSync(fileURLToPath(import.meta.url)); }
+  try { return isDirectInvocation(import.meta.url); }
   catch { return false; }
 }
 if (isMain()) main().catch(() => process.exit(0));

package/plugin/scripts/automatic-update.mjs

@@ -98,7 +98,15 @@ export function automaticInvocation(args, { source, home = os.homedir(), nodePat
     const coordinator = developerCoordinatorOwner({ home });
     if (coordinator.active) {
       if (!coordinator.ready) throw new Error(`coordinated updater is not ready: ${coordinator.reason}`);
-      return { executable: nodePath, args: [coordinator.entry, '--apply'], source: 'developer-suite', coordinator };
+      // Hooks and timers get knowledge only, never the whole suite (brew, cargo, every npm install) under a session TTL
+      // that kills it mid-install (AuditC #10). The full suite runs only from the scheduled runner, which calls the
+      // coordinator directly, not through here.
+      // The registered snapshot moves only when an --update reconciles it, so it can predate --knowledge-only
+      // (4.7.20 and older refuse it: "unsupported developer update argument", exit 1). Pass the flag only to a
+      // coordinator whose source parses it, as runUpdate does for the updater's --result-file.
+      const knowledgeOnly = fs.readFileSync(coordinator.entry, 'utf8').includes("'--knowledge-only'");
+      return { executable: nodePath, args: [coordinator.entry, '--apply', ...(knowledgeOnly ? ['--knowledge-only'] : [])],
+        source: 'developer-suite', coordinator };
     }
   }
   source ??= updateSource({ home });

package/plugin/scripts/brain-confirmation.mjs

@@ -143,7 +143,8 @@ export function confirm({ footprint, env = process.env, home = os.homedir(), now
   const checkable = Boolean(integrity) && fs.existsSync(path.join(roots.kbDir, 'CORPUS-COVERAGE.json'));
   if (checkable && !integrity.valid) knowledgeProblems.push([`the bytes on disk fail the release-coverage check (${integrity.failures?.[0] || 'unknown'})`, UPDATE]);
   // A newer corpus is published and not yet installed (identity, not age): advisory, never a gate.
-  const pending = newerCorpusPending({ source, corpusCheck: readJson(autoUpdatePaths(roots.brainHome).checkFile) });
+  const pending = newerCorpusPending({ source, corpusCheck: readJson(autoUpdatePaths(roots.brainHome).checkFile),
+    installedAtMs: signed ? Date.parse(signature.verifiedAt || '') : NaN });
   if (pending) {
     const lockAt = readJson(autoUpdatePaths(roots.brainHome).lockFile)?.at;
     const running = Number.isFinite(Date.parse(lockAt || '')) && now - Date.parse(lockAt) < AUTO_UPDATE_LOCK_STALE_MS;