@lyupro/codex-bridge 0.6.11 → 0.6.14

package/cli/remove-layout.mjs

@@ -33,15 +33,15 @@ export async function removeEmptyParents(target, boundary) {
 }
 
 /**
- * The directory an emptied-parent walk must stop at. Plan_25 gave the host four package-owned
- * directories at once — the current agents and commands subdirectories and the two the previous
- * layout used — and a walk that started inside one of them but stopped at host.root would delete
- * the operator's own emptied directories on the way up.
+ * The directory an emptied-parent walk must stop at: five package-owned directories: current
+ * agents, commands and rules (Plan_64 D5, D9), plus the two legacy directories (Plan_25).
+ * Stopping there preserves the operator's own emptied parent directories.
  */
 export function claudeBoundary(host, target) {
   const directories = [
     host.agentsDir,
     host.commandsDir,
+    host.rulesDir,
     host.legacyAgentsDir,
     host.legacyCommandsDir,
   ].filter(Boolean);

package/cli/run-lookup.mjs

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { git } from '../src/home/lib/runner/git-state.mjs';
 import { resolveProjectRunsDir } from '../src/home/lib/runner/project-dir.mjs';
-import { runsRoot } from '../src/home/lib/runner/runs-root.mjs';
+import { retiredPathRefusal, runsRootResolution, staleOverrideRefusal } from '../src/home/lib/runner/runs-root.mjs';
 
 function projectRoot(cwd) {
   const result = git(cwd, ['rev-parse', '--show-toplevel']);
@@ -23,7 +23,8 @@ export function resolveRunFolder({
   command = 'stop',
   run,
   cwd = process.cwd(),
-  runsRootPath = runsRoot(),
+  runsRootPath,
+  resolution = runsRootResolution(),
 } = {}) {
   const commandName = String(command || 'stop');
   const value = String(run ?? '').trim();
@@ -31,6 +32,17 @@ export function resolveRunFolder({
     return refusal(commandName, `${commandName} requires a run folder (full path or bare folder name)`);
   }
 
+  // Plan_77 D6: run-lookup.mjs:51-55 only said "Run folder not found" after stat on an old path.
+  if (path.isAbsolute(value)) {
+    const retired = retiredPathRefusal(value, resolution);
+    if (retired) return refusal(commandName, retired);
+  }
+  if (runsRootPath === undefined) {
+    const stale = staleOverrideRefusal(resolution);
+    if (stale) return refusal(commandName, stale);
+    runsRootPath = resolution.root;
+  }
+
   let runDir;
   try {
     if (path.isAbsolute(value)) runDir = path.resolve(value);

package/cli/runs-inventory.mjs

@@ -108,6 +108,7 @@ function readRun(runDir, livePaths) {
   const live = livePaths.has(pathKey(runDir));
   return {
     run: path.basename(runDir),
+    path: path.resolve(runDir),
     agent: text(facts?.agent),
     verdict: live ? 'running' : text(meta ? meta.status : runLiveness({ runDir, status }).state),
     tokens: meta ? number(meta.tokens) : null,
@@ -120,6 +121,8 @@ function readRun(runDir, livePaths) {
 function publicRun(run) {
   return {
     run: run.run,
+    // D10: the core names no run root, so each JSON row must carry its address.
+    path: run.path,
     agent: run.agent,
     verdict: run.verdict,
     tokens: run.tokens,
@@ -155,16 +158,21 @@ function buildProject(projectDir) {
 }
 
 function projectDirectory(root, name) {
-  return directoryEntries(root)
+  return projectEntries(root)
     .find((entry) => entry.name === name)
     ? path.join(root, name)
     : null;
 }
 
+function projectEntries(root) {
+  // Plan_77 B5b makes the moved store a git repository; its metadata is not a project.
+  return directoryEntries(root).filter((entry) => entry.name !== '.git');
+}
+
 /** Lists one summary row per project directory. */
 export function listProjects(runsRootPath = runsRoot()) {
   const root = normalizeRoot(runsRootPath);
-  return directoryEntries(root).map((entry) => buildProject(path.join(root, entry.name)).summary);
+  return projectEntries(root).map((entry) => buildProject(path.join(root, entry.name)).summary);
 }
 
 /** Lists one detail row per run directory in a named project, or null when there is no such project. */

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.11",
-  "description": "Claude Code-to-Codex delegation with 7 guards, 3199 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"
   },