ruvnet-brain 4.6.2 → 4.6.4

package/plugin/scripts/project-transition-hook.mjs

@@ -15,7 +15,7 @@ import { normalizeHostEvent } from './hook-input.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
 import { withProgressionReader } from './project-progression-reader.mjs';
 import { redactProgression, restoreProjectProgression, digestCanonical, validateProgressionSnapshot } from './project-progression-contract.mjs';
-import { runSessionSnapshotHook, effectiveBudgetMs, queueCapture, replayOutboxDetached, runOutboxReplay } from './session-snapshot-hook.mjs';
+import { runSessionSnapshotHook, queueCapture, replayOutboxDetached } from './session-snapshot-hook.mjs';
 
 const EVENTS = new Set(['UserPromptSubmit', 'PreToolUse', 'PostToolUse', 'PostToolUseFailure', 'SubagentStop']);
 const TOPICS = [
@@ -197,8 +197,23 @@ export function captureNormalizedTransition(job, { readHistory = readTransitionH
   return { ...result, eventId: normalized.observation.id };
 }
 
+/** Queued work older than this is no longer in flight; the boundary says so (continuity-journal STUCK_AFTER_MS). */
+export const QUEUE_STUCK_AFTER_MS = 10 * 60_000;
+
+/**
+ * Prompt and tool boundaries (UserPromptSubmit, PreToolUse, PostToolUse, PostToolUseFailure,
+ * SubagentStop) do only bounded, local work: consent and identity, fsync the observation into the
+ * durable queue, hand the queue to the detached replay worker, return. No native store write runs
+ * inline. Measured 2026-10-11: each inline commit cost one ~3 s native write per boundary, queued
+ * debt made every later boundary spend its full 6.5 s budget, and under load the host killed the
+ * hook at its 10 s timeout and discarded its output. A queued-and-handed-off observation is the
+ * NORMAL state and says nothing; only an unwritable queue or work stuck past
+ * QUEUE_STUCK_AFTER_MS is reported. Exact readback is unchanged: the worker commits each item only
+ * by exact readback (captureNormalizedTransition), and Stop/PreCompact/SessionEnd keep their own
+ * bounded synchronous budgets.
+ */
 export function runProjectTransitionHook(projectDir, event, { payload = {}, host = process.env.RUVNET_HOOK_HOST || 'claude',
-  readHistory = readTransitionHistory, capture = runSessionSnapshotHook, env = process.env } = {}) {
+  env = process.env, spawnReplay = replayOutboxDetached, now = Date.now } = {}) {
   if (developmentHooksSuspended(projectDir)) return { state: 'skipped', reason: 'development hooks suspended' };
   const suspended = automaticProgressionSuspensionResult(env, { state: 'suspended', reason: 'automatic project progression is operator-suspended' });
   if (suspended) return suspended;
@@ -218,12 +233,16 @@ export function runProjectTransitionHook(projectDir, event, { payload = {}, host
     payload: { session_id: payload.session_id, hook_event_name: transportEvent,
       normalizedTransition: { observation, sourceIdentity: observeTransitionSource(resolution, projectDir) } } });
   if (!queued) return { state: 'degraded', reason: 'normalized observation queue unwritable', eventId: observation.id };
-  let result = null;
-  runOutboxReplay({ projectDir: resolution.projectRoot, env, budgetMs: Math.min(6500, effectiveBudgetMs(env)),
-    captureNormalized: (job, options) => captureNormalizedTransition(job, { ...options, env, readHistory, capture }),
-    onCaptured: (captured) => { if (captured?.eventId === observation.id) result = captured; } });
-  if (!result?.receipt) replayOutboxDetached({ projectDir: resolution.projectRoot, env });
-  return { state: result?.progressionCaptured && result.receipt ? 'committed' : 'pending', eventId: observation.id, result };
+  const handed = spawnReplay({ projectDir: resolution.projectRoot, env });
+  let oldest = Infinity;
+  try {
+    for (const name of fs.readdirSync(path.join(resolution.projectRoot, '.swarm'))) {
+      if (!/^\.progression-capture-(?:queue|claimed)-.*\.json$/.test(name)) continue;
+      oldest = Math.min(oldest, fs.statSync(path.join(resolution.projectRoot, '.swarm', name)).mtimeMs);
+    }
+  } catch { /* the observation itself is already durable */ }
+  if (now() - oldest > QUEUE_STUCK_AFTER_MS) return { state: 'stuck', eventId: observation.id, handed, oldestQueuedAt: new Date(oldest).toISOString() };
+  return { state: 'queued', eventId: observation.id, handed };
 }
 
 /** One pending-readback condition across prompt/tool boundaries and both CLI entrypoints. */
@@ -238,8 +257,10 @@ if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.me
     const payload = JSON.parse(fs.readFileSync(0, 'utf8') || '{}');
     const projectDir = payload.cwd || process.env.CLAUDE_PROJECT_DIR || process.cwd();
     const result = runProjectTransitionHook(projectDir, process.argv[2], { payload });
-    if (result.state === 'pending') {
-      const message = transitionPendingNotice(projectDir, payload, 'Project memory transition is pending; exact AgentDB readback was not verified at this boundary.');
+    if (result.state === 'stuck' || result.state === 'degraded') {
+      const message = transitionPendingNotice(projectDir, payload, result.state === 'stuck'
+        ? `Project memory capture is stuck: queued work since ${result.oldestQueuedAt} has not been committed by exact readback.`
+        : 'Project memory capture degraded: the observation queue is unwritable.');
       if (message) process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: process.argv[2], additionalContext: message } }));
     }
   } catch { process.stdout.write(JSON.stringify({ systemMessage: 'Project memory transition capture degraded; exact readback was not verified.' })); }

package/plugin/scripts/session-snapshot-hook.mjs

@@ -15,6 +15,7 @@ import { projectDirectory } from './project-identity.mjs';
 import { buildProjectProgression } from './project-progression-producer.mjs';
 import { ProjectProgressionStore } from './project-progression-store.mjs';
 import { resolveProjectStore } from './project-store-resolver.mjs';
+import { ensureProjectMemory } from './project-memory-enrollment.mjs';
 import { resolveTurnDb, captureTurnOutcome } from './turn-outcome-capture.mjs';
 import { captureContinuityEvents, stopNotice } from './continuity-journal.mjs';
 import { automaticProgressionSuspensionResult } from './project-progression-suspension.mjs';
@@ -129,6 +130,7 @@ export function runSessionSnapshotHook(projectDir, event, {
   spawnReplay = replayOutboxDetached,
   ordered = null,
   captureEvents = captureContinuityEvents,
+  enrollMemory = ensureProjectMemory,
   deadlineAt: inheritedDeadlineAt = Infinity,
   signal,
 } = {}) {
@@ -136,6 +138,11 @@ export function runSessionSnapshotHook(projectDir, event, {
   const checkDeadline = () => { if (signal?.aborted || now() >= deadlineAt) throw new Error('restore deadline exceeded'); };
   const suspended = (reason) => ({ metadataWritten: false, progressionCaptured: false, receipt: null, skipped: reason,
     turn: { event, recorded: false, skipped: reason }, continuity: { event, recorded: 0, launched: false, skipped: reason } });
+  let enrollmentPayload = {};
+  try { enrollmentPayload = rawInput ? JSON.parse(rawInput) : {}; } catch { /* malformed payload */ }
+  const enrollment = enrollMemory({ projectDir, env, event, payload: enrollmentPayload, host, deadlineAt });
+  if (enrollment.state === 'pending') return { ...suspended('native project memory enrollment pending'), enrollment };
+  if (enrollment.state === 'disabled' || enrollment.state === 'unavailable') return { ...suspended(enrollment.reason), enrollment };
   // Consent is checked before metadata, transcript inspection or any durable capture queue.
   try {
     checkDeadline();
@@ -316,8 +323,13 @@ if (process.argv[1] && path.resolve(process.argv[1]).endsWith('session-snapshot-
     const payload = JSON.parse(fs.readFileSync(0, 'utf8') || '{}');
     const projectDir = payload.cwd || projectDirectory();
     const result = runProjectTransitionHook(projectDir, process.argv[2], { payload });
-    if (result.state === 'pending') {
-      const message = transitionPendingNotice(projectDir, payload, 'Project memory transition remains pending; exact readback was not verified.');
+    // ADR-106: learning capture rides this boundary instead of a second PostToolUse registration.
+    if (process.argv[2] === 'PostToolUse') { try { (await import('./learn-capture.mjs')).captureLearning(payload); } catch { /* advisory */ } }
+    // A queued, handed-off observation is normal and silent (ADR-106); only stuck or degraded speaks.
+    if (result.state === 'stuck' || result.state === 'degraded') {
+      const message = transitionPendingNotice(projectDir, payload, result.state === 'stuck'
+        ? `Project memory capture is stuck: queued work since ${result.oldestQueuedAt} has not been committed by exact readback.`
+        : 'Project memory capture degraded: the observation queue is unwritable.');
       if (message) process.stdout.write(JSON.stringify({ systemMessage: message }));
     }
   } catch { process.stdout.write(JSON.stringify({ systemMessage: 'Project memory transition capture degraded; exact readback was not verified.' })); }
@@ -333,6 +345,10 @@ if (process.argv[1] && path.resolve(process.argv[1]).endsWith('session-snapshot-
       if (typeof cwd === 'string' && path.isAbsolute(cwd)) originProjectDir = cwd;
     } catch { /* malformed input keeps the host's project fallback */ }
     const result = runSessionSnapshotHook(originProjectDir, process.argv[2] || 'SessionEnd', { rawInput });
+    // ADR-106: learning recovery rides SessionEnd instead of a second SessionEnd registration.
+    if ((process.argv[2] || 'SessionEnd') === 'SessionEnd') {
+      import('./learn-capture.mjs').then((m) => m.scheduleLearningRecovery({ cwd: originProjectDir })).catch(() => {});
+    }
     // FAIL LOUDLY, NEVER SILENTLY — AND ONCE. When recording is stuck (events pending past STUCK_AFTER_MS,
     // a quarantined conflict, a corrupt outbox line, a cap drop) Claude Code shows this systemMessage, at
     // most once per session per condition (stopNotice; it used to repeat at every turn). "Not applicable"

package/plugin/scripts/session-start-core.mjs

@@ -26,6 +26,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { enrollmentPlan } from './project-memory-enrollment.mjs';
 import { restoreWithBrief } from './continuity-brief.mjs';
 import { turnRecordingStatus } from './turn-outcome-capture.mjs';
 import {
@@ -33,6 +34,7 @@ import {
 } from './session-start-fsutil.mjs';
 import { maintainerIssueEntitlement, surfaceIssuePointer } from './session-start-issue-alert.mjs';
 import { surfaceSignals } from './session-start-signals.mjs';
+import { failureLine, FAILURE_LINE_PREFIX } from './hook-failures.mjs';
 import { brainState, health, knowledgeCurrency, mcpReadiness, KNOWLEDGE_LINE_PREFIX } from './session-start-health.mjs';
 import { stableSpine, heartbeat, knowledgeAutoUpdate, footprintCheck } from './session-start-update-plane.mjs';
 import { FOOTPRINT_LINE_PREFIX } from './brain-confirmation.mjs';
@@ -97,6 +99,7 @@ export async function runSessionStart({
   probeConsoleAlias = probeCodexConsoleAlias,
   startedAt = Date.now(),
   deadlineAt = Infinity,
+  scheduleRecovery = true,
 } = {}) {
   const hookDeadlineAt = Math.min(deadlineAt, sessionStartDeadlineAt({ host: env.RUVNET_HOOK_HOST || 'claude', env, startedAt }));
   const lines = [];
@@ -136,7 +139,8 @@ export async function runSessionStart({
       || s.startsWith('[RuvNet Brain — PROJECT CONTINUITY UNKNOWN]')
       || s.startsWith('[RuvNet Brain — PROJECT CONTINUITY RESTORED]')
       || s.startsWith('[RuvNet Brain — COME UP TO SPEED')
-      || s.startsWith('[RuvNet Brain — MAINTAINER ONLY:');
+      || s.startsWith('[RuvNet Brain — MAINTAINER ONLY:')
+      || s.startsWith(FAILURE_LINE_PREFIX);
   };
   // An alarm's HEADER line always matches isSafeStatus on its own dedicated prefix (above); its
   // explanatory BODY lines do not, and without this they were silently dropped — a real gap this
@@ -169,6 +173,8 @@ export async function runSessionStart({
   const home = env.HOME || env.USERPROFILE || os.homedir();
   const stateDir = env.RUVNET_BRAIN_HOME || path.join(home, '.cache', 'ruvnet-brain');
   resetInjectionDedupe(stateDir, Date.now());
+  // ADR-106: advisory hooks fail open, so a failed one is reported here, once, never per fire.
+  try { const failed = failureLine(stateDir); if (failed) emit(failed); } catch { /* the summary must not cost the session */ }
   const hookDir = path.dirname(fileURLToPath(import.meta.url));
   const now = Date.now();
   const consoleInvoke = env.RUVNET_HOOK_HOST === 'codex' ? '$ruvnet-brain:rnbc' : '/rnbc';
@@ -189,6 +195,11 @@ export async function runSessionStart({
     }
   };
 
+  // Report only. SessionStart never creates or bootstraps a store (ADR-105 rule 6); enrollment starts at the first
+  // consented captured boundary, so a session that merely started leaves no store behind.
+  let enrollment;
+  try { enrollment = enrollmentPlan({ projectDir: cwd, env, deadlineAt: hookDeadlineAt }); } catch (error) { enrollment = { state: 'unavailable', reason: error.message }; }
+  if (enrollment.state === 'pending' || enrollment.state === 'unavailable') emit(`[RuvNet Brain — TURN CAPTURE] Project memory enrollment ${enrollment.state}; restoration is not yet proven.`);
   const restoreStart = Date.now();
   const restoreDeadlineAt = Math.min(hookDeadlineAt, restoreStart + STAGE_BUDGETS_MS.restore);
   const restoreController = new AbortController();
@@ -443,6 +454,9 @@ export async function runSessionStart({
   stdout.write(output);
   trace('body-finished');
   recordProof({ stages: tracer.table(), restore: restoreProof, bodyFailed, bannerFallback: !bannerEmitted });
+  // ADR-106: learning recovery rides SessionStart instead of a second SessionStart registration.
+  // learningContext() inside owns consent and brain-off; the detached worker is never awaited.
+  if (scheduleRecovery) { try { (await import('./learn-capture.mjs')).scheduleLearningRecovery({ cwd, env }); } catch { /* advisory */ } }
   return { ok: true, outputBytes: Buffer.byteLength(output, 'utf8'), platform };
 }
 

package/plugin/scripts/turn-outcome-capture.mjs

@@ -23,11 +23,9 @@
  *   • Content = assistant outcome text, files changed, Bash descriptions. NEVER raw user text (a
  *     2026-07-13 measurement: prompt echoes made 87% of a store noise). Trivial turns are skipped.
  *
- * CODEX: codex-cli 0.158.0's own `stop.command.input` schema (read from the installed binary
- * 2026-09-29) carries `last_assistant_message` (nullable) and `transcript_path` (nullable).
- * The Codex rollout format is NOT parsed: project-progression-sources.mjs already declares it
- * unknown, and the rollout records observed locally (custom_tool_call / function_call with free-form
- * inputs) give no stable file-change shape. Codex records therefore carry the outcome text only.
+ * CODEX: native response_item JSONL is normalized mechanically through native-turn-transcript.
+ * SessionEnd and PreCompact recover a closing outcome when Stop payload text is absent. Tool IDs
+ * correlate observable gate outcomes; opaque custom orchestration inputs remain unclassified.
  *
  * LATENCY: Stop runs synchronously in the host's turn, and one `ruflo memory store` costs ~0.7s
  * (measured). So the writes run in ONE detached worker (this file, `--run-steps`), store then
@@ -40,9 +38,11 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { spawn, spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { nativeTurnLines } from './native-turn-transcript.mjs';
 import { resolveRuflo, rufloInvocation } from './ruflo-bin.mjs';
-import { redactText, userLevelAgentdbHooks } from './continuity-events.mjs';
-import { resolveProjectStore } from './project-store-resolver.mjs';
+import { rufloCwdFor, rufloScratchRoot } from './project-progression-store.mjs';
+import { redactText } from './continuity-events.mjs';
+import { resolveProjectStore, globalEnrollmentAllowed } from './project-store-resolver.mjs';
 import { digest, journalTurn, readJournal, pendingTurnFiles, acknowledgeJournal, appendReceipt, storeData } from './turn-transport-journal.mjs';
 import { contentPathExcludes, pathIsExcluded, privateTurn, maskExcludedPaths, captureFailureReason, firstTurnCaptureNotice } from './turn-capture-privacy.mjs';
 
@@ -162,7 +162,7 @@ const consentMap = (value) => value !== null && typeof value === 'object'
   && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype
   && Object.values(value).every((setting) => setting === 'on' || setting === 'off');
 
-export function resolveTurnDb({ projectDir, brainHome, requestedStorePath, gitTimeoutMs = 1000, unknownOriginalPath = false, deadlineAt = Infinity, signal } = {}) {
+export function resolveTurnDb({ projectDir, brainHome, requestedStorePath, gitTimeoutMs = 1000, unknownOriginalPath = false, deadlineAt = Infinity, signal, enrollmentRoots = {} } = {}) {
   if (signal?.aborted || Date.now() >= deadlineAt) throw new Error('restore deadline exceeded');
   const resolved = resolveProjectStore({ projectDir, requestedStorePath, gitTimeoutMs, deadlineAt });
   if (signal?.aborted || Date.now() >= deadlineAt) throw new Error('restore deadline exceeded');
@@ -173,12 +173,14 @@ export function resolveTurnDb({ projectDir, brainHome, requestedStorePath, gitTi
     try {
       policy = JSON.parse(fs.readFileSync(file, 'utf8'));
       if (policy?.schemaVersion !== 1 || !consentMap(policy.projects)
+        || (Object.hasOwn(policy, 'default') && !['on', 'off'].includes(policy.default))
         || (Object.hasOwn(policy, 'paths') && !consentMap(policy.paths))) throw new Error('invalid policy');
       contentPathExcludes(policy.contentPathExcludes);
     } catch { return { skipped: 'turn capture policy unreadable or invalid', projectRoot: resolved.projectRoot }; }
   }
   // A path rule wins over a project rule, allowing a linked checkout/subdirectory to opt out.
-  const setting = policy.paths?.[capturePath] ?? policy.projects?.[resolved.projectRoot];
+  const explicitSetting = policy.paths?.[capturePath] ?? policy.projects?.[resolved.projectRoot];
+  const setting = explicitSetting ?? policy.default;
   if (setting !== undefined && !['on', 'off'].includes(setting)) return { skipped: 'invalid turn capture consent', projectRoot: resolved.projectRoot };
   const db = resolved.canonicalAgentDbPath;
   const exclusions = contentPathExcludes(policy.contentPathExcludes);
@@ -191,6 +193,9 @@ export function resolveTurnDb({ projectDir, brainHome, requestedStorePath, gitTi
   if (setting === 'off') return { db, scope: 'project', capturePath, projectRoot: resolved.projectRoot, skipped: 'persisted turn capture opt-out' };
   let exists = false;
   try { exists = fs.statSync(db).isFile(); } catch { /* absent */ }
+  if (!exists && setting === 'on' && explicitSetting !== 'on' && !globalEnrollmentAllowed({ resolution: resolved, brainHome, ...enrollmentRoots })) {
+    return { db, scope: 'project', capturePath, projectRoot: resolved.projectRoot, skipped: 'global capture consent requires a safe Git project root; explicit project/path opt-in required' };
+  }
   if (!exists && setting !== 'on') return { db, scope: 'project', capturePath, projectRoot: resolved.projectRoot, skipped: 'no project memory db; persisted opt-in required' };
   return { db, scope: 'project', capturePath, projectRoot: resolved.projectRoot, optedIn: setting === 'on',
     contentPathExcludes: exclusions };
@@ -282,24 +287,17 @@ export function captureTurnOutcome({
   const project = projectName(projectRoot);
   const receipts = path.join(brainHome, 'turn-capture', 'receipts.jsonl');
 
-  // ONE WRITER PER TURN (ADR-100 §3). Measured 2026-10-01 on this repo's real store: 624 `turns` rows
-  // in five days for 323 distinct outcomes — this writer (host-tagged) and the owner's user-level
-  // ~/.claude/hooks/agentdb-turn-capture.mjs both recorded every Claude turn. The user-level hook is
-  // the owner's and is never edited by the product, so where it is registered the product DEFERS
-  // (RUVNET_TURN_CAPTURE=force keeps both). Codex turns are not seen by that Claude-only hook.
-  const deferTo = event === 'Stop' && host === 'claude' && String(env.RUVNET_TURN_CAPTURE || '').toLowerCase() !== 'force'
-    && userLevelAgentdbHooks({ home, event, projectDir, env }).turnCapture;
-  if (deferTo) {
-    report.skipped = 'deferred: an enabled user-level Stop writer explicitly targets the canonical turn store; actual native delivery is unproven';
-    report.deferredToUserLevel = true;
-  } else if (event === 'Stop') {
+  // ONE WRITER PER TURN (ADR-105 §7): the product is the only writer of project turn history. The
+  // former deferral to a user-level ~/.claude hook (ADR-100 §3) could never fire — its probe never
+  // reported a writer — and cost a git call on every Stop, so it was removed (ADR-106).
+  if (['Stop', 'SessionEnd', 'PreCompact'].includes(event)) {
     const sessionKey = String(payload.session_id || payload.transcript_path || '');
     const message = typeof payload.last_assistant_message === 'string' ? payload.last_assistant_message.trim() : '';
     let turn = { finalText: '', files: [], actions: [] };
-    if (host === 'claude' && typeof payload.transcript_path === 'string' && payload.transcript_path) {
+    if (typeof payload.transcript_path === 'string' && payload.transcript_path) {
       // With the closing message in hand, the transcript is read immediately (tool calls are already
       // flushed); without it, wait for the closing message to land, bounded.
-      try { turn = claudeTurn(readTranscript(payload.transcript_path, { maxMs: message ? 0 : settleMs })); } catch { /* unreadable */ }
+      try { turn = claudeTurn(nativeTurnLines(readTranscript(payload.transcript_path, { maxMs: message || event !== 'Stop' ? 0 : settleMs }), host)); } catch { /* unreadable */ }
     }
     if (message && (message.length >= MIN_OUTCOME_CHARS || message.length >= turn.finalText.length)) turn.finalText = message;
     turn = privateTurn(turn, target.contentPathExcludes, target.capturePath);
@@ -323,12 +321,12 @@ export function captureTurnOutcome({
           catch (error) { return { ...report, skipped: `durable turn queue invalid: ${redactText(error.message)}` }; }
         }
         steps.push({ ...binding, kind: 'store', ruflo, args: ['memory', 'store', '-k', key, '--value', value, '-n', TURN_NAMESPACE,
-          '--path', db, '--no-upsert', '--tags', `project=${project},host=${host}`, '--provenance', 'agent_output'] });
+          '--path', db, '--no-upsert', '--require-native', '--append-only', '--tags', `project=${project},host=${host}`, '--provenance', 'agent_output'] });
         // This synchronous boundary proves only queuing; the worker's exact receipt proves recording.
         Object.assign(report, { queued: true, key, value });
       }
     }
-  } else report.skipped = `turn outcomes are recorded at Stop, not ${event}`;
+  } else report.skipped = `no turn outcome capture at ${event}`;
 
   if (event === 'SessionEnd' || event === 'PreCompact') {
     if (!fs.existsSync(db)) report.distill = { queued: false, skipped: 'no memory db to distill yet' };
@@ -376,7 +374,7 @@ export function runSteps({ steps = [], receipts } = {}, { run: suppliedRun = spa
   };
   const results = [];
   for (const queued of steps) {
-    let status = 1; let error = null; let verified = false; let db = ''; let key; let privacyPatterns = [];
+    let status = 1; let error = null; let skipped = null; let verified = false; let db = ''; let key; let privacyPatterns = [];
     const kind = queued.kind === 'journal' ? 'store' : queued.kind;
     try {
       if (String(env.RUVNET_TURN_CAPTURE || '').toLowerCase() === 'off') throw new Error('RUVNET_TURN_CAPTURE=off');
@@ -396,7 +394,7 @@ export function runSteps({ steps = [], receipts } = {}, { run: suppliedRun = spa
         binding = queued.kind === 'journal' ? data.binding : queued;
         key = data.key; value = maskExcludedPaths(redactText(data.value), target.contentPathExcludes, target.capturePath);
         if (value !== redactText(data.value)) throw new Error('content exclusions changed; immutable turn retained');
-        args = ['memory', 'store', '-k', key, '--value', value, '-n', TURN_NAMESPACE, '--path', db, '--no-upsert', '--provenance', 'agent_output'];
+        args = ['memory', 'store', '-k', key, '--value', value, '-n', TURN_NAMESPACE, '--path', db, '--no-upsert', '--require-native', '--append-only', '--provenance', 'agent_output'];
       } else if (kind === 'distill') {
         if (queued.brainHome !== brainHome) throw new Error('queued consent settings differ from trusted caller');
         const recipe = queued.args;
@@ -424,21 +422,30 @@ export function runSteps({ steps = [], receipts } = {}, { run: suppliedRun = spa
       const invocation = rufloInvocation(ruflo, args);
       const remaining = deadlineMs === undefined ? STEP_TIMEOUT_MS : deadlineMs - Date.now();
       if (remaining <= 0) throw new Error('turn replay deadline exhausted');
-      const options = { encoding: 'utf8', timeout: Math.min(STEP_TIMEOUT_MS, remaining), cwd: path.dirname(db), windowsHide: true,
-        maxBuffer: 1024 * 1024, env: { ...env, ...RUFLO_ENV, CLAUDE_FLOW_MEMORY_PATH: path.dirname(db) } };
+      // Measured 2026-10-10 with global Ruflo 3.56.3: cwd=<project>/.swarm litters ruvector.db/.claude-flow there, and
+      // CLAUDE_FLOW_MEMORY_PATH=<.swarm> makes Ruflo create a second agentdb-memory.db beside the canonical store.
+      // The explicit --path already binds the store, so run from private scratch with neither.
+      const options = { encoding: 'utf8', timeout: Math.min(STEP_TIMEOUT_MS, remaining), windowsHide: true,
+        cwd: rufloCwdFor(db, { root: rufloScratchRoot({ ...env, RUVNET_BRAIN_HOME: brainHome }) }),
+        maxBuffer: 1024 * 1024, env: { ...env, ...RUFLO_ENV } };
+      delete options.env.CLAUDE_FLOW_MEMORY_PATH;
       const existing = kind === 'store' && queued.journalFile ? read({ ruflo, db, key, run, options }) : null;
       if (existing !== null && existing !== value) throw new Error('existing turn key content differs; no upsert permitted');
       verified = kind === 'store' && existing === value;
       const r = verified ? { status: 0 } : run(invocation.executable, invocation.args, options);
       status = Number.isInteger(r.status) ? r.status : 1;
-      if (kind === 'store' && !verified) verified = read({ ruflo, db, key, run, options }) === value;
+      if (kind === 'store' && !verified && status === 0) verified = read({ ruflo, db, key, run, options }) === value;
       if (verified) status = 0;
+      if (kind === 'distill' && status === 0) {
+        const match = /(?:^|\n)\s*skipped:\s*([^\n]+)/i.exec(String(r.stdout || '').replace(/\x1b\[[0-9;]*m/g, ''));
+        if (match) skipped = redactText(match[1]).slice(0, 300);
+      }
       if (!verified && (r.error || status !== 0)) error = captureFailureReason(r, status);
       else if (kind === 'store' && !verified) { status = 1; error = 'exact turn key/content readback failed'; }
     } catch (e) { status = 1; error = redactText(e.message).slice(0, 300); }
     if (error) error = maskExcludedPaths(error, privacyPatterns, projectDir);
     const row = { at: new Date().toISOString(), kind, db: redactText(db), storeIdentity: digest(db), key, status, error,
-      ...(kind === 'store' ? { verified } : {}) };
+      ...(kind === 'store' ? { verified } : {}), ...(skipped ? { skipped } : {}) };
     results.push(row);
     if (receipts) {
       try { appendReceipt(receipts, row); if (verified && queued.journalFile) acknowledgeJournal(queued.journalFile, db); }
@@ -473,8 +480,7 @@ export function turnRecordingStatus({ projectDir = process.cwd(), env = process.
   let target;
   try { target = resolveTurnDb({ projectDir, brainHome }); } catch { return { state: 'unknown', line: 'turn recording unavailable: canonical store resolution failed' }; }
   if (String(env.RUVNET_TURN_CAPTURE || '').toLowerCase() === 'off' || target.skipped) return { state: 'unknown', line: `turn recording n/a — ${target.skipped || 'RUVNET_TURN_CAPTURE=off'}` };
-  const deferred = String(env.RUVNET_HOOK_HOST || 'claude') === 'claude' && String(env.RUVNET_TURN_CAPTURE || '').toLowerCase() !== 'force' && userLevelAgentdbHooks({ home, event: 'Stop', projectDir, env }).turnCapture;
-  const notice = noticeOnFirstUse && !deferred ? firstTurnCaptureNotice({ target, brainHome, policyFile: turnCapturePolicyFile(brainHome), env }) : null;
+  const notice = noticeOnFirstUse ? firstTurnCaptureNotice({ target, brainHome, policyFile: turnCapturePolicyFile(brainHome), env }) : null;
   const status = (value) => ({ ...value, ...(notice ? { notice } : {}) });
   let rows = [];
   try {

package/plugin/scripts/turn-transport-journal.mjs

@@ -26,9 +26,11 @@ export function syncTurnDirectory(dir, { platform = process.platform, io = fs }
 export function storeData(step) {
   if (step?.kind !== 'store' || !Array.isArray(step.args) || step.args[0] !== 'memory' || step.args[1] !== 'store') throw new Error('invalid turn store operation');
   const fields = {}; const aliases = { '-k': 'key', '--key': 'key', '--value': 'value', '-n': 'namespace', '--namespace': 'namespace', '--path': 'db', '--tags': 'tags', '--provenance': 'provenance' };
-  let strict = false;
+  let strict = false; let native = false; let immutable = false;
   for (let i = 2; i < step.args.length; i++) {
     const flag = step.args[i];
+    if (flag === '--append-only') { if (immutable) throw new Error('duplicate turn store flag'); immutable = true; continue; }
+    if (flag === '--require-native') { if (native) throw new Error('duplicate turn store flag'); native = true; continue; }
     if (flag === '--no-upsert') { if (strict) throw new Error('duplicate turn store flag'); strict = true; continue; }
     const field = aliases[flag];
     if (!field || Object.hasOwn(fields, field) || typeof step.args[i + 1] !== 'string') throw new Error('unknown or duplicate turn store flag');

package/scripts/deferral-replay.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * deferral-replay.mjs — measure continuation-gate's `no-deferral` check (ADR-106) on REAL Claude Code
+ * transcripts, read-only. Same turn model as completion-claim-replay.mjs: a turn runs from one genuine
+ * user message to the next and its final assistant text stands in for `last_assistant_message`;
+ * authorization is read from the owner prompts up to and including that turn.
+ *
+ *   node scripts/deferral-replay.mjs [--root ~/.claude/projects] [--limit 60] [--skip 0] [--out sample.jsonl]
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { transcripts, turnsOf, finalText } from './completion-claim-replay.mjs';
+import { auditDeferral, ownerPrompts } from '../plugin/scripts/deferral-evidence.mjs';
+
+const argv = process.argv.slice(2);
+const opt = (flag, fallback) => { const i = argv.indexOf(flag); return i >= 0 && argv[i + 1] ? argv[i + 1] : fallback; };
+const root = path.resolve(opt('--root', path.join(os.homedir(), '.claude', 'projects')));
+const limit = Number(opt('--limit', '60'));
+const skip = Number(opt('--skip', '0')); // held-out evaluation: skip the newest N transcripts
+const out = opt('--out', null);
+const report = { root, transcripts: 0, turns: 0, deferralPhrase: 0, blocked: 0, unauthorized: 0, forced: 0, byKind: {} };
+const samples = [];
+for (const file of transcripts(root, skip + limit).slice(skip)) {
+  report.transcripts += 1;
+  const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
+  const prompts = [];
+  for (const turn of turnsOf(lines)) {
+    report.turns += 1;
+    prompts.push(...ownerPrompts(turn.slice(0, 1)));
+    const message = finalText(turn);
+    if (!message) continue;
+    const v = auditDeferral(message, { prompts });
+    if (v.verdict === 'NONE') continue;
+    report.deferralPhrase += 1;
+    if (v.verdict === 'BLOCKER') report.blocked += 1;
+    if (v.verdict === 'UNAUTHORIZED') report.unauthorized += 1;
+    if (v.verdict === 'DEFERRAL') {
+      report.forced += 1;
+      report.byKind[v.deferral.kind] = (report.byKind[v.deferral.kind] || 0) + 1;
+      samples.push({ file: path.basename(file), phrase: v.deferral.phrase, authorization: v.authorization, tail: message.slice(-500) });
+    }
+  }
+}
+report.forcedRate = report.turns ? Number((report.forced / report.turns).toFixed(4)) : 0;
+if (out) fs.writeFileSync(out, samples.map((s) => JSON.stringify(s)).join('\n') + '\n');
+console.log(JSON.stringify(report, null, 2));