ruvnet-brain 4.6.1 → 4.6.3

package/README.md

@@ -1,4 +1,4 @@
-Updated: 2026-10-10 10:41:47 EDT | Version 4.6.1
+Updated: 2026-10-10 10:41:47 EDT | Version 4.6.2
 Created: 2026-06-29 22:36:38 EDT
 
 <div align="center">
@@ -9,7 +9,7 @@ Created: 2026-06-29 22:36:38 EDT
 
 ### Discover the stack. Read the source. Build with confidence.
 
-[![RuvNet Brain version 4.6.1 — README updated 2026-10-10 EDT](https://img.shields.io/badge/version_4.6.1-updated_2026--10--10_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](plugin/.claude-plugin/plugin.json)
+[![RuvNet Brain version 4.6.2 — README updated 2026-10-10 EDT](https://img.shields.io/badge/version_4.6.3-updated_2026--10--10_EDT-1E90FF?style=for-the-badge&labelColor=0757BA)](plugin/.claude-plugin/plugin.json)
 
 **A source-grounded companion for Claude Code and Codex that helps you find and use Reuven Cohen's (rUv's) RuvNet ecosystem.**
 
@@ -259,7 +259,8 @@ The **4.6.0 published-corpus baseline** is **199 public stores · 162,680 public
 Those are bundle census values, not a claim that every upstream repository is fresh today.
 Later corpus publication may advance the knowledge generation independently of code changes.
 
-See [4.6.1 release notes](docs/RELEASE-NOTES-4.6.1.md) and
+See [4.6.2 native update repair notes](docs/RELEASE-NOTES-4.6.2.md),
+[4.6.1 README/admin notes](docs/RELEASE-NOTES-4.6.1.md) and
 [4.6.0 coordinated-update notes](docs/RELEASE-NOTES-4.6.0.md) and the authoritative
 [update and release policy](CONTRIBUTING.md).
 

package/bin/nightly-refresh.mjs

@@ -80,7 +80,11 @@ try {
   if (registration.mode === 'developer-suite') {
     const coordinator = await import(pathToFileURL(modules['developer-update.mjs'].path).href);
     const receipt = await coordinator.runDeveloperUpdate({ mode: 'apply', env: { ...process.env,
-      RUVNET_NIGHTLY_IDENTITY: registration.identity, RUVNET_NIGHTLY: '1' } });
+      RUVNET_NIGHTLY_IDENTITY: registration.identity, RUVNET_NIGHTLY: '1',
+      RUVNET_NIGHTLY_REGISTRATION: registrationPath,
+      RUVNET_NIGHTLY_NODE_PATH: registration.nodePath,
+      RUVNET_NIGHTLY_RUNNER_PATH: registration.runnerPath,
+      RUVNET_NIGHTLY_RUNNER_SHA256: registration.runnerSha256 } });
     console.log(JSON.stringify(receipt));
     process.exit(0);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.6.1",
+  "version": "4.6.3",
   "description": "One-command installer for RuvNet Brain — a portable, source-grounded brain over rUv's RuvNet building blocks, delivered as a Claude Code plugin so Claude uses the stack instead of fighting it.",
   "type": "module",
   "bin": {

package/plugin/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "ruvnet-brain",
   "description": "RuvNet brain transplant for Claude Code — grounds every RuvNet decision in real source across 77 rUv repositories, prefers Ruflo / RuVector-RVF / AgentDB over training-prior defaults (pgvector, Pinecone, hand-rolled cosine), and can pull in any RuvNet repo on demand. Ships a UserPromptSubmit retrieve-and-inject grounding hook and a PreToolUse write gate that refuses ungrounded rUv-product code until search_ruvnet has been consulted (ADR-0012 / ADR-067).",
-  "version": "4.6.1",
+  "version": "4.6.3",
   "author": {
     "name": "Stuart Kerr"
   },

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvnet-brain",
-  "version": "4.6.1",
+  "version": "4.6.3",
   "description": "Source-grounded RuvNet knowledge, lifecycle enforcement, and learning for Codex.",
   "author": {
     "name": "Stuart Kerr"

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

@@ -0,0 +1,118 @@
+/** Owned, deadline-bound native reads and global Ruflo commands for canonical recall. */
+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';
+export function searchJsonResult(stdout) {
+  const s = String(stdout || '');
+  // Live Ruflo prints warnings AFTER the JSON object as well as logs before it.
+  const start = s.indexOf('{'); const end = s.lastIndexOf('}');
+  if (start < 0 || end < start) return { valid: false, rows: [] };
+  try { const rows = JSON.parse(s.slice(start, end + 1)).results;
+    return Array.isArray(rows) && rows.every(r => r && typeof r.key === 'string' && r.key)
+      ? { valid: true, rows } : { valid: false, rows: [] };
+  } catch { return { valid: false, rows: [] }; }
+}
+
+function killGroup(child) {
+  try { if (process.platform !== 'win32') process.kill(-child.pid, 'SIGKILL'); else child.kill('SIGKILL'); }
+  catch { try { child.kill('SIGKILL'); } catch { /* already gone */ } }
+}
+
+/** 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) => {
+    const remaining = deadline - Date.now();
+    if (signal?.aborted || remaining <= 0) { resolve({ rows: [], state: signal?.aborted ? 'unavailable' : 'timed out' }); return; }
+    let cwd;
+    try { cwd = fs.mkdtempSync(path.join(scratch(store.path), 'run-')); } catch { resolve({ rows: [], state: 'unavailable' }); return; }
+    const cleanup = () => { try { fs.rmSync(cwd, { recursive: true, force: true }); } catch { /* swept later as a stale run- dir */ } };
+    let inv;
+    try { inv = invocation ?? rufloInvocation(ruflo, ['memory', operation, '--path', store.path, ...args]); }
+    catch { cleanup(); resolve({ rows: [], state: 'unavailable' }); return; }
+    let child;
+    try {
+      child = spawn(inv.executable, inv.args, { cwd, env: { ...env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_MEMORY_PATH: undefined },
+        stdio: ['ignore', 'pipe', 'ignore'], detached: process.platform !== 'win32', windowsHide: true });
+    } catch { cleanup(); resolve({ rows: [], state: 'unavailable' }); return; }
+    let out = '', outputBytes = 0;
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    let done = false, retiring = null, retirementTimer, timer;
+    const finish = (state, retirement = process.platform === 'win32' ? 'direct-child-only' : 'confirmed') => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      clearTimeout(retirementTimer);
+      signal?.removeEventListener('abort', cancel);
+      cleanup();
+      const parsed = operation === 'search' ? searchJsonResult(out) : null;
+      if (state === 'ok' && parsed && !parsed.valid) state = 'unavailable';
+      resolve({ rows: state === 'ok' && parsed ? parsed.rows : [], value: state === 'ok' ? out.trim() : '', state, retirement });
+    };
+    const retire = state => {
+      if (done || retiring) return;
+      retiring = state; killGroup(child);
+      retirementTimer = setTimeout(() => finish('unavailable', 'unconfirmed'), Math.max(1, deadline - Date.now()));
+    };
+    const cancel = () => retire('unavailable');
+    signal?.addEventListener('abort', cancel, { once: true });
+    // Reserve cleanup inside the same caller deadline; pipe inheritance cannot report success.
+    timer = setTimeout(() => retire('timed out'), Math.max(1, deadline - Date.now() - 100));
+    child.stdout.on('data', c => { if (done || retiring) return; outputBytes += c.length;
+      if (outputBytes > 1 << 20) return retire('unavailable');
+      try { out += decoder.decode(c, { stream: true }); } catch { retire('unavailable'); } });
+    child.on('error', () => retire('unavailable'));
+    child.on('close', code => {
+      killGroup(child); // Successful parent exit must not leave an owned detached grandchild.
+      let valid = true; try { out += decoder.decode(); } catch { valid = false; }
+      const settle = () => {
+        if (done) return;
+        let alive = false;
+        if (process.platform !== 'win32') {
+          try { process.kill(-child.pid, 0); alive = true; } catch (error) { alive = error.code !== 'ESRCH'; }
+        }
+        if (alive && Date.now() < deadline) { retirementTimer = setTimeout(settle, 5); return; }
+        finish(alive || !valid ? 'unavailable' : retiring ?? (code === 0 ? 'ok' : 'failed'), alive ? 'unconfirmed' : undefined);
+      };
+      clearTimeout(retirementTimer); settle();
+    });
+    if (signal?.aborted) cancel();
+  });
+}
+
+/** Isolate synchronous read-only SQLite work inside the same cancellable process budget. */
+export async function nativeRead({ store, requests, namespaces, deadline, env, scratch, signal }) {
+  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 })] } });
+  if (result.state !== 'ok') return { ok: false, fatal: true, state: result.state };
+  try {
+    const parsed = JSON.parse(result.value);
+    if (typeof parsed.ok !== 'boolean') throw new Error('invalid native result');
+    return { ...parsed, state: parsed.ok ? 'ok' : 'unavailable' };
+  } catch { return { ok: false, fatal: true, state: 'unavailable' }; }
+}
+
+export async function exactReads({ candidates, bin, deadline, env, scratch, signal }) {
+  const groups = new Map();
+  for (const candidate of candidates) {
+    const storePath = candidate.storePath;
+    if (!groups.has(storePath)) groups.set(storePath, []);
+    groups.get(storePath).push(candidate);
+  }
+  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 });
+    await Promise.all(rows.map(async (row, index) => {
+      const result = native.ok ? { state: 'ok', value: native.value[index] ?? '' }
+        : native.fatal ? { state: native.state, value: '' }
+        : await searchOnce({ ruflo: bin, store: { path: storePath }, deadline, env, scratch, signal,
+          operation: 'retrieve', args: ['-k', row.key, '-n', row.namespace, '--value-only'] });
+      results.set(row, result);
+    }));
+  }));
+  return results;
+}
+

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

@@ -0,0 +1,22 @@
+/** 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.
+ */
+import { withProgressionReader } from './project-progression-reader.mjs';
+
+try {
+  const [storePath, input] = process.argv.slice(2);
+  const { requests, namespaces, deadline } = JSON.parse(input);
+  if (!Number.isFinite(deadline) || Date.now() >= deadline
+    || requests && (!Array.isArray(requests) || requests.length > 32
+      || 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));
+} catch {
+  process.stdout.write(JSON.stringify({ ok: false, fatal: true }));
+}

package/plugin/scripts/agentdb-recall.mjs

@@ -2,15 +2,16 @@
 /** Prompt-time canonical AgentDB recall (ADR-101, G-022).
  * Every nonempty human prompt searches curated signal, turn outcomes and project/default namespaces in
  * .swarm/memory.db. Recalled records are untrusted evidence, never instructions.
- * Global Ruflo executes in isolated scratch directories; all processes share one
+ * Global Ruflo ranks semantic matches; an isolated read-only child prunes empty namespaces
+ * and batches exact values through the schema-checked canonical reader. All processes share one
  * <=2s deadline. ground-ruvnet.sh delivers <=600 bytes on each eligible prompt.
  */
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { resolveRuflo, rufloInvocation } from './ruflo-bin.mjs';
+import { resolveRuflo } from './ruflo-bin.mjs';
 import { rufloCwdFor, rufloScratchRoot } from './project-progression-store.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { isHarnessGenerated, readStdinBounded } from './hook-input.mjs';
@@ -19,7 +20,9 @@ import { learningTarget, LEARNING_NAMESPACE } from './learning-store.mjs';
 import { safeAction } from './learning-queue.mjs';
 
 import { redactText } from './continuity-events.mjs';
-import { withProgressionReader } from './project-progression-reader.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 { makeLesson } from './lesson-store.mjs';
 export const STORE_FILES = Object.freeze(['memory.db']);
 export const DEFAULT_DEADLINE_MS = 1900;
@@ -39,9 +42,9 @@ export function recallBinding({ binding = {}, projectRoot, storePath, prompt } =
     requestDigest: binding.requestDigest ?? crypto.createHash('sha256').update(String(prompt)).digest('hex') };
 }
 
-/** Bounded enumeration is structural evidence; exact values still come from global Ruflo. */
-function enumerateCanonicalKeys({ storePath, namespaces, deadline, signal }) {
-  return withProgressionReader(storePath, reader => Object.fromEntries(namespaces.map(namespace => [namespace, reader.listKeys(namespace, { maxEntries: 2000 })])), { deadlineAt: deadline, signal });
+/** Bounded structural enumeration uses the same cancellable read-only canonical provider. */
+function enumerateCanonicalKeys({ storePath, namespaces, deadline, signal, env, scratch }) {
+  return nativeRead({ store: { path: storePath }, namespaces, deadline, signal, env, scratch });
 }
 
 export function applicableRecallLesson(value, projectRoot) {
@@ -98,17 +101,6 @@ export function parseSearchJson(stdout) {
   return searchJsonResult(stdout).rows;
 }
 
-function searchJsonResult(stdout) {
-  const s = String(stdout || '');
-  // Live Ruflo prints warnings AFTER the JSON object as well as logs before it.
-  const start = s.indexOf('{'); const end = s.lastIndexOf('}');
-  if (start < 0 || end < start) return { valid: false, rows: [] };
-  try { const rows = JSON.parse(s.slice(start, end + 1)).results;
-    return Array.isArray(rows) && rows.every(r => r && typeof r.key === 'string' && r.key)
-      ? { valid: true, rows } : { valid: false, rows: [] };
-  } catch { return { valid: false, rows: [] }; }
-}
-
 function clean(value, limit) {
   // Redact before truncation so a clipped token cannot escape recognition.
   const text = redactText(value).replace(/[\u0000-\u001f\u007f`]+/g, ' ').replace(/\s+/g, ' ').trim();
@@ -195,7 +187,7 @@ 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))
+  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))
     && 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;
@@ -227,76 +219,15 @@ export function formatBlock({ picks, status }) {
   return render(limit);
 }
 
-function killGroup(child) {
-  try { if (process.platform !== 'win32') process.kill(-child.pid, 'SIGKILL'); else child.kill('SIGKILL'); }
-  catch { try { child.kill('SIGKILL'); } catch { /* already gone */ } }
-}
+/** Semantic ranking gets a bounded slice; exact curated reads keep the rest so load cannot erase all history. */
+export const SEARCH_BUDGET_SHARE = 0.8;
+export function searchDeadlineFor(started, deadline) { return Math.min(deadline, started + Math.floor((deadline - started) * SEARCH_BUDGET_SHARE)); }
 
-/** One ruflo search, bounded by an absolute deadline. Resolves { rows, state } — never rejects. */
-function searchOnce({ ruflo, store, args, deadline, env, scratch, operation = 'search', signal }) {
-  return new Promise((resolve) => {
-    const remaining = deadline - Date.now();
-    if (signal?.aborted || remaining <= 0) { resolve({ rows: [], state: signal?.aborted ? 'unavailable' : 'timed out' }); return; }
-    let cwd;
-    try { cwd = fs.mkdtempSync(path.join(scratch(store.path), 'run-')); } catch { resolve({ rows: [], state: 'unavailable' }); return; }
-    const cleanup = () => { try { fs.rmSync(cwd, { recursive: true, force: true }); } catch { /* swept later as a stale run- dir */ } };
-    let inv;
-    try { inv = rufloInvocation(ruflo, ['memory', operation, '--path', store.path, ...args]); }
-    catch { cleanup(); resolve({ rows: [], state: 'unavailable' }); return; }
-    let child;
-    try {
-      child = spawn(inv.executable, inv.args, { cwd, env: { ...env, RUFLO_DAEMON_AUTOSTART: '0' },
-        stdio: ['ignore', 'pipe', 'ignore'], detached: process.platform !== 'win32', windowsHide: true });
-    } catch { cleanup(); resolve({ rows: [], state: 'unavailable' }); return; }
-    let out = '', outputBytes = 0;
-    const decoder = new TextDecoder('utf-8', { fatal: true });
-    let done = false, retiring = null, retirementTimer, timer;
-    const finish = (state, retirement = process.platform === 'win32' ? 'direct-child-only' : 'confirmed') => {
-      if (done) return;
-      done = true;
-      clearTimeout(timer);
-      clearTimeout(retirementTimer);
-      signal?.removeEventListener('abort', cancel);
-      cleanup();
-      const parsed = operation === 'search' ? searchJsonResult(out) : null;
-      if (state === 'ok' && parsed && !parsed.valid) state = 'unavailable';
-      resolve({ rows: state === 'ok' && parsed ? parsed.rows : [], value: state === 'ok' ? out.trim() : '', state, retirement });
-    };
-    const retire = state => {
-      if (done || retiring) return;
-      retiring = state; killGroup(child);
-      retirementTimer = setTimeout(() => finish('unavailable', 'unconfirmed'), Math.max(1, deadline - Date.now()));
-    };
-    const cancel = () => retire('unavailable');
-    signal?.addEventListener('abort', cancel, { once: true });
-    // Reserve cleanup inside the same caller deadline; pipe inheritance cannot report success.
-    timer = setTimeout(() => retire('timed out'), Math.max(1, deadline - Date.now() - 100));
-    child.stdout.on('data', c => { if (done || retiring) return; outputBytes += c.length;
-      if (outputBytes > 1 << 20) return retire('unavailable');
-      try { out += decoder.decode(c, { stream: true }); } catch { retire('unavailable'); } });
-    child.on('error', () => retire('unavailable'));
-    child.on('close', code => {
-      killGroup(child); // Successful parent exit must not leave an owned detached grandchild.
-      let valid = true; try { out += decoder.decode(); } catch { valid = false; }
-      const settle = () => {
-        if (done) return;
-        let alive = false;
-        if (process.platform !== 'win32') {
-          try { process.kill(-child.pid, 0); alive = true; } catch (error) { alive = error.code !== 'ESRCH'; }
-        }
-        if (alive && Date.now() < deadline) { retirementTimer = setTimeout(settle, 5); return; }
-        finish(alive || !valid ? 'unavailable' : retiring ?? (code === 0 ? 'ok' : 'failed'), alive ? 'unconfirmed' : undefined);
-      };
-      clearTimeout(retirementTimer); settle();
-    });
-    if (signal?.aborted) cancel();
-  });
-}
-
-async function consequentialRecall({ prompt, root, store, bin, scratch, env, deadline, binding, signal, enumerateKeys }) {
+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 enumeration = await enumerateKeys({ storePath: store.path, namespaces, deadline, signal });
+  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;
@@ -306,13 +237,21 @@ async function consequentialRecall({ prompt, root, store, bin, scratch, env, dea
   const decisionKeys = decisionNamespaces.flatMap(namespace => keys[namespace].filter(key => /^decision[-_]|^cevt-.*-decision-/i.test(key)).map(key => ({ category: 'decisions', namespace, key })));
   let relevantDecisions = decisionKeys;
   let decisionAvailability = 'ok-empty';
-  if (decisionKeys.length > 8) {
+  if (decisionKeys.length > 8 && !rankedSearch) {
+    relevantDecisions = decisionKeys.slice(-8);
+    decisionAvailability = 'unavailable'; // unranked newest slice only; not a claim about all decisions
+  } else if (decisionKeys.length > 8) {
     const searched = await Promise.all(decisionNamespaces.map(async namespace => ({ namespace,
-      ...await searchOnce({ ruflo: bin, store, deadline, env, scratch, signal, args: ['--format', 'json', '-q', recallQuery(prompt), '-n', namespace, '--limit', '12'] }) })));
-    if (searched.some(row => row.state !== 'ok')) decisionAvailability = searched.some(row => row.state === 'timed out') ? 'timed-out' : 'unavailable';
+      ...await searchOnce({ ruflo: bin, store, deadline: searchDeadline, env, scratch, signal, args: ['--format', 'json', '-q', recallQuery(prompt), '-n', namespace, '--limit', '12'] }) })));
+    const rankingFailed = searched.some(row => row.state !== 'ok');
+    if (rankingFailed) decisionAvailability = searched.some(row => row.state === 'timed out') ? 'timed-out' : 'unavailable';
     relevantDecisions = searched.flatMap(result => result.rows.filter(row => row.namespace === result.namespace && Number.isFinite(row.score) && row.score >= MIN_RELEVANCE
       && decisionKeys.some(key => key.namespace === row.namespace && key.key === row.key)).map(row => ({ category: 'decisions', namespace: row.namespace, key: row.key, score: row.score })))
       .sort((a, b) => b.score - a.score).slice(0, 8);
+    if (rankingFailed && !relevantDecisions.length) {
+      // Semantic ranking is gone, not the history: read the newest bounded slice natively and keyword-match it exactly.
+      relevantDecisions = decisionKeys.slice(-8);
+    }
     if (!relevantDecisions.length) decisionAvailability = 'unavailable'; // semantic miss is not absent history
   }
   const candidates = [
@@ -323,9 +262,12 @@ async function consequentialRecall({ prompt, root, store, bin, scratch, env, dea
   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 records = [];
+  candidates.forEach(candidate => { candidate.storePath = store.path; });
+  const exactResults = await exactReads({ candidates, bin, deadline, env, scratch, signal });
   await Promise.all(candidates.map(async candidate => {
-    const exact = await searchOnce({ ruflo: bin, store, deadline, env, scratch, operation: 'retrieve', signal, args: ['-k', candidate.key, '-n', candidate.namespace, '--value-only'] });
+    const exact = exactResults.get(candidate);
     if (exact.state !== 'ok' || !exact.value || exact.value.startsWith('[WARN]')) { categories[candidate.category] = /timed out/.test(exact.state) ? 'timed-out' : 'unavailable'; return; }
+    if (maskExcludedPaths(exact.value, exclusions, root) !== exact.value) return;
     let structured; try { structured = JSON.parse(exact.value); } catch { structured = null; }
     const declaredRoot = structured?.projectRoot ?? structured?.scope?.projectRoot;
     if (declaredRoot && declaredRoot !== root || structured?.supersededBy || structured?.superseded === true) {
@@ -347,7 +289,7 @@ async function consequentialRecall({ prompt, root, store, bin, scratch, env, dea
   let limit = 350;
   while (limit > 0 && Buffer.byteLength(render(limit)) > CONSEQUENTIAL_BLOCK_MAX_BYTES) limit--;
   const block = render(limit);
-  return { block, picks: selected, stores: [store], status: { 'memory.db': outcome }, outcome, categories,
+  return { block, picks: selected, stores: [store], status: { 'memory.db': outcome }, outcome, categories, enumerated: true,
     receipt: { schemaVersion: 1, kind: 'canonical-memory-recall', binding: phaseBinding, outcome, categories,
       observedAt: new Date().toISOString(), deadline, queryDigest: crypto.createHash('sha256').update(String(prompt)).digest('hex'),
       records: selected.map(({ category, namespace, key, storePath, valueDigest }) => ({ category, namespace, key, storePath, valueDigest })), authority: false } };
@@ -365,7 +307,15 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
     const budget = Number.isFinite(requested) && requested > 0 ? Math.min(requested, 1900) : DEFAULT_DEADLINE_MS;
     const deadline = Math.min(started + budget, absoluteDeadline ?? Infinity);
     if (deadline <= started) return { ...empty, outcome: 'timed-out' };
-    const { root, stores } = agentdbStores(projectDir, Math.max(1, Math.min(100, Math.floor(budget / 4))));
+    const gitTimeoutMs = Math.max(1, Math.min(600, Math.floor(budget / 3)));
+    const privacy = resolveTurnDb({ projectDir, brainHome: env.RUVNET_BRAIN_HOME || path.join(env.HOME || os.homedir(), '.cache', 'ruvnet-brain'), gitTimeoutMs, deadlineAt: deadline, signal });
+    if (privacy.skipped) {
+      const outcome = /opt-out/.test(privacy.skipped) ? 'disabled' : /no project memory db/.test(privacy.skipped) ? 'not-adopted' : 'unavailable';
+      return { ...empty, outcome, reason: privacy.skipped, block: outcome === 'unavailable' ? formatBlock({ picks: [], status: 'unavailable privacy policy' }) : '' };
+    }
+    const exclusions = privacy.contentPathExcludes;
+    const root = privacy.projectRoot; const stores = [];
+    try { if (fs.statSync(privacy.db).isFile()) stores.push({ name: 'memory.db', path: privacy.db }); } catch { /* absent */ }
     recallBinding({ binding, projectRoot: root, storePath: stores[0]?.path ?? null, prompt });
     let learningStore;
     try {
@@ -381,14 +331,26 @@ 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 });
-    const namespaces = [...new Set(['lessons', 'patterns', 'pattern', 'turns', path.basename(root), 'default'])];
+    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;
-    const jobs = (store ? namespaces : []).flatMap((namespace) => [{ store, namespace, family: null, args: ['--format', 'json', '-q', query, '-n', namespace, '--limit', '12'] },
+    // 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,
+    // 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',
+      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;
+    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))
@@ -396,7 +358,7 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
     if (learningStore && workflowQuery) jobs.push({ store: learningStore, namespace: LEARNING_NAMESPACE, family: null,
       args: ['--format', 'json', '-q', workflowQuery, '-n', LEARNING_NAMESPACE, '-t', 'keyword', '--limit', '4'] });
     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, env, scratch: scratchFor, args, signal }) })));
+      ...await 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
@@ -404,13 +366,21 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
     const candidates = pickRows(results, 6);
     // 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 retrieved = await Promise.all(candidates.map(async (p) => {
-      const r = await searchOnce({ ruflo: bin, store: { name: 'memory.db', path: p.storePath }, deadline, env, scratch: scratchFor, operation: 'retrieve',
-        args: ['-k', p.key, '-n', p.namespace, '--value-only'], signal });
+      const r = exactResults.get(p);
       if (r.state === 'ok' && r.value && !r.value.startsWith('[WARN]')) {
+        if (maskExcludedPaths(r.value, exclusions, root) !== r.value || maskExcludedPaths(p.key, exclusions, root) !== p.key) return { pick: null, state: r.state };
+        let event;
+        if (p.namespace === 'continuity-events') {
+          try { event = JSON.parse(r.value); } catch { return { pick: null, state: r.state }; }
+          if (event.schema !== 'ruvnet-brain.continuity-event' || event.schemaVersion !== 1 || event.project !== root
+            || !['decision', 'lesson', 'open-item'].includes(event.kind) || typeof event.summary !== 'string'
+            || !promptKeywords(prompt, 14).some(word => redactText(event.summary).toLowerCase().includes(word))) return { pick: null, state: r.state };
+        }
         const clauses = p.namespace === 'turns' ? turnOutcomeClauses(r.value, prompt) : null;
         const preview = p.namespace === LEARNING_NAMESPACE ? learningObservationExcerpt(r.value)
-          : clauses ? turnOutcomeExcerpt(r.value, prompt) : evidenceExcerpt(r.value, p.key, prompt);
+          : event ? clean(event.summary, 280) : clauses ? turnOutcomeExcerpt(r.value, prompt) : evidenceExcerpt(r.value, p.key, prompt);
         return { pick: preview ? { ...p, preview, clauses, valueDigest: crypto.createHash('sha256').update(r.value).digest('hex') } : null, state: 'ok' };
       }
       return { pick: null, state: r.state === 'ok' ? 'unavailable' : r.state };
@@ -427,6 +397,19 @@ export async function recall({ prompt, projectDir = process.cwd(), env = process
       });
       return unique.length ? [{ ...p, preview: clean('OUTCOME: ' + unique.join(' '), 280) }] : [];
     }).slice(0, 3);
+    // Curated exact records were read before ranking and are already verified: they lead, ranked hits fill the
+    // rest, deduplicated by (namespace, key). Ranked search failing or finding nothing never discards them, and
+    // everything leaves through formatBlock so the prompt path stays within BLOCK_MAX_BYTES.
+    const exactCurated = (curated?.picks ?? []).map(p => ({ store: 'memory.db', storePath: p.storePath, key: p.key, namespace: p.namespace,
+      score: 1, preview: p.preview, valueDigest: p.valueDigest }));
+    const seenKeys = new Set(exactCurated.map(p => `${p.namespace}\u0000${p.key}`));
+    const merged = [...exactCurated, ...picks.filter(p => !seenKeys.has(`${p.namespace}\u0000${p.key}`))].slice(0, 3);
+    picks.length = 0; picks.push(...merged);
+    // A failed curated read of state or lessons is not empty history: it must surface even when ranked search was ok.
+    // (Decisions are unranked by design in this pass, so their availability marker is not folded in.)
+    if (status === 'ok' && curated?.enumerated && ['state', 'lessons'].some(c => ['timed-out', 'unavailable'].includes(curated.categories?.[c]))) {
+      status = ['state', 'lessons'].some(c => curated.categories[c] === 'timed-out') ? 'timed out reading curated records' : 'unavailable curated records';
+    }
     if (retrieved.some((r) => r.state !== 'ok')) status = retrieved.some((r) => r.state === 'timed out') ? 'timed out reading exact values' : 'unavailable exact values';
     const outcome = status === 'ok' ? (picks.length ? 'ok-with-results' : 'ok-empty') : /timed out/.test(status) ? 'timed-out' : 'unavailable';
     const receipt = { schemaVersion: 1, kind: 'canonical-memory-recall', outcome,

package/plugin/scripts/continuity-events.mjs

@@ -28,6 +28,7 @@
  * detail.status: 'detected-unconfirmed'`, written only to the project's own local store; the brief never
  * presents one as a standing rule. RUVNET_CONTINUITY_LESSON_DETECT=off turns that detector off.
  */
+import { nativeTurnLines } from './native-turn-transcript.mjs';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -265,12 +266,12 @@ function exitOutcome(result) {
 }
 
 /**
- * Typed events from one Claude JSONL turn. Codex rollouts are not parsed (project-progression-sources
- * declares that format unknown); Codex gets decisions/lessons from `last_assistant_message` only.
+ * Typed events from the current native turn. Codex JSONL is normalized mechanically; opaque
+ * custom-tool orchestration inputs cannot manufacture a gate outcome or semantic decision.
  */
 export function collectTurnEvents({ lines = null, lastAssistantMessage = '', host, session, project, env = process.env, at = Date.now() }) {
   const events = [];
-  const turn = lines ? currentTurnRecords(lines) : { userMessage: '', records: [] };
+  const turn = lines ? currentTurnRecords(nativeTurnLines(lines, host)) : { userMessage: '', records: [] };
   const uses = new Map();
   const assistantTexts = [];
   for (const rec of turn.records) {
@@ -306,9 +307,9 @@ export function collectTurnEvents({ lines = null, lastAssistantMessage = '', hos
   for (const text of assistantTexts) {
     for (const line of text.split('\n')) {
       if (DECISION_LINE.test(line)) {
-        events.push(makeEvent({ kind: 'decision', at, host, session, project, source: 'assistant-detected', authoritative: false, summary: line.replace(/\*\*/g, '') }));
+        events.push(makeEvent({ kind: 'decision', at, host, session, project, source: 'assistant-detected', authoritative: false, detail: { status: 'detected-unconfirmed' }, summary: line.replace(/\*\*/g, '') }));
       } else if (LESSON_LINE.test(line)) {
-        events.push(makeEvent({ kind: 'lesson', at, host, session, project, source: 'assistant-detected', authoritative: false, summary: line.replace(/\*\*/g, '') }));
+        events.push(makeEvent({ kind: 'lesson', at, host, session, project, source: 'assistant-detected', authoritative: false, detail: { status: 'detected-unconfirmed' }, summary: line.replace(/\*\*/g, '') }));
       }
     }
   }