@lyupro/codex-bridge 0.6.12 → 0.6.14

package/cli/runs-move-copy.mjs

@@ -0,0 +1,123 @@
+/**
+ * Copies a run store into a caller-created staging folder and proves every byte arrived.
+ *
+ * Plan_77 D1: the 2026-10-07 VaultForge journal cost $16.57 instead of $0.3-0.8
+ * because records lived in another project's git tree. Every record must survive.
+ * A 2026-10-08 Windows probe (Plan_77 B5a) preserved trailing dots with ordinary Node
+ * absolute paths; keep names verbatim, including tradeforge.loc (do not cd into codex-runs).
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { normalizeRepoPath } from '../src/home/lib/runner/project-dir.mjs';
+
+export function sha256File(file) {
+  const digest = createHash('sha256');
+  const buffer = Buffer.allocUnsafe(1024 * 1024);
+  const descriptor = fs.openSync(file, 'r');
+  try {
+    for (;;) {
+      const bytes = fs.readSync(descriptor, buffer, 0, buffer.length, null);
+      if (!bytes) break;
+      digest.update(buffer.subarray(0, bytes));
+    }
+    return digest.digest('hex');
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function entryStat(file) {
+  const stat = fs.lstatSync(file);
+  if (stat.isSymbolicLink() || (!stat.isFile() && !stat.isDirectory())) {
+    throw new Error(`Unsupported run store entry: ${file}`);
+  }
+  return stat;
+}
+
+/** A read-only inventory also serves the dry run; empty folders count as records. */
+export function inspectRunStore(root) {
+  if (!entryStat(root).isDirectory()) throw new Error(`Run store is not a directory: ${root}`);
+  const entries = new Map();
+  const totals = { files: 0, directories: 0, bytes: 0 };
+  function walk(relative) {
+    for (const name of fs.readdirSync(path.join(root, relative)).sort()) {
+      const child = path.join(relative, name);
+      const stat = entryStat(path.join(root, child));
+      const directory = stat.isDirectory();
+      entries.set(child, { directory, size: stat.size });
+      if (directory) {
+        totals.directories += 1;
+        walk(child);
+      } else {
+        totals.files += 1;
+        totals.bytes += stat.size;
+      }
+    }
+  }
+  walk('');
+  return { entries, ...totals };
+}
+
+/** Plan_77 D3: reject unsafe destinations before creating any copy. */
+export function checkRunStoreDestination({ from, to }) {
+  const source = normalizeRepoPath(from);
+  const destination = normalizeRepoPath(to);
+  if (source === destination || source.startsWith(`${destination}/`) || destination.startsWith(`${source}/`)) {
+    throw new Error(`Run store paths overlap: ${from} and ${to}.`);
+  }
+  let stat;
+  try {
+    stat = fs.lstatSync(to);
+  } catch (error) {
+    if (error.code === 'ENOENT') return false;
+    throw error;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink() || fs.readdirSync(to).length) {
+    throw new Error(`Run store destination is not an empty directory: ${to}.`);
+  }
+  return true;
+}
+
+function verifyPaths(expected, actual, root) {
+  for (const relative of [...new Set([...expected.keys(), ...actual.keys()])].sort()) {
+    if (!expected.has(relative) || !actual.has(relative)
+      || expected.get(relative).directory !== actual.get(relative).directory) {
+      throw new Error(`Run store verification failed at ${path.join(root, relative)}: paths differ.`);
+    }
+  }
+}
+
+export function copyRunStore({ from, to, hash = sha256File }) {
+  const destinationExists = checkRunStoreDestination({ from, to });
+  const original = inspectRunStore(from);
+  if (!destinationExists) throw new Error(`Run store staging folder must already exist: ${to}.`);
+  try {
+    for (const [relative, entry] of original.entries) {
+      const src = path.join(from, relative);
+      const dst = path.join(to, relative);
+      entryStat(src); // Never follow a link introduced between the inventory and the copy.
+      if (entry.directory) fs.mkdirSync(dst);
+      else fs.copyFileSync(src, dst, fs.constants.COPYFILE_EXCL);
+    }
+    const source = inspectRunStore(from);
+    const destination = inspectRunStore(to);
+    verifyPaths(original.entries, source.entries, from);
+    verifyPaths(source.entries, destination.entries, to);
+    for (const [relative, entry] of source.entries) {
+      if (entry.directory) continue;
+      if (entry.size !== destination.entries.get(relative).size
+        || hash(path.join(from, relative)) !== hash(path.join(to, relative))) {
+        throw new Error(`Run store verification failed at ${relative}: size or hash differs.`);
+      }
+    }
+    // Check the path sets again after hashing, before declaring this copy verified.
+    verifyPaths(source.entries, inspectRunStore(from).entries, from);
+    verifyPaths(source.entries, inspectRunStore(to).entries, to);
+    return { files: source.files, directories: source.directories, bytes: source.bytes };
+  } catch (error) {
+    // Plan_77 F1: the caller guarantees this staging folder was exclusively created by this process.
+    fs.rmSync(to, { recursive: true, force: true });
+    throw error;
+  }
+}

package/cli/runs-move-history.mjs

@@ -0,0 +1,78 @@
+/**
+ * Gives the moved run store the git history its records had in the repository they left.
+ *
+ * Plan_77 D4: split only a clone so the old repository's working tree, index and refs stay intact.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+export function runGit(cwd, args) {
+  const { status, stdout, stderr } = spawnSync('git', ['-C', cwd, ...args], {
+    encoding: 'utf8', windowsHide: true, maxBuffer: 64 * 1024 * 1024,
+  });
+  return { status, stdout, stderr };
+}
+
+function gitFailure(step, result) {
+  const firstLine = (result.stderr || '').trim().split(/\r?\n/)[0];
+  return new Error(`Git ${step} failed (exit ${result.status}): ${firstLine}`);
+}
+
+function gitStep(git, cwd, args, statuses = [0]) {
+  let result;
+  try {
+    result = git(cwd, args);
+  } catch (error) {
+    throw gitFailure(args[0], { status: null, stderr: error.message });
+  }
+  if (!statuses.includes(result.status)) throw gitFailure(args[0], result);
+  return result;
+}
+
+/** D4: dry runs use exactly the same read-only eligibility checks, without creating a clone. */
+export function inspectRunHistory({ from, git = runGit }) {
+  const repository = gitStep(git, from, ['rev-parse', '--show-toplevel'], [0, 128]);
+  if (repository.status !== 0) {
+    if (/not a git repository/i.test(repository.stderr || '')) return { imported: false, reason: 'not in git' };
+    throw gitFailure('rev-parse', repository);
+  }
+  const top = repository.stdout.trim();
+  const prefix = path.relative(top, from).split(path.sep).join('/');
+  if (!prefix) return { imported: false, reason: 'store is a repository of its own' };
+  const commits = Number(gitStep(git, top, ['rev-list', '--count', 'HEAD', '--', prefix]).stdout.trim());
+  if (commits === 0) return { imported: false, reason: 'no history' };
+  return { top, prefix, commits };
+}
+
+export function importRunHistory({ from, to, git = runGit, tmpdir = os.tmpdir() }) {
+  const history = inspectRunHistory({ from, git });
+  if (history.imported === false) return history;
+  const gitDir = path.join(to, '.git');
+  const hadGit = fs.existsSync(gitDir);
+  const clone = fs.mkdtempSync(path.join(tmpdir, 'codex-bridge-runs-history-'));
+  let initializing = false;
+  try {
+    gitStep(git, tmpdir, ['clone', '--quiet', '--no-checkout', history.top, clone]);
+    // D4: subtree requires the prefix on disk; materialize only that prefix in the disposable clone.
+    gitStep(git, clone, ['checkout', '--quiet', 'HEAD', '--', history.prefix]);
+    gitStep(git, clone, ['subtree', 'split', '--quiet', `--prefix=${history.prefix}`, '-b', 'codex-runs-history']);
+    initializing = true;
+    gitStep(git, to, ['init', '--quiet']);
+    gitStep(git, to, ['fetch', '--quiet', clone, 'codex-runs-history']);
+    // D4: mixed reset imports the index and history while keeping the verified on-disk records.
+    gitStep(git, to, ['reset', '--quiet', 'FETCH_HEAD']);
+    gitStep(git, to, ['add', '-A']);
+    if (gitStep(git, to, ['diff', '--cached', '--quiet'], [0, 1]).status === 1) {
+      gitStep(git, to, ['commit', '--quiet', '-m', 'Import run records moved by codex-bridge (Plan_77)']);
+    }
+    return { imported: true, commits: Number(gitStep(git, to, ['rev-list', '--count', 'HEAD']).stdout.trim()) };
+  } catch (error) {
+    // D4: roll back only metadata created by this import, never the source repository or records.
+    if (initializing && !hadGit) fs.rmSync(gitDir, { recursive: true, force: true });
+    throw error;
+  } finally {
+    fs.rmSync(clone, { recursive: true, force: true });
+  }
+}

package/cli/runs-move-remove.mjs

@@ -0,0 +1,92 @@
+/**
+ * Removes the old run store once the operator agrees and every file in it has an identical copy in the new one.
+ *
+ * Plan_77 D3/B5c: an older package can still write to the old root after the D7 switch.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { inspectRunStore, sha256File } from './runs-move-copy.mjs';
+import { askYesNo, isInteractive } from './terminal-question.mjs';
+
+/** Returns the first 20 differing relative paths and the total count, including empty folders. */
+export function oldStoreDifferences({ from, to, hash = sha256File }) {
+  const source = path.resolve(from);
+  const destination = path.resolve(to);
+  const relative = path.relative(source, destination);
+  const reverse = path.relative(destination, source);
+  const inside = (value) => value === '' || (!path.isAbsolute(value)
+    && value !== '..' && !value.startsWith(`..${path.sep}`));
+  if (inside(relative) || inside(reverse)) throw new Error(`Run store paths overlap: ${from} and ${to}.`);
+  const oldEntries = inspectRunStore(from).entries;
+  const newEntries = inspectRunStore(to).entries;
+  const paths = [];
+  let count = 0;
+  for (const [entryPath, oldEntry] of oldEntries) {
+    const newEntry = newEntries.get(entryPath);
+    if (!newEntry || oldEntry.directory !== newEntry.directory
+      || (!oldEntry.directory && (oldEntry.size !== newEntry.size
+        || hash(path.join(from, entryPath)) !== hash(path.join(to, entryPath))))) {
+      count += 1;
+      if (paths.length < 20) paths.push(entryPath);
+    }
+  }
+  return { paths, count };
+}
+
+function differencesResult(from, { paths, count }) {
+  return { exitCode: 1,
+    output: `The old folder ${from} has ${count} entries the new store does not hold identically:\n${paths.join('\n')}\nNothing was removed.` };
+}
+
+export async function removeOldStore({ from, to, ask = askYesNo, interactive = isInteractive,
+  questionOptions = {}, hash }) {
+  let quarantine;
+  const restore = () => {
+    if (!quarantine) return '';
+    if (!fs.existsSync(from)) {
+      try {
+        fs.renameSync(quarantine, from);
+        quarantine = undefined;
+        return '';
+      } catch (error) {
+        return `\nCould not restore ${quarantine} to ${from}: ${error.message}. Records remain in ${quarantine}.`;
+      }
+    }
+    return `\nThe old records remain in ${quarantine}; ${from} also exists. Both folders were kept.`;
+  };
+  try {
+    const differences = oldStoreDifferences({ from, to, hash });
+    if (differences.count) return differencesResult(from, differences);
+    if (!interactive(questionOptions)) {
+      return { exitCode: 0,
+        output: `The old folder ${from} is still there; run codex-bridge runs move in a terminal to remove it.` };
+    }
+    const answer = await ask(`Remove the old folder ${from}? Every file in it has an identical copy in ${to}. `
+      + 'It stays in the history of the git repository that holds it until that project commits the removal.', questionOptions);
+    if (answer === 'cancel') return { exitCode: 130, output: 'Cancelled; nothing was removed.' };
+    if (answer !== 'yes') return { exitCode: 0, output: 'The old folder was kept.' };
+    // Plan_77 F1: isolate the old tree before comparing; never delete a newly recreated from.
+    const isolated = `${from}.removing-${process.pid}-${Date.now()}`;
+    try {
+      fs.renameSync(from, isolated);
+    } catch (error) {
+      if (['EPERM', 'EBUSY', 'EACCES'].includes(error.code)) {
+        return { exitCode: 1,
+          output: `A process still uses a file in ${from}; nothing was removed. Close it and repeat.` };
+      }
+      throw error;
+    }
+    quarantine = isolated;
+    const confirmed = oldStoreDifferences({ from: quarantine, to, hash });
+    if (confirmed.count) {
+      const result = differencesResult(from, confirmed);
+      result.output += restore();
+      return result;
+    }
+    fs.rmSync(quarantine, { recursive: true });
+    quarantine = undefined;
+    return { exitCode: 0, output: `Removed ${from}.` };
+  } catch (error) {
+    return { exitCode: 1, output: `${error.message}\nNothing was removed.${restore()}` };
+  }
+}

package/cli/runs-move.mjs

@@ -0,0 +1,96 @@
+/**
+ * Moves the run records from the retired default root into the package home, on the operator's signal.
+ *
+ * Plan_77 D3/D7: projects are closed by the operator; refuse live runs and prove
+ * the copy and import D4 history before writing the D7 move record that switches roots.
+ * The 2026-10-07 VaultForge $16.57 journal incident is why records leave foreign git.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { runsRootResolution } from '../src/home/lib/runner/runs-root.mjs';
+import { resolveBrandHome } from '../src/home/lib/brand-home.mjs';
+import { writeRunsMoveRecord } from '../src/home/lib/runner/retired-roots.mjs';
+import { allLiveRuns } from '../src/home/hooks/live-runs.mjs';
+import { checkRunStoreDestination, copyRunStore, inspectRunStore } from './runs-move-copy.mjs';
+import { importRunHistory, inspectRunHistory, runGit } from './runs-move-history.mjs';
+import { oldStoreDifferences } from './runs-move-remove.mjs';
+
+export function runsMove({ dryRun = false, resolution = runsRootResolution(), liveRuns = allLiveRuns,
+  stateDir, importHistory = importRunHistory, git = runGit } = {}) {
+  const { source, root, legacyRoot, homeRoot } = resolution;
+  const refuse = (output) => ({ exitCode: 1, output, oldStore: null, homeRoot });
+  if (source === 'CODEX_RUNS_ROOT') {
+    return refuse(`CODEX_RUNS_ROOT is set to ${root}; unset it to move the default run store.`);
+  }
+  if (source === 'moved') {
+    try {
+      if (fs.existsSync(legacyRoot) && fs.lstatSync(legacyRoot).isDirectory()) {
+        return { exitCode: 0, oldStore: dryRun ? null : legacyRoot, homeRoot,
+          output: `Run records already live in ${homeRoot}; the old folder ${legacyRoot} still exists.` };
+      }
+    } catch (error) {
+      return refuse(error.message);
+    }
+    return refuse(`Run records already live in ${homeRoot}.`);
+  }
+  if (source === 'default') return refuse(`No run store to move: ${legacyRoot} does not exist.`);
+  let liveRefusal = null;
+  try {
+    const live = liveRuns(legacyRoot);
+    if (live.length) {
+      liveRefusal = `Runs are still live in ${legacyRoot}:\n${live.map(({ dir }) => dir).join('\n')}. `
+        + 'Wait for them or stop them with codex-bridge stop, then repeat.';
+      // Like purge --dry-run: a preview names the refusal and still shows the move, since some
+      // project is nearly always running and the operator plans the move from these numbers.
+      if (!dryRun) return refuse(liveRefusal);
+    }
+    checkRunStoreDestination({ from: legacyRoot, to: homeRoot });
+  } catch (error) {
+    return refuse(liveRefusal ? `${liveRefusal}\n${error.message}` : error.message);
+  }
+  const staging = `${homeRoot}.moving-${process.pid}-${Date.now()}`;
+  let ownsStaging = false;
+  let published = false;
+  try {
+    if (!dryRun) {
+      fs.lstatSync(legacyRoot);
+      fs.mkdirSync(path.dirname(homeRoot), { recursive: true });
+      fs.mkdirSync(staging);
+      ownsStaging = true;
+    }
+    const counts = dryRun ? inspectRunStore(legacyRoot) : copyRunStore({ from: legacyRoot, to: staging });
+    const megabytes = (counts.bytes / (1024 * 1024)).toFixed(2);
+    if (dryRun) {
+      const history = inspectRunHistory({ from: legacyRoot, git });
+      const description = history.imported === false ? history.reason : `would import ${history.commits} commits`;
+      const preview = `Would copy ${counts.files} files (${megabytes} MB) in ${counts.directories} folders from ${legacyRoot} to ${homeRoot}; history: ${description}. Dry run: nothing changed.`;
+      return { exitCode: liveRefusal ? 1 : 0, oldStore: null, homeRoot,
+        output: liveRefusal ? `${liveRefusal}\n${preview}` : preview };
+    }
+    const history = importHistory({ from: legacyRoot, to: staging, git });
+    // Plan_77 F1: a writer may start or change records during copy/history import.
+    const live = liveRuns(legacyRoot);
+    const differences = oldStoreDifferences({ from: legacyRoot, to: staging });
+    if (live.length || differences.count) {
+      fs.rmSync(staging, { recursive: true, force: true });
+      ownsStaging = false;
+      return refuse(`A run started or a record changed during the move: ${[
+        ...live.map(({ dir }) => dir), ...differences.paths,
+      ].slice(0, 20).join(', ')}. Nothing was switched; repeat when no project is running.`);
+    }
+    // Plan_77 F1: publish only our exclusive staging folder; never roll back a competing store.
+    if (checkRunStoreDestination({ from: legacyRoot, to: homeRoot })) fs.rmdirSync(homeRoot);
+    fs.renameSync(staging, homeRoot);
+    ownsStaging = false;
+    published = true;
+    const description = history.imported ? `imported ${history.commits} commits` : history.reason;
+    // D7: publishing the record is the last write, after copy verification and D4 history import.
+    writeRunsMoveRecord(stateDir ?? resolution.stateDir ?? resolveBrandHome().stateDir, { root: legacyRoot });
+    return { exitCode: 0, oldStore: legacyRoot, homeRoot,
+      output: `Moved ${counts.files} files (${megabytes} MB) from ${legacyRoot} to ${homeRoot}; history: ${description}. New runs write to ${homeRoot}. The old folder is untouched.` };
+  } catch (error) {
+    if (ownsStaging) fs.rmSync(staging, { recursive: true, force: true });
+    if (published) fs.rmSync(homeRoot, { recursive: true, force: true });
+    return refuse(`${error.message}\nNothing was switched; the old folder is untouched.`);
+  }
+}

package/cli/stop.mjs

@@ -10,7 +10,6 @@ import {
   processAlive,
 } from '../src/home/lib/process-identity.mjs';
 import { markAbandoned, readJson } from '../src/home/lib/write-meta.mjs';
-import { runsRoot } from '../src/home/lib/runner/runs-root.mjs';
 import { resolveRunFolder } from './run-lookup.mjs';
 
 const EXIT_POLL_MS = 25;
@@ -52,7 +51,7 @@ function result(exitCode, output) {
 export async function stop({
   run,
   cwd = process.cwd(),
-  runsRootPath = runsRoot(),
+  runsRootPath,
   commandRunner,
 } = {}) {
   const lookup = resolveRunFolder({ command: 'stop', run, cwd, runsRootPath });

package/cli/uninstall-purge.mjs

@@ -82,6 +82,7 @@ async function purgeInRun(options, ticket) {
     detached: true, imageMembers: plan.imageMembers, authorization,
   });
   await removeEmpty(host.commandsDir);
+  await removeEmpty(host.rulesDir);
   if (record) await removeOutside(writer, legacyInstallRecordPath(host));
   await removeEmpty(host.agentsDir);
   await removeEmptyLayout(host.legacyAgentsDir);

package/cli/uninstall.mjs

@@ -109,6 +109,7 @@ no host is recorded as using it.`,
   const plan = await buildHomeRemovalPlan({ command: 'uninstall', host, packageRoot: options.packageRoot,
     imagePolicy });
   await removeEmpty(host.commandsDir);
+  await removeEmpty(host.rulesDir);
   await removeEmpty(host.agentsDir);
   await removeEmptyLayout(host.legacyAgentsDir);
   await removeEmptyLayout(host.legacyCommandsDir);
@@ -221,6 +222,7 @@ using ${host.brandRoot}.`);
   const { outcomes } = await executeHomePlan(host, plan,
     { detached: hostSide.detached, imageMembers: plan.imageMembers });
   await removeEmpty(host.commandsDir);
+  await removeEmpty(host.rulesDir);
   if (detachedRecord) await removeOutside(writer, legacyInstallRecordPath(host));
   await removeEmpty(host.agentsDir);
   await removeEmptyLayout(host.legacyAgentsDir);

package/cli/update.mjs

@@ -73,8 +73,11 @@ function displayFile(file) {
   return `${entry.root}/${entry.path}`;
 }
 
-function classifyPlanned(state) {
-  if (!state.recorded) return 'new';
+function classifyPlanned(state, { adoptUnrecorded = false } = {}) {
+  // A planned path the record does not name but someone already filled is not ours to overwrite:
+  // install refuses it without --force, and update used to call it 'new' and copy over it — for
+  // the host rules file (Plan_64 B2c) that would silently replace the operator's own text.
+  if (!state.recorded) return state.exists && !state.matchesPackage && !adoptUnrecorded ? 'unowned' : 'new';
   if (!state.exists) return 'missing';
   if (state.matchesPackage) return 'up-to-date';
   if (state.recordedFingerprint === state.fingerprint) return 'outdated';
@@ -93,7 +96,7 @@ function appliedOutput(states) {
     [count('outdated'), 'updated'],
     [count('new'), 'added'],
     [count('missing'), 'restored'],
-    [states.filter((state) => state.status === 'modified' && state.item).length, 'overwritten'],
+    [states.filter((state) => ['modified', 'unowned'].includes(state.status) && state.item).length, 'overwritten'],
     [states.filter((state) => state.status === 'orphaned' && state.exists).length, 'removed'],
   ].filter(([total]) => total > 0).map(([total, label]) => `${total} ${label}`);
   return parts.length ? `Updated codex-bridge: ${parts.join(', ')}.` : 'Updated codex-bridge.';
@@ -103,7 +106,7 @@ function conflictOutput(conflicts, legacy, dryRun) {
   const heading = dryRun ? 'Update would stop for these paths:' : 'Update stopped for these paths:';
   const lines = conflicts.map((state) => `  ${state.relative} (${state.status})`);
   if (legacy) lines.push('Installation record has no fingerprints; differing files are treated as modified.');
-  lines.push('Run update again with --force to overwrite modified files and restore missing files.');
+  lines.push('Run update again with --force to overwrite modified or unowned files and restore missing files.');
   return [heading, ...lines].join('\n');
 }
 
@@ -112,7 +115,7 @@ function dryRunOutput(states, hookStates, legacy, oldHooks) {
   for (const state of states) {
     if (state.status === 'outdated') lines.push(`Would update ${state.relative}.`);
     if (state.status === 'new') lines.push(`Would create ${state.relative}.`);
-    if (state.status === 'modified' && state.item) lines.push(`Would overwrite ${state.relative}.`);
+    if (['modified', 'unowned'].includes(state.status) && state.item) lines.push(`Would overwrite ${state.relative}.`);
     if (state.status === 'missing') lines.push(`Would restore ${state.relative}.`);
     if (state.status === 'orphaned' && state.exists) lines.push(`Would remove ${state.relative}.`);
     if (state.status === 'modified' && !state.item) lines.push(`Would preserve modified orphan ${state.relative}.`);
@@ -228,7 +231,9 @@ async function updateInRun({
     matchesPackage: ruleExists && await targetMatches(rule, host.brandRoot),
     fingerprint: ruleExists ? await fileFingerprint(rule.target) : null,
   };
-  ruleState.status = classifyPlanned(ruleState);
+  // Records written before the Codex rules file was recorded name no rules, yet the file under the
+  // package's own name was written by this package: adopting it is the migration, not a collision.
+  ruleState.status = classifyPlanned(ruleState, { adoptUnrecorded: true });
   const orphanStates = await Promise.all(record.files
     .filter((file) => !planned.has(recordFileKey(file)))
     .map(async (file) => {
@@ -245,7 +250,7 @@ async function updateInRun({
       return { ...state, status: classifyOrphan(state) };
     }));
   const states = [...plannedStates, ruleState, ...orphanStates];
-  const conflicts = states.filter((state) => state.status === 'modified' || state.status === 'missing');
+  const conflicts = states.filter((state) => ['modified', 'unowned', 'missing'].includes(state.status));
   const legacy = !record.fingerprints;
   if (conflicts.length && !force) {
     return { exitCode: 1, output: conflictOutput(conflicts, legacy, dryRun) };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lyupro/codex-bridge",
-  "version": "0.6.12",
-  "description": "Claude Code-to-Codex delegation with 7 guards, 3267 tests, zero runtime dependencies, and zero build steps.",
+  "version": "0.6.14",
+  "description": "Claude Code-to-Codex delegation with 8 guards, 3654 tests, zero runtime dependencies, and zero build steps.",
   "keywords": [
     "claude-code",
     "codex",
@@ -34,6 +34,7 @@
     "cli",
     "src",
     "scripts",
+    "!scripts/release-check",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -41,6 +42,7 @@
   "scripts": {
     "dev:install": "node bin/codex-bridge.mjs update --force",
     "test": "node scripts/run-tests.mjs",
+    "release-check:rules-load-claude": "node scripts/release-check/rules-load-claude.mjs",
     "check:size": "node scripts/check-file-size.mjs",
     "check:open-work": "node scripts/open-work/check.mjs --strict"
   },

package/scripts/home-write-inventory.mjs

@@ -16,6 +16,18 @@ export const HOME_WRITE_INVENTORY = Object.freeze([
   outside('cli/probe-rig.mjs', 'mkdir', 2, 'Creates hook and agent directories inside the throwaway probe rig.'),
   outside('cli/probe-rig.mjs', 'writeFile', 3, 'Writes hook, agent, and settings fixtures inside the throwaway probe rig.'),
   outside('cli/prune.mjs', 'rmSync', 1, 'Deletes the explicitly selected run or archived transport target.'),
+  outside('cli/runs-move-copy.mjs', 'mkdirSync', 1, 'Recreates run folders inside the staging copy this command created (Plan_77 B5a/F1); run records are operator data outside the home writer.'),
+  outside('cli/runs-move-copy.mjs', 'copyFileSync', 1, 'Copies the run store into the runs folder and removes only the copy it created when verification fails (Plan_77 B5a); run records are operator data outside the home writer.'),
+  outside('cli/runs-move-copy.mjs', 'rmSync', 1, 'Copies the run store into the runs folder and removes only the copy it created when verification fails (Plan_77 B5a); run records are operator data outside the home writer.'),
+  outside('cli/runs-move-copy.mjs', 'openSync', 1, 'Copies the run store into the runs folder and removes only the copy it created when verification fails (Plan_77 B5a); run records are operator data outside the home writer.'),
+  outside('cli/runs-move-history.mjs', 'mkdtempSync', 1, 'Creates a temporary history clone in the system temp folder, keeping the source repository untouched (Plan_77 D4/B5b).'),
+  outside('cli/runs-move-history.mjs', 'rmSync', 2, 'Removes the temporary history clone in the system temp folder and metadata this import created on failure (Plan_77 D4/B5b).'),
+  outside('cli/runs-move.mjs', 'mkdirSync', 2, 'Creates the home parent and the exclusive staging folder of this process for the run store copy (Plan_77 F1).'),
+  outside('cli/runs-move.mjs', 'rmSync', 3, 'Removes only the staging folder this command created, or the store it just renamed into place when the move record fails (Plan_77 F1).'),
+  outside('cli/runs-move.mjs', 'rmdirSync', 1, 'Removes an empty pre-existing runs folder non-recursively before publishing the staging copy (Plan_77 F1).'),
+  outside('cli/runs-move.mjs', 'renameSync', 1, 'Publishes the verified staging copy as the runs folder (Plan_77 F1).'),
+  outside('cli/runs-move-remove.mjs', 'rmSync', 1, 'Removes the isolated old run store after the operator agrees and every file in it is proven identical in the new store (Plan_77 D3/B5c/F1).'),
+  outside('cli/runs-move-remove.mjs', 'renameSync', 2, 'Isolates the old run store before the last comparison and restores it when a difference appears (Plan_77 F1).'),
   outside('cli/remove-layout.mjs', 'rmdir', 1, 'Removes empty host package directories (agents, commands, their legacy layout); home folders go through the adapter (Plan_65 B15b2).'),
   outside('cli/rules-owners.mjs', 'rename', 1, 'Publishes the shared host rules ownership registry.'),
   outside('cli/rules-owners.mjs', 'rm', 2, 'Removes a failed temporary copy or the host rules ownership registry.'),
@@ -32,10 +44,12 @@ export const HOME_WRITE_INVENTORY = Object.freeze([
   outside('src/home/lib/file-lock.mjs', 'rm', 1, 'Raw route of the lock, taken only after writer.assertOutside proves the lock is beyond the home (Codex rules registry).'),
   outside('src/home/lib/heartbeat.mjs', 'writeFileSync', 1, 'Heartbeat stamp inside a run folder under the runs root.'),
   outside('src/home/lib/host-version.mjs', 'open', 1, 'Read-only open of a run transcript tail with the r flag.'),
+  outside('src/home/lib/load-witness.mjs', 'openSync', 1, 'Read-only open with the r flag, reading at most the shared core byte ceiling plus one sentinel byte (Plan_64 D15 / review B8); all witness state writes use the registered load-witness artifact.'),
   outside('src/home/lib/meta/run-state.mjs', 'writeFileSync', 3, 'Writes status.json and meta.json inside run folders under the runs root.'),
   outside('src/home/lib/run-codex.mjs', 'appendFileSync', 1, 'Appends a crash diagnostic to stderr.log inside a run folder.'),
-  outside('src/home/lib/retention.mjs', 'fs-binding-escape', 1, 'The injected filesystem falls back to fs while cleaning run folders under the runs root, outside package home.'),
-  outside('src/home/lib/retention.mjs', 'unlinkSync', 1, 'Removes transport files inside run folders under the runs root, outside package home.'),
+  outside('src/home/lib/retention.mjs', 'fs-binding-escape', 1, 'The injected filesystem falls back to fs while cleaning run folders under the runs root, which is operator data outside the home writer even when it is runs/ of the home (Plan_77).'),
+  outside('src/home/lib/retention.mjs', 'unlinkSync', 1, 'Removes transport files inside run folders under the runs root, which is operator data outside the home writer even when it is runs/ of the home (Plan_77).'),
+  outside('src/home/lib/runner/sandbox-diagnosis.mjs', 'openSync', 1, 'Read-only open with the r flag, reading a bounded tail of the Codex sandbox log under CODEX_HOME (Plan_78 B1).'),
   outside('src/home/lib/runner/git-state.mjs', 'openSync', 1, 'Read-only open with the r flag, hashing an untracked file of the worked repository in chunks (Plan_73 B4b).'),
   outside('src/home/lib/runner/build-evidence.mjs', 'writeFileSync', 11, 'Writes the before and after tree evidence of a build run, flags.txt and flags-coverage.txt inside a run folder.'),
   outside('src/home/lib/runner/codex-cmd.mjs', 'createWriteStream', 2, 'Appends stderr.log and events.jsonl inside a run folder.'),
@@ -53,6 +67,7 @@ export const HOME_WRITE_INVENTORY = Object.freeze([
   outside('src/home/lib/runner/project-dir.mjs', 'mkdirSync', 2, 'Creates the runs root and a project folder under the runs root.'),
   outside('src/home/lib/runner/project-dir.mjs', 'writeFileSync', 1, 'Writes the project ownership marker under the runs root.'),
   outside('src/home/lib/runner/run-context.mjs', 'writeFileSync', 1, 'Writes a worker reply inside a run folder.'),
+  outside('src/home/lib/runner/run-autocommit.mjs', 'appendFileSync', 1, 'Appends an autocommit failure line to stderr.log inside the run folder (Plan_77 B6).'),
   outside('src/home/lib/runner/worker-order.mjs', 'writeFileSync', 1, 'Writes worker.json inside a run folder.'),
   outside('src/home/lib/runner/worker.mjs', 'writeFileSync', 1, 'Writes report.md inside a run folder.'),
   outside('src/home/lib/write-meta.mjs', 'writeFileSync', 1, 'Writes meta.json inside a run folder under the runs root.'),

package/scripts/isolated-roots.mjs

@@ -8,7 +8,8 @@
  * stood in the way of the seeded-file migration the release was about.
  *
  * `CODEX_RUNS_ROOT` joined before a failure rather than after one (Plan_65 B12): the runs root
- * falls back to the operator's `~/.claude/codex-runs`, so a runner test that did not name it
+ * falls back to the resolver's default (the package home's `runs/`, or the old
+ * `~/.claude/codex-runs` while a move is pending), so a runner test that did not name it
  * filed its runs among real ones, and the purge liveness checks would read real live runs as the
  * fixture's — a verdict that depends on what the operator happens to be running.
  *

package/src/{agents → claude/agents}/codex-advisor.md

@@ -1,6 +1,6 @@
 ---
 name: codex-advisor
-description: Независимое второе мнение по DESIGN до появления кода — что правильно, а не что уже есть; работу выполняет Codex CLI по подписке ChatGPT, строго read-only. Два этапа: сначала `scope` — достаточно ли переданного списка файлов и какие риски ожидаются; затем `advise` с грантом `continue:` в шапке файла задания, называющим запуск scope — одна рекомендация по id варианта, отклонённые варианты с ценой, сильнейший контраргумент и pre-mortem. Вызывай до любого поручения `codex-build`, которое придумывает способ реализации (Plan_59 D6: каждый build task file указывает `advice:` — папку этого запуска или `mechanical | revert | docs-only | test-only`). Полный результат — в ~/.claude/codex-runs/, в чате — не более пяти строк и путь. {{CODEX_REQUIRED_INPUTS_SUMMARY}} {{CODEX_STOP_SUMMARY}}
+description: Независимое второе мнение по DESIGN до появления кода — что правильно, а не что уже есть; работу выполняет Codex CLI по подписке ChatGPT, строго read-only. Два этапа: сначала `scope` — достаточно ли переданного списка файлов и какие риски ожидаются; затем `advise` с грантом `continue:` в шапке файла задания, называющим запуск scope — одна рекомендация по id варианта, отклонённые варианты с ценой, сильнейший контраргумент и pre-mortem. Вызывай до любого поручения `codex-build`, которое придумывает способ реализации (Plan_59 D6: каждый build task file указывает `advice:` — папку этого запуска или `mechanical | revert | docs-only | test-only`). Полный результат — в корень прогонов (`codex-bridge doctor` → `runsRoot`; по умолчанию `~/.lyupro/.codex-bridge/runs/`), в чате — не более пяти строк и путь. {{CODEX_REQUIRED_INPUTS_SUMMARY}} {{CODEX_STOP_SUMMARY}}
 model: haiku
 tools: Bash
 ---
@@ -42,7 +42,7 @@ successful scope run's `missing_paths`.
 
 Return the attaching output exactly as printed by the runner, including its ready-made short
 result and report path. Do not compose, summarize, or improve the result yourself. The full report
-lives under `~/.claude/codex-runs/`; the orchestrator receives no more than five lines plus that
+lives under the runs root (`codex-bridge doctor` → `runsRoot`; by default `~/.lyupro/.codex-bridge/runs/`); the orchestrator receives no more than five lines plus that
 path.
 
 ## The script determines status, not you
@@ -52,7 +52,7 @@ path.
 - `FAIL` — the result is empty, invalid, the return code is nonzero, or the run was abandoned.
 - `LIMIT` — the result is empty and the log signals a ChatGPT quota limit. The quota is spent and
   the task was not completed; do not restart it.
-- `UNAVAILABLE` — Codex is missing or signed out (checked before start, or recognised from the CLI's own
+- `UNAVAILABLE` — Codex is signed out (checked before start, or recognised from the CLI's own
   sign-in refusal after start). The task was not attempted or could not run; this is not a task failure and
   not a reason to restart — return the block as is, the orchestrator hands the task to the next executor.
 
@@ -78,10 +78,11 @@ the runner refuses a continued scope, because it would spend the continuation th
 
 ## Codex is unavailable
 
-The runner looks `codex` up on PATH and asks `codex login status` before starting. A missing binary
-or the measured "Not logged in" answer prints a ready-made `UNAVAILABLE` block (first line
-`UNAVAILABLE — `, exit 5, no run folder). An unclear probe prints an ordinary refusal starting
-`Codex CLI unavailable:` (exit 1). Return that output verbatim.
+The runner looks `codex` up on PATH and retries once after ~1 s. If the lookup still fails, it prints
+an ordinary refusal starting `Codex CLI readiness unconfirmed:` (exit 1, no run folder).
+When found, it asks `codex login status` before starting. The measured "Not logged in" answer prints
+a ready-made `UNAVAILABLE` block (first line `UNAVAILABLE — `, exit 5, no run folder). Any other unclear
+probe prints an ordinary refusal starting `Codex CLI unavailable:` (exit 1). Return that output verbatim.
 Performing the task manually instead of Codex is prohibited for any reason it fails.
 
 ## What a violation looks like