ruvnet-brain 4.6.1 → 4.6.3

package/plugin/scripts/continuity-journal.mjs

@@ -12,6 +12,7 @@
  * RETAIN_COMMITTED_MS, ages quarantine/corrupt notices after QUARANTINE_REPORT_MS, and bounds committed
  * history at MAX_EVENT_RECORDS. Pending events are never dropped; prolonged outages report pressure.
  */
+import { nativeTurnLines } from './native-turn-transcript.mjs';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -137,7 +138,9 @@ export class ContinuityJournal {
   scan() {
     this.requireBudget();
     let text = '';
-    try { text = fs.readFileSync(this.path, 'utf8'); } catch { /* no outbox yet */ }
+    try { text = fs.readFileSync(this.path, 'utf8'); } catch (error) {
+      if (error.code !== 'ENOENT') throw new Error(`continuity outbox unreadable: ${error.code || 'I/O error'}`);
+    }
     const events = new Map();
     const committed = new Map();
     const failures = new Map();
@@ -367,23 +370,23 @@ export function stopNotice({ journal, status, session }) {
 }
 function defaultStore({ ruflo, db, key, value }) {
   const cwd = rufloRunDir(db);
+  const source = JSON.parse(value).source;
+  const provenance = ['assistant-detected', 'owner-correction-detected', 'agent-result'].includes(source) ? 'agent_output' : 'system_observation';
   try {
     const { executable, args } = rufloInvocation(ruflo, ['memory', 'store', '--key', key, '--value', value,
-      '--namespace', CONTINUITY_NAMESPACE, '--no-upsert', '--provenance', 'system_observation', '--path', db]);
+      '--namespace', CONTINUITY_NAMESPACE, '--no-upsert', '--require-native', '--append-only', '--provenance', provenance, '--path', db]);
     const r = spawnSync(executable, args, { cwd, encoding: 'utf8', timeout: 60_000, windowsHide: true,
-      env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } });
+      env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_MEMORY_PATH: undefined } });
     return { status: Number.isInteger(r.status) ? r.status : 1, output: `${r.stderr || ''}\n${r.stdout || ''}${r.error ? `\n${r.error.message}` : ''}` };
   } finally { fs.rmSync(cwd, { recursive: true, force: true }); }
 }
 
 function defaultReadBack({ ruflo, db, key }) {
-  const fast = withProgressionReader(db, (reader) => reader.readContent(CONTINUITY_NAMESPACE, key));
-  if (fast.ok) return { key, content: fast.value, readPath: 'node:sqlite' };
   const cwd = rufloRunDir(db);
   try {
     const { executable, args } = rufloInvocation(ruflo, ['memory', 'retrieve', '--key', key, '--namespace', CONTINUITY_NAMESPACE, '--value-only', '--path', db]);
-    const r = spawnSync(executable, args, { cwd, encoding: 'utf8', timeout: 60_000, windowsHide: true, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0' } });
-    return { key, content: r.status === 0 ? String(r.stdout || '') : null, readPath: `ruflo-cli (${fast.reason})` };
+    const r = spawnSync(executable, args, { cwd, encoding: 'utf8', timeout: 60_000, windowsHide: true, env: { ...process.env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_MEMORY_PATH: undefined } });
+    return { key, content: r.status === 0 ? String(r.stdout || '') : null, readPath: 'ruflo-cli' };
   } finally { fs.rmSync(cwd, { recursive: true, force: true }); }
 }
 
@@ -414,15 +417,18 @@ export function drain(journal, {
       if (now() >= deadline) break;
       const value = JSON.stringify(privateContinuityEvent(rec.event, consent.contentPathExcludes, consent.capturePath));
       if (value !== JSON.stringify(rec.event)) return { committed, failed, remaining: journal.pending().length, skipped: 'content exclusions changed; immutable continuity retained' };
-      attempts += 1; const result = store({ ruflo, db: journal.db, key: rec.key, value });
-      const back = readBack({ ruflo, db: journal.db, key: rec.key });
+      attempts += 1;
+      const prior = readBack({ ruflo, db: journal.db, key: rec.key });
+      const alreadyStored = typeof prior.content === 'string' && prior.content.trim() === value && (prior.key === undefined || prior.key === rec.key);
+      const result = alreadyStored ? { status: 0 } : store({ ruflo, db: journal.db, key: rec.key, value });
+      const back = alreadyStored ? prior : readBack({ ruflo, db: journal.db, key: rec.key });
       const content = typeof back.content === 'string' ? back.content.trim() : '';
-      if (content === value && digestCanonical(rec.event) === rec.digest && (back.key === undefined || back.key === rec.key)) {
+      if (result.status === 0 && content === value && digestCanonical(rec.event) === rec.digest && (back.key === undefined || back.key === rec.key)) {
         journal.appendRecords([{ type: 'commit', key: rec.key, digest: rec.digest, committedAt: new Date(now()).toISOString(), readPath: back.readPath,
-          alreadyStored: result.status !== 0 || content !== value, ...(attempts > 1 ? { attempts, lastError: last?.reason } : {}) }]);
+          alreadyStored, ...(attempts > 1 ? { attempts, lastError: last?.reason } : {}) }]);
         committed += 1;
         done = true;
-      } else if (content) {
+      } else if (content && (content !== value || digestCanonical(rec.event) !== rec.digest || (back.key !== undefined && back.key !== rec.key))) {
         // A DIFFERENT row holds our key: never overwritten (--no-upsert), never retried, reported.
         journal.appendRecords([{ type: 'quarantine', key: rec.key, at: new Date(now()).toISOString(), reason: 'a different stored row holds this key' }]);
         failed += 1;
@@ -466,7 +472,7 @@ export function takeLock(journal, { now = Date.now } = {}) {
 export function launchDrain({ projectRoot, spawnFn = spawn, env = process.env } = {}) {
   try {
     const child = spawnFn(process.execPath, [fileURLToPath(import.meta.url), '--drain', projectRoot], {
-      cwd: os.tmpdir(), detached: true, stdio: 'ignore', windowsHide: true, env: { ...env, RUFLO_DAEMON_AUTOSTART: '0' },
+      cwd: os.tmpdir(), detached: true, stdio: 'ignore', windowsHide: true, env: { ...env, RUFLO_DAEMON_AUTOSTART: '0', CLAUDE_FLOW_MEMORY_PATH: undefined },
     });
     child.unref?.();
     return true;
@@ -513,13 +519,13 @@ export function captureContinuityEvents({
     events.push(...collectCommits({ checkoutRoot: resolution.checkoutRoot, sinceMs, host, session, project }));
     events.push(...collectReleases({ checkoutRoot: resolution.checkoutRoot, sinceMs, host, session, project }));
   }
-  if (event === 'Stop') {
+  if (['Stop', 'SessionEnd', 'PreCompact', 'SubagentStop'].includes(event)) {
     let lines = null;
-    if (host === 'claude' && typeof payload.transcript_path === 'string' && payload.transcript_path) {
+    if (typeof payload.transcript_path === 'string' && payload.transcript_path) {
       try { lines = readTranscript(payload.transcript_path); } catch { /* unreadable transcript: git events still count */ }
     }
     const last = typeof payload.last_assistant_message === 'string' ? payload.last_assistant_message : ''; const policy = journal.captureConsent();
-    if (!policy.skipped && !(lines && turnReferencesExcludedResource(claudeTurn(lines), policy.contentPathExcludes, projectDir))) events.push(...collectTurnEvents({ lines, lastAssistantMessage: last, host, session, project, env, at: now() }));
+    if (!policy.skipped && !(lines && turnReferencesExcludedResource(claudeTurn(nativeTurnLines(lines, host)), policy.contentPathExcludes, projectDir))) events.push(...collectTurnEvents({ lines, lastAssistantMessage: last, host, session, project, env, at: now() }));
   }
   try { report.recorded = journal.record(events).length; } catch (error) { return { ...report, skipped: `outbox write failed: ${error.message}` }; }
   try { if (journal.needsCompaction()) journal.compact(); } catch { /* bounded next time */ }

package/plugin/scripts/developer-update-maintenance.mjs

@@ -3,6 +3,114 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { cmpVersion as compare } from './developer-update-policy.mjs';
+import crypto from 'node:crypto';
+import { pathToFileURL } from 'node:url';
+const sha = bytes => crypto.createHash('sha256').update(bytes).digest('hex');
+const quote = text => `'${String(text).replaceAll("'", "'\\''")}'`;
+function regular(file) {
+  const stat = fs.lstatSync(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.uid !== process.getuid?.()
+    || (stat.mode & 0o022)) throw Error('Codex launcher requires owned regular files');
+  return fs.readFileSync(file);
+}
+function runtimeIdentity(root) {
+  const entries = [];
+  function visit(relative) {
+    const file = path.join(root, relative), stat = fs.lstatSync(file);
+    if (stat.isDirectory() && !stat.isSymbolicLink() && stat.uid === process.getuid?.()) {
+      for (const name of fs.readdirSync(file)) visit(path.join(relative, name));
+    } else entries.push([relative.split(path.sep).join('/'), sha(regular(file))]);
+  }
+  visit('');
+  return sha(JSON.stringify(entries.sort(([a], [b]) => a.localeCompare(b))));
+}
+function nativeOwner(file, home) {
+  const real = fs.realpathSync(file), root = path.join(home, '.codex/packages/standalone/releases') + path.sep;
+  if (!real.startsWith(root) || path.basename(real) !== 'codex') throw Error('Codex native owner outside standalone releases');
+  const bytes = regular(real), magic = bytes.subarray(0, 4).toString('hex');
+  if (!['7f454c46', 'cffaedfe', 'feedfacf', 'cafebabe', 'bebafeca'].includes(magic)) throw Error('Codex native executable identity unavailable');
+  fs.accessSync(real, fs.constants.X_OK);
+  return real;
+}
+export function inspectCodexLauncher(file, home) {
+  if (file !== path.join(home, '.local/bin/codex') || fs.lstatSync(file).isSymbolicLink()) return null;
+  const bytes = regular(file);
+  // A direct native binary is handled by the ordinary owner gate; unknown scripts never run.
+  if (!bytes.subarray(0, 2).equals(Buffer.from('#!'))) {
+    if (!['7f454c46', 'cffaedfe', 'feedfacf', 'cafebabe', 'bebafeca'].includes(bytes.subarray(0, 4).toString('hex'))) throw Error('Unknown Codex native launcher refused');
+    return null;
+  }
+  const configPath = path.join(home, '.cache/ruvnet-brain/model-routing/terminal-launcher-config.json');
+  const configBytes = regular(configPath), config = JSON.parse(configBytes);
+  const runtimeRoot = path.join(home, '.cache/ruvnet-brain/model-routing/versions', config.runtimeDigest || '');
+  const keys = ['schemaVersion', 'managedBy', 'runtimeDigest', 'runtimeRoot', 'nodeBinary', 'runner', 'realCodex', 'gatewayPath',
+    ...(config.realClaude ? ['realClaude', 'claudeHelperPath', 'enginePath'] : [])];
+  if (Object.keys(config).sort().join(',') !== keys.sort().join(',')) throw Error('Codex launcher config shape mismatch');
+  if (config.schemaVersion !== 1 || config.managedBy !== 'ruvnet-brain-terminal-launchers'
+    || !/^[a-f0-9]{64}$/.test(config.runtimeDigest || '') || config.runtimeRoot !== runtimeRoot
+    || fs.realpathSync(runtimeRoot) !== runtimeRoot || config.runner !== path.join(runtimeRoot, 'scripts/model-terminal-launchers.mjs')
+    || config.gatewayPath !== path.join(runtimeRoot, 'scripts/model-terminal-gateway.mjs')
+    || (config.realClaude && (config.claudeHelperPath !== path.join(runtimeRoot, 'scripts/claude-terminal-mod.mjs')
+      || config.enginePath !== path.join(runtimeRoot, 'scripts/model-router-engine.mjs')))
+    || runtimeIdentity(runtimeRoot) !== config.runtimeDigest) throw Error('Codex launcher runtime/config identity mismatch');
+  const expected = `#!/bin/sh\n# Managed RuvNet Brain terminal launcher\nexec ${quote(config.nodeBinary)} ${quote(config.runner)} --launch 'codex' --config ${quote(configPath)} -- "$@"\n`;
+  if (!bytes.equals(Buffer.from(expected))) throw Error('Preserving unknown Codex terminal wrapper');
+  regular(config.nodeBinary); fs.accessSync(config.nodeBinary, fs.constants.X_OK);
+  // The shared installer also visits registered Claude launchers; require exact existing bytes.
+  const claudeEntries = [];
+  if (config.realClaude) {
+    const claudeBytes = Buffer.from(expected.replace("--launch 'codex'", "--launch 'claude'"));
+    for (const entry of ['claude', 'ruvnet-brain-claude-terminal']) {
+      const claudeFile = path.join(home, '.local/bin', entry);
+      if (!regular(claudeFile).equals(claudeBytes)) throw Error('Preserving changed Claude terminal wrapper');
+      claudeEntries.push({ file: claudeFile, bytes: claudeBytes });
+    }
+  }
+  return { file, home, configPath, configBytes, config, bytes, claudeEntries, native: nativeOwner(config.realCodex, home) };
+}
+export function updatedCodexNative(proof) {
+  if (fs.lstatSync(proof.file).uid !== process.getuid?.()) throw Error('Codex canonical owner changed during update');
+  if (!fs.lstatSync(proof.file).isSymbolicLink() && regular(proof.file).equals(proof.bytes)) {
+    return nativeOwner(path.join(proof.home, '.codex/packages/standalone/current/bin/codex'), proof.home);
+  }
+  return nativeOwner(proof.file, proof.home);
+}
+export async function restoreCodexLauncher(proof, { retainOriginalNative = false } = {}) {
+  const { file, home, config, configPath } = proof;
+  if (!regular(configPath).equals(proof.configBytes) || runtimeIdentity(config.runtimeRoot) !== config.runtimeDigest) {
+    throw Error('Codex launcher identity changed during native update');
+  }
+  for (const entry of proof.claudeEntries) if (!regular(entry.file).equals(entry.bytes)) throw Error('Claude wrapper changed during Codex update');
+  const candidate = updatedCodexNative(proof);
+  const native = retainOriginalNative ? nativeOwner(proof.native, home) : candidate;
+  const installed = await import(pathToFileURL(config.runner).href);
+  if (typeof installed.installTerminalLaunchers !== 'function') throw Error('Codex launcher installer unavailable');
+  // Installer accepts only same-owner native links. On failure retain the known original
+  // wrapper first, backing up the verified vendor link, then let its installer reconcile config.
+  if (retainOriginalNative && fs.lstatSync(file).isSymbolicLink()) {
+    const link = fs.readlinkSync(file), backup = `${file}.${sha(link)}.original`;
+    try { fs.symlinkSync(link, backup); }
+    catch (error) {
+      if (error.code !== 'EEXIST' || !fs.lstatSync(backup).isSymbolicLink()
+        || fs.lstatSync(backup).uid !== process.getuid?.() || fs.readlinkSync(backup) !== link) throw Error('Codex vendor link backup mismatch');
+    }
+    const temporary = `${file}.${crypto.randomUUID()}.tmp`;
+    try { fs.writeFileSync(temporary, proof.bytes, { flag: 'wx', mode: 0o755 }); fs.renameSync(temporary, file); }
+    finally { fs.rmSync(temporary, { force: true }); }
+  }
+  installed.installTerminalLaunchers({ home, runtimeRoot: config.runtimeRoot, runtimeDigest: config.runtimeDigest,
+    nodeBinary: config.nodeBinary, realCodex: native, realClaude: config.realClaude, apply: true, manageZsh: false });
+  if (!regular(file).equals(proof.bytes)) throw Error('Codex wrapper restoration verification failed');
+  const after = JSON.parse(regular(configPath));
+  const expectedConfig = { ...config, realCodex: native };
+  const sameConfig = Object.keys(after).sort().join(',') === Object.keys(expectedConfig).sort().join(',')
+    && Object.entries(expectedConfig).every(([key, value]) => after[key] === value);
+  if (!sameConfig || nativeOwner(after.realCodex, home) !== native) {
+    throw Error('Codex restored owner verification failed');
+  }
+  return native;
+}
+
 const HOME = os.homedir();
 const read = p => JSON.parse(fs.readFileSync(p, 'utf8'));
 function required(p) { fs.accessSync(p, fs.constants.X_OK); return p; }
@@ -66,14 +174,33 @@ export async function maintenance(config, run, dryRun, { home = HOME, brainHome,
       const resolved = fs.realpathSync(file);
       if (resolved.split(path.sep).includes('node_modules')) { result.exclusions.push(`npm owns native alias: ${file}`); continue; }
       required(file);
-      const owner = fs.realpathSync(file), stage = { owner: file, originalTarget: owner, state: 'running', commands: [] }; result.stages.push(stage);
-      const before = commandOutput(run, file, ['--version'], { timeout: 30_000 }, stage); stage.before = before;
-      if (!dryRun) commandOutput(run, file, args, { timeout: 900_000 }, stage);
-      const after = commandOutput(run, file, ['--version'], { timeout: 30_000 }, stage);
+      const launcher = inspectCodexLauncher(file, home);
+      const command = launcher?.native || file;
+      const owner = launcher?.native || fs.realpathSync(file), stage = { owner: file, originalTarget: owner, state: 'running', commands: [] }; result.stages.push(stage);
+      if (launcher) stage.launcherProof = { kind: 'brain-terminal-wrapper', runtimeDigest: launcher.config.runtimeDigest, wrapperSha256: sha(launcher.bytes) };
+      const before = commandOutput(run, command, ['--version'], { timeout: 30_000 }, stage); stage.before = before;
       const version = text => text.match(/\b(\d+\.\d+\.\d+(?:-[\w.-]+)?)/)?.[1];
-      const versionVerified = !!version(before) && !!version(after) && compare(version(after), version(before)) >= 0;
+      let after, afterOwner, versionVerified, restorationAttempted = false;
+      try {
+        if (!dryRun) commandOutput(run, command, args, { timeout: 900_000 }, stage);
+        const afterCommand = launcher && !dryRun ? updatedCodexNative(launcher) : command;
+        after = commandOutput(run, afterCommand, ['--version'], { timeout: 30_000 }, stage);
+        versionVerified = !!version(before) && !!version(after) && compare(version(after), version(before)) >= 0;
+        if (launcher && !dryRun) {
+          restorationAttempted = true;
+          if (!versionVerified) stage.rejectedNativeTarget = afterCommand;
+          afterOwner = await restoreCodexLauncher(launcher, { retainOriginalNative: !versionVerified });
+        }
+        else afterOwner = launcher?.native || fs.realpathSync(file);
+      } catch (error) {
+        stage.state = 'failed';
+        if (launcher && !dryRun && !restorationAttempted) {
+          try { stage.restoredTarget = await restoreCodexLauncher(launcher, { retainOriginalNative: true }); }
+          catch (restoreError) { stage.restorationError = restoreError.message; }
+        }
+        throw error;
+      }
       // Native launchers may re-point to a newer version, but stay in the same established root.
-      const afterOwner = fs.realpathSync(file);
       const ownerPreserved = nativeOwnerPreserved(file, owner, afterOwner, home);
       settleStage(stage, after, { versionVerified, ownerPreserved }, { currentTarget: afterOwner });
     }

package/plugin/scripts/developer-update.mjs

@@ -310,7 +310,7 @@ function knowledge(run, dryRun, runId, { brainHome, root, node }) {
 }
 export function developerUpdatePaths({ home = os.homedir(), brainHome = process.env.RUVNET_BRAIN_HOME || path.join(home, '.cache/ruvnet-brain') } = {}) {
   return { home, brainHome, config: path.join(brainHome, 'developer-update-config.json'),
-    receipt: path.join(brainHome, 'nightly-suite-update.json'), lock: path.join(brainHome, 'developer-update.lock') };
+    receipt: path.join(brainHome, 'nightly-suite-update.json'), scheduledReceipt: path.join(brainHome, 'scheduler/last-suite-attempt.json'), lock: path.join(brainHome, 'developer-update.lock') };
 }
 export function validateDeveloperUpdateConfig(value = {}) {
   const defaults = { schemaVersion: 1, channel: 'latest', scope: 'ruvnet', homebrew: false, uv: false, cargo: false, native: false, managedCallback: null, cleanup: false, preservePackages: [] };
@@ -371,12 +371,42 @@ export async function runDeveloperUpdate({ mode = 'check', home = os.homedir(),
   run.receipt = (command, args, options = {}) => dispatch(command, args, { ...options, capture: true });
   const locate = name => locateExecutable(name, { env: childEnv });
   const receipt = { schemaVersion: 1, kind: 'nightly-suite-update', runId: crypto.randomUUID(), pid: process.pid,
-    startedAt: new Date().toISOString(), mode, state: 'running', ok: false, config, steps: [], notes: [],
+    startedAt: new Date().toISOString(), mode, scheduled: mode === 'apply' && env.RUVNET_NIGHTLY === '1' && !!env.RUVNET_NIGHTLY_IDENTITY, state: 'running', ok: false, config, steps: [], notes: [],
     sourceSha256: null, ownerToken: lock.token, ownerPid: lock.ownerPid, schedulerIdentity: env.RUVNET_NIGHTLY_IDENTITY || null };
+  const scheduledAttempt = value => value?.mode === 'apply' && value.scheduled !== false && !!value.schedulerIdentity;
+  const readAttempt = file => {
+    try {
+      const stat = fs.lstatSync(file);
+      if (!stat.isFile() || stat.isSymbolicLink()) throw Error('scheduled receipt must be a regular file');
+      return read(file);
+    } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  };
+  const persistReceipt = () => {
+    // Write Activity first: if the second write fails, health still sees this newer failed attempt.
+    atomic(paths.receipt, receipt);
+    if (receipt.scheduled) {
+      try { atomic(paths.scheduledReceipt, receipt); }
+      catch (error) {
+        receipt.state = 'failed'; receipt.ok = false; receipt.error = `Scheduled receipt persistence failed: ${error.message}`;
+        atomic(paths.receipt, receipt);
+        throw error;
+      }
+    }
+  };
+  let latestMayBeReplaced = receipt.scheduled;
   try {
+    if (!receipt.scheduled) {
+      const latest = readAttempt(paths.receipt), retained = readAttempt(paths.scheduledReceipt);
+      const latestTime = Date.parse(latest?.startedAt || latest?.finishedAt || ''), retainedTime = Date.parse(retained?.startedAt || retained?.finishedAt || '');
+      if (scheduledAttempt(latest) && (!retained || !Number.isFinite(latestTime) || !Number.isFinite(retainedTime) || latestTime >= retainedTime)) {
+        // Preserve real legacy/failed evidence before a check or manual run replaces Activity.
+        atomic(paths.scheduledReceipt, latest);
+      }
+      latestMayBeReplaced = true;
+    }
     receipt.sourceSha256 = hash(fs.readFileSync(new URL(import.meta.url)));
     receipt.sourceSnapshot = Object.fromEntries(EXECUTION_MODULES.map(name => [name, hash(fs.readFileSync(new URL(name, import.meta.url)))]));
-    atomic(paths.receipt, receipt);
+    persistReceipt();
     const npm = locate('npm');
     if (!npm) throw Error('existing npm owner absent; fresh install refused');
     const prefix = run(npm, ['prefix', '-g'], { timeout: 30_000 }).trim();
@@ -386,16 +416,16 @@ export async function runDeveloperUpdate({ mode = 'check', home = os.homedir(),
     childEnv.npm_config_prefix = prefix;
     receipt.npmIdentity = { npm, prefix, root, node: process.execPath };
     receipt.before = discover(root, prefix, config.scope);
-    atomic(paths.receipt, receipt);
+    persistReceipt();
     for (const before of receipt.before) {
       const tags = before.localSource ? {} : JSON.parse(run(npm, ['view', before.name, 'dist-tags', '--json'], { timeout: 90_000 }));
       receipt.steps.push(upgradePackage(before, tags, REVIEWED_INSTALL_SCRIPTS, { run, dryRun: mode === 'check', channel: config.channel, npm, preservePackages: config.preservePackages }));
-      atomic(paths.receipt, receipt);
+      persistReceipt();
     }
     receipt.plugins = await synchronizePlugins(run, mode === 'check', receipt.notes, { home, prefix, scope: config.scope, locate, unattended: !!env.RUVNET_NIGHTLY_IDENTITY });
     if (exists(path.join(paths.brainHome, 'kb/forge-update.mjs'))) receipt.knowledge = knowledge(run, mode === 'check', receipt.runId, { brainHome: paths.brainHome, root, node: process.execPath });
     else receipt.notes.push('Brain corpus absent; fresh knowledge install excluded');
-    receipt.maintenance = await maintenance(config, run, mode === 'check', { home, brainHome: paths.brainHome, locate, node: process.execPath, progress: result => { receipt.maintenance = result; atomic(paths.receipt, receipt); } });
+    receipt.maintenance = await maintenance(config, run, mode === 'check', { home, brainHome: paths.brainHome, locate, node: process.execPath, progress: result => { receipt.maintenance = result; persistReceipt(); } });
     receipt.cleanup = cleanupNpxDuplicates({ home, globalRoot: root, enabled: config.cleanup && mode === 'apply', run });
     receipt.after = discover(root, prefix, config.scope);
     receipt.state = mode === 'check' ? 'checked' : 'completed'; receipt.ok = true;
@@ -412,7 +442,7 @@ export async function runDeveloperUpdate({ mode = 'check', home = os.homedir(),
     throw error;
   } finally {
     receipt.finishedAt = new Date().toISOString();
-    try { atomic(paths.receipt, receipt); } finally { lock.release(); }
+    try { if (latestMayBeReplaced) persistReceipt(); } finally { lock.release(); }
   }
 }
 export async function developerUpdateCli(args = process.argv.slice(2)) {

package/plugin/scripts/native-turn-transcript.mjs

@@ -0,0 +1,51 @@
+/** Bounded, mechanical Codex JSONL normalization. No model inference or user-text persistence. */
+const LIMIT = 2 * 1024 * 1024;
+const text = content => typeof content === 'string' ? content : Array.isArray(content)
+  ? content.filter(part => ['text', 'input_text', 'output_text'].includes(part?.type)).map(part => part.text || '').join('\n') : '';
+const message = (role, content) => ({ message: { role, content } });
+const parse = value => { try { return JSON.parse(value); } catch { return null; } };
+
+/** Keep call IDs intact; torn/unknown records cannot manufacture successful tool evidence. */
+export function nativeTurnLines(lines, host) {
+  if (host !== 'codex') return lines;
+  const records = []; let bytes = 0;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    bytes += Buffer.byteLength(String(lines[i]));
+    if (bytes > LIMIT) break;
+    const record = parse(lines[i]); if (record) records.push(record);
+  }
+  records.reverse();
+  const out = []; const sessions = new Map(); const calls = new Map();
+  for (const record of records) {
+    const p = record.payload;
+    if (record.type === 'event_msg' && p?.type === 'user_message') {
+      out.push(message('user', p.message || '')); continue;
+    }
+    if (record.type === 'event_msg' && p?.type === 'agent_message' && typeof p.message === 'string') {
+      out.push(message('assistant', p.message)); continue;
+    }
+    if (record.type !== 'response_item' || !p) continue;
+    if (p.type === 'message' && ['user', 'assistant'].includes(p.role)) {
+      out.push(message(p.role, text(p.content))); continue;
+    }
+    if (['function_call', 'custom_tool_call'].includes(p.type) && typeof p.call_id === 'string') {
+      const args = typeof p.arguments === 'string' ? parse(p.arguments) : p.arguments;
+      let name = String(p.name || '').split('.').at(-1); let input = args || {};
+      if (name === 'exec_command' && typeof args?.cmd === 'string') { name = 'Bash'; input = { command: args.cmd }; }
+      if (name === 'apply_patch') input = { input: p.input || '' };
+      if (name === 'write_stdin' && sessions.has(args?.session_id)) {
+        name = 'Bash'; input = { command: sessions.get(args.session_id) };
+      }
+      calls.set(p.call_id, { name, input });
+      out.push(message('assistant', [{ type: 'tool_use', id: p.call_id, name, input }]));
+    } else if (['function_call_output', 'custom_tool_call_output'].includes(p.type) && typeof p.call_id === 'string') {
+      const result = typeof p.output === 'string' ? parse(p.output) : p.output;
+      const call = calls.get(p.call_id);
+      if (Number.isSafeInteger(result?.session_id) && call?.name === 'Bash') sessions.set(result.session_id, call.input.command);
+      // Native structured exit fields are retained; opaque text is never guessed to be a pass.
+      out.push(message('user', [{ ...(result && typeof result === 'object' ? result : {}),
+        type: 'tool_result', tool_use_id: p.call_id, content: typeof p.output === 'string' ? p.output : JSON.stringify(p.output ?? '') }]));
+    }
+  }
+  return out.map(record => JSON.stringify(record));
+}

package/plugin/scripts/nightly-scheduler.mjs

@@ -252,24 +252,45 @@ export function resolveNightlyProofBundle({ brainHome, env = process.env } = {})
 }
 
 export function developerRunHealth({ brainHome, registration, now = Date.now(), maxAgeHours = 30 }) {
-  const file = path.join(brainHome, 'nightly-suite-update.json');
-  if (!fs.existsSync(file)) return { state: 'never-ran', evidence: 'No coordinated update receipt exists yet.', receipt: null };
+  const scheduled = value => value?.mode === 'apply' && value.scheduled !== false && !!value.schedulerIdentity;
+  const readReceipt = file => {
+    try {
+      const stat = fs.lstatSync(file);
+      if (!stat.isFile() || stat.isSymbolicLink()) throw Error('receipt is not a regular file');
+      return JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+  };
   let receipt;
-  try { receipt = JSON.parse(fs.readFileSync(file, 'utf8')); }
-  catch (error) { return { state: 'failed', evidence: `Coordinated update receipt unreadable: ${error.message}`, receipt: null }; }
+  try {
+    const retained = readReceipt(path.join(brainHome, 'scheduler/last-suite-attempt.json'));
+    const latest = readReceipt(path.join(brainHome, 'nightly-suite-update.json'));
+    if (retained && !scheduled(retained)) throw Error('retained receipt is not a scheduled apply attempt');
+    receipt = retained || latest;
+    if (scheduled(latest)) {
+      const latestTime = Date.parse(latest.startedAt || latest.finishedAt || '');
+      const retainedTime = Date.parse(retained?.startedAt || retained?.finishedAt || '');
+      if (!retained || !Number.isFinite(latestTime) || !Number.isFinite(retainedTime) || latestTime >= retainedTime) receipt = latest;
+    }
+  } catch (error) { return { state: 'failed', evidence: `Coordinated update receipt unreadable or refused: ${error.message}`, receipt: null }; }
+  if (!receipt) return { state: 'never-ran', evidence: 'No coordinated update receipt exists yet.', receipt: null };
   const validDigest = value => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
   const bound = validDigest(receipt.sourceSha256) && receipt.kind === 'nightly-suite-update' && receipt.schemaVersion === 1
     && receipt.sourceSha256 === registration.updateModules?.['developer-update.mjs']?.sha256
+    && Object.entries(receipt.sourceSnapshot || {}).every(([name, digest]) => validDigest(digest) && digest === registration.updateModules?.[name]?.sha256)
     && EXECUTION_MODULES.filter(name => name !== 'plugin-artifact-proof.mjs' || registration.updateModules?.[name]).every(name => validDigest(receipt.sourceSnapshot?.[name]) && receipt.sourceSnapshot[name] === registration.updateModules?.[name]?.sha256);
   const ageHours = (now - Date.parse(receipt.finishedAt || receipt.startedAt || '')) / 3_600_000;
-  if (!bound || !Number.isFinite(ageHours)) return { state: 'failed', evidence: 'Coordinated update receipt is not bound to registered source.', receipt };
+  const times = [receipt.startedAt, receipt.finishedAt].filter(value => value !== undefined).map(value => Date.parse(value));
+  const timestampsValid = times.length > 0 && times.every(value => Number.isFinite(value) && value <= now)
+    && !(receipt.startedAt && receipt.finishedAt && Date.parse(receipt.finishedAt) < Date.parse(receipt.startedAt));
+  if (!bound) return { state: 'failed', evidence: 'Coordinated update receipt is not bound to registered source.', receipt };
+  if (!Number.isFinite(ageHours) || !timestampsValid) return { state: 'failed', evidence: 'Coordinated update receipt timestamps are invalid or future-dated.', receipt };
+  if (!scheduled(receipt) || receipt.schedulerIdentity !== registration.identity) return { state: 'never-ran', ageHours, receipt, evidence: 'No scheduled apply attempt is bound to the current registration.' };
   if (receipt.state === 'running') {
     const lock = sharedLockStatus({ brainHome });
     const live = lock.state === 'running' && lock.owner.pid === (receipt.ownerPid || receipt.pid) && lock.owner.token === receipt.ownerToken;
     return { state: live ? 'running' : 'failed', ageHours, receipt, evidence: live ? 'Coordinated updates have a live exact owner.' : 'Coordinated update owner is absent or unverified.' };
   }
   if (receipt.state === 'failed' || receipt.ok !== true) return { state: 'failed', ageHours, receipt, evidence: receipt.error || 'Coordinated updates failed.' };
-  if (receipt.mode !== 'apply' || receipt.schedulerIdentity !== registration.identity) return { state: 'never-ran', ageHours, receipt, evidence: 'Latest receipt is manual or a currency check; nightly execution remains unproven.' };
   if (receipt.state !== 'completed') return { state: 'failed', ageHours, receipt, evidence: 'Coordinated update terminal state is unverified.' };
   if (ageHours > maxAgeHours) return { state: 'stale', ageHours, receipt, evidence: `Last coordinated update is ${ageHours.toFixed(1)}h old.` };
   const verification = { ok: bound && receipt.mode === 'apply' && receipt.schedulerIdentity === registration.identity && receipt.state === 'completed' && receipt.ok === true && ageHours >= 0 && ageHours <= maxAgeHours };

package/plugin/scripts/project-capture-queue.mjs

@@ -318,6 +318,8 @@ export function runOutboxReplay({ projectDir, token = process.env.RUVNET_REPLAY_
             const options = { rawInput: JSON.stringify(job.payload), host: job.host, env,
               budgetMs: Math.max(0, deadlineAt - now()), deadlineAt, signal,
               makeStoreFactory: () => makeStoreFactory(deadlineAt), now, ordered: held, writeMetadata: false,
+              // A queued job was admitted at its live boundary; replay must not re-run (or be suspended by) enrollment.
+              enrollMemory: () => ({ state: 'existing' }),
               captureTurn: () => ({ recorded: false, skipped: 'detached replay' }),
               captureEvents: () => ({ recorded: 0, skipped: 'detached replay' }) };
             const result = job.payload?.normalizedTransition ? captureNormalized(job, options)