@lyupro/codex-bridge 0.6.8 → 0.6.9

package/cli/update.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { packageSource, sourceAt, checkoutAt } from './package-source.mjs';
 import { install } from './install.mjs';
+import { syncOtherOwners } from './owner-sync-apply.mjs';
 import {
   buildInstallPlan,
   fileFingerprint,
@@ -18,15 +19,20 @@ import {
 } from './manifest.mjs';
 import { targetMatches } from './copy.mjs';
 import { hookTargets, recordHasHooks } from './hook-targets.mjs';
-import { definitionForRecordedHook, fileEntry, fingerprintFor } from './install-record.mjs';
+import { definitionForRecordedHook, fileEntry, fingerprintFor, readInstallRecordFile } from './install-record.mjs';
+import { ownImageStampCurrent } from './install-owners.mjs';
 import {
   commandFor,
   inspectHook,
   removeHook,
   withSettingsRun,
 } from './settings-merge.mjs';
+import { withLifecycle } from './lifecycle-transaction.mjs';
 import { addRulesOwner, readRulesRegistry } from './rules-owners.mjs';
-import { claudeBoundary, removeEmptyLayout, removeEmptyParents } from './remove-layout.mjs';
+import { removeEmptyLayout } from './remove-layout.mjs';
+import { recordHomeWriter, removeOutside, removeRecordedFile } from './record-removal.mjs';
+import { askTransition, detectTransition, transitionOutcome } from './inventory-transition.mjs';
+import { hasPackageMarks, inspectHost } from './host-inspection.mjs';
 
 const LEGACY_GUARD_LOG_FILES = [
   'codex-reply-guard.blocked.json',
@@ -44,19 +50,19 @@ async function exists(target) {
 }
 
 /** Drops the previous layout's record and its emptied directories; safe to run when both are gone. */
-async function retireLegacyLayout(host) {
-  await fs.rm(legacyInstallRecordPath(host), { force: true });
+async function retireLegacyLayout(host, writer) {
+  await removeOutside(writer, legacyInstallRecordPath(host));
   await removeEmptyLayout(host.legacyAgentsDir);
   await removeEmptyLayout(host.legacyCommandsDir);
 }
 
-async function retireLegacyGuardLogs(host, { dryRun = false } = {}) {
+async function retireLegacyGuardLogs(host, writer, { dryRun = false } = {}) {
   const logDir = path.join(path.dirname(host.settingsPath), 'logs');
   const lines = [];
   for (const name of LEGACY_GUARD_LOG_FILES) {
     const target = path.join(logDir, name);
     if (!await exists(target)) continue;
-    if (!dryRun) await fs.rm(target, { force: true });
+    if (!dryRun) await removeOutside(writer, target);
     lines.push(`${dryRun ? 'Would remove' : 'Removed'} ${path.join('logs', name)}.`);
   }
   return lines.join('\n');
@@ -153,12 +159,47 @@ function previousHooks(host, record, targets) {
   });
 }
 
-async function updateInRun({ host, dryRun = false, force = false, packageRoot, env = process.env } = {}) {
+async function updateInRun({
+  host,
+  dryRun = false,
+  force = false,
+  packageRoot,
+  env = process.env,
+  lifecycleTicket,
+  isTTY,
+  prompt,
+  stdin,
+  promptOutput,
+} = {}) {
   await readRulesRegistry(host);
   const record = await readInstallRecord(host);
+  const rawRecord = await readInstallRecordFile(host);
   if (!record) {
-    return { exitCode: 1, output: 'codex-bridge is not installed. Run codex-bridge install first.' };
+    // Plan_65 D10 item 6: a host that carries our files or hooks but has no row (legacy is nobody's view
+    // since H5) is recorded by what is actually there. Install owns that — conflicts for edited files, the
+    // transition question — and update has changed nothing yet, so the question still precedes any change.
+    const inspection = await inspectHost(host);
+    if (!hasPackageMarks(inspection)) {
+      return { exitCode: 1, output: 'codex-bridge is not installed. Run codex-bridge install first.' };
+    }
+    const installed = await install({
+      host,
+      dryRun,
+      force,
+      packageRoot,
+      env,
+      lifecycleTicket,
+      isTTY,
+      prompt,
+      stdin,
+      promptOutput,
+    });
+    return {
+      exitCode: installed.exitCode,
+      output: `No installation record names ${host.root}; recording what is installed.\n${installed.output}`,
+    };
   }
+  const writer = recordHomeWriter(host, record.files);
 
   const plan = await buildInstallPlan(host, packageRoot);
   const rule = { ...rulesPlan(host, packageRoot), processing: 'copy' };
@@ -210,6 +251,17 @@ async function updateInRun({ host, dryRun = false, force = false, packageRoot, e
     return { exitCode: 1, output: conflictOutput(conflicts, legacy, dryRun) };
   }
 
+  // Plan_65 D9: ask before the first change (orphans, hooks, the legacy layout) and hand install the one
+  // answer: after that cleanup the nested run could neither ask honestly nor recount homeHadImage.
+  const { transition, homeHadImage } = await detectTransition(host);
+  let inventory;
+  if (transition && !dryRun) {
+    inventory = await askTransition(host, { isTTY, prompt, stdin, promptOutput });
+    if (inventory === 'cancel') {
+      return { exitCode: 130, output: 'Cancelled; nothing was changed.' };
+    }
+  }
+
   const currentPackage = await packageInfo(packageRoot);
   // The 2026-09-07, 0.6.0 install incident hid which package's files update actually compared.
   const resolved = packageRoot ? sourceAt(packageRoot) : packageSource();
@@ -232,51 +284,67 @@ async function updateInRun({ host, dryRun = false, force = false, packageRoot, e
   const recordCurrent = recordMatchesPackage(record, plan, currentPackage,
     new Map(plannedStates.map((state) => [recordFileKey(state.item), state.fingerprint])),
     { path: rule.target, fingerprint: ruleState.fingerprint });
-  const changed = states.some((state) => state.status !== 'up-to-date') || oldHooks.length > 0;
+  // Plan_65 D9: a format-1 migration remains work when every installed file is current.
+  const changed = transition || states.some((state) => state.status !== 'up-to-date') || oldHooks.length > 0;
+  // D11: the command doctor recommends must clear its warning about this host's image stamp.
   if (!changed && inspectedHooks.every(({ state }) => state.current)
-    && recordHasHooks(record, targets) && recordCurrent) {
-    const legacyLogOutput = await retireLegacyGuardLogs(host, { dryRun });
+    && recordHasHooks(record, targets) && recordCurrent && ownImageStampCurrent(rawRecord, host)) {
+    const legacyLogOutput = await retireLegacyGuardLogs(host, writer, { dryRun });
     if (!dryRun) {
       await addRulesOwner(host);
       // An update that installed the new layout but stopped before retiring the old one used to
       // land here forever after: everything it compares is current, so it reported "up to date"
       // while agents/codex sat next to agents/codex-bridge. Retirement is idempotent, so running
       // it on this path costs nothing when there is nothing left to retire.
-      await retireLegacyLayout(host);
+      await retireLegacyLayout(host, writer);
     }
+    const ownerSync = await syncOtherOwners(host, { packageRoot, env, dryRun });
     return {
-      exitCode: 0,
-      output: [`codex-bridge is up to date with ${source}${mismatch}`, legacyLogOutput]
+      exitCode: ownerSync.complete ? 0 : 1,
+      output: [`codex-bridge is up to date with ${source}${mismatch}`, legacyLogOutput, ...ownerSync.lines]
         .filter(Boolean).join('\n'),
     };
   }
   if (dryRun) {
-    const legacyLogOutput = await retireLegacyGuardLogs(host, { dryRun: true });
+    const legacyLogOutput = await retireLegacyGuardLogs(host, writer, { dryRun: true });
+    const ownerSync = await syncOtherOwners(host, { packageRoot, env, dryRun });
     return {
       exitCode: 0,
       output: [`Would update codex-bridge with ${source}.${mismatch}`,
-        dryRunOutput(states, inspectedHooks, legacy, oldHooks), legacyLogOutput]
+        ...(transition ? [`A real run would ask whether this host is the only one using ${host.brandRoot}.`] : []),
+        dryRunOutput(states, inspectedHooks, legacy, oldHooks), legacyLogOutput, ...ownerSync.lines]
         .filter(Boolean).join('\n'),
     };
   }
 
   for (const state of orphanStates) {
     if (state.status !== 'orphaned' || !state.exists) continue;
-    const target = recordTarget(host, state.entry);
-    await fs.rm(target, { force: true });
-    const boundary = state.entry.root === 'brand' ? host.brandRoot : claudeBoundary(host, target);
-    await removeEmptyParents(target, boundary);
+    await removeRecordedFile(host, writer, state.entry);
   }
   for (const { spec, hook } of oldHooks) {
     await removeHook(host.settingsPath, spec, { createdGroup: hook.createdGroup === true });
   }
-  const installed = await install({ host, force: true, packageRoot, env });
-  if (installed.exitCode !== 0) return installed;
-  await retireLegacyLayout(host);
-  const legacyLogOutput = await retireLegacyGuardLogs(host);
+  const installed = await install({
+    host,
+    force: true,
+    packageRoot,
+    env,
+    lifecycleTicket,
+    isTTY,
+    prompt,
+    stdin,
+    promptOutput,
+    inventoryTransition: { transition, homeHadImage, inventory },
+  });
+  // Plan_65 D7: another owner left behind must not prevent this host's retirement and summary.
+  if (installed.exitCode !== 0 && installed.ownerSync?.complete !== false) return installed;
+  await retireLegacyLayout(host, writer);
+  const legacyLogOutput = await retireLegacyGuardLogs(host, writer);
+  const outcome = transition ? transitionOutcome(host, inventory) : null;
   return {
-    exitCode: 0,
-    output: [`${appliedOutput(states)}\nSource: ${source}${mismatch}`, legacyLogOutput]
+    exitCode: installed.exitCode,
+    output: [`${appliedOutput(states)}\nSource: ${source}${mismatch}`, outcome, legacyLogOutput,
+      ...installed.ownerSync.lines]
       .filter(Boolean).join('\n'),
   };
 }
@@ -284,5 +352,12 @@ async function updateInRun({ host, dryRun = false, force = false, packageRoot, e
 export async function update(options = {}) {
   const host = options?.host;
   if (!host?.settingsPath) return updateInRun(options);
-  return withSettingsRun(host.settingsPath, () => updateInRun(options));
+  // A dry run only reads; like install's, it must not wait on or create anything.
+  if (options.dryRun === true) return withSettingsRun(host.settingsPath, () => updateInRun(options));
+  return withLifecycle(
+    host,
+    'update',
+    (ticket) => withSettingsRun(host.settingsPath, () => updateInRun({ ...options, lifecycleTicket: ticket })),
+    { ticket: options.lifecycleTicket, waitMs: options.lifecycleWaitMs },
+  );
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lyupro/codex-bridge",
-  "version": "0.6.8",
-  "description": "Claude Code-to-Codex delegation with 7 guards, 1667 tests, zero runtime dependencies, and zero build steps.",
+  "version": "0.6.9",
+  "description": "Claude Code-to-Codex delegation with 7 guards, 2570 tests, zero runtime dependencies, and zero build steps.",
   "keywords": [
     "claude-code",
     "codex",
@@ -41,7 +41,8 @@
   "scripts": {
     "dev:install": "node bin/codex-bridge.mjs update --force",
     "test": "node scripts/run-tests.mjs",
-    "check:size": "node scripts/check-file-size.mjs"
+    "check:size": "node scripts/check-file-size.mjs",
+    "check:open-work": "node scripts/open-work/check.mjs --strict"
   },
   "publishConfig": {
     "access": "public"

package/scripts/home-write-audit.mjs

@@ -0,0 +1,286 @@
+/**
+ * Checks filesystem write boundaries before tests start. Plan_62 D22 made package-home writes
+ * removable only when they pass through the artifact adapter; Plan_65 B1b keeps that boundary
+ * enforceable while existing writers are migrated.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { lexSource } from './home-write-lexer.mjs';
+
+const FILESYSTEM_MODULES = new Set(['node:fs', 'node:fs/promises', 'fs', 'fs/promises']);
+const FILESYSTEM_WRITES = [
+  'writeFile', 'writeFileSync', 'appendFile', 'appendFileSync', 'rename', 'renameSync',
+  'copyFile', 'copyFileSync', 'cp', 'cpSync', 'mkdir', 'mkdirSync', 'mkdtemp', 'mkdtempSync',
+  'rm', 'rmSync', 'rmdir', 'rmdirSync', 'unlink', 'unlinkSync', 'open', 'openSync',
+  'createWriteStream', 'symlink', 'symlinkSync', 'link', 'linkSync', 'truncate', 'truncateSync',
+  'utimes', 'utimesSync',
+];
+const GENERIC_WRITES = ['withOutsideFileLock'];
+const ADAPTER_MODULE = 'src/home/lib/home-write.mjs';
+
+function modulePaths(repositoryRoot) {
+  const modules = [];
+  const visit = (directory) => {
+    if (!fs.existsSync(directory)) return;
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+      const fullPath = path.join(directory, entry.name);
+      if (entry.isDirectory()) visit(fullPath);
+      else if (entry.isFile() && entry.name.endsWith('.mjs')) {
+        modules.push(path.relative(repositoryRoot, fullPath).split(path.sep).join('/'));
+      }
+    }
+  };
+  for (const directory of ['src', 'cli', 'bin']) visit(path.join(repositoryRoot, directory));
+  return modules.sort();
+}
+
+function importBindings(source, code, module, violations) {
+  const bindings = [];
+  const importPattern = /\bimport\s+([\s\S]*?)\s+from\s+(['"])([^'"]+)\2/g;
+  for (const match of source.matchAll(importPattern)) {
+    if (!/^import\b/.test(code.slice(match.index))) continue;
+    if (!FILESYSTEM_MODULES.has(match[3])) continue;
+    const clauseOffset = match[0].indexOf(match[1]);
+    const clause = match[1].trim();
+    const leading = match[1].length - match[1].trimStart().length;
+    const defaultBinding = clause.match(/^([A-Za-z_$][\w$]*)\b/);
+    if (defaultBinding) {
+      bindings.push({
+        name: defaultBinding[1],
+        declarationIndex: match.index + clauseOffset + leading,
+      });
+    }
+    const namespaceBinding = clause.match(/\*\s+as\s+([A-Za-z_$][\w$]*)/);
+    if (namespaceBinding) {
+      const localOffset = clause.indexOf(namespaceBinding[1], namespaceBinding.index);
+      bindings.push({
+        name: namespaceBinding[1],
+        declarationIndex: match.index + clauseOffset + leading + localOffset,
+      });
+    }
+    for (const named of clause.matchAll(/\{([^}]*)\}/g)) {
+      for (const specifier of named[1].split(',')) {
+        const parts = specifier.trim().split(/\s+as\s+/);
+        const imported = parts[0].trim();
+        if (FILESYSTEM_WRITES.includes(imported)) {
+          violations.push({
+            module,
+            sink: `named-import:${imported}`,
+            problem: `named filesystem write import${parts[1] ? ` as ${parts[1].trim()}` : ''} is forbidden`,
+          });
+        }
+      }
+    }
+  }
+  return bindings;
+}
+
+function assignedBinding(source, index) {
+  const prefix = source.slice(Math.max(0, index - 100), index);
+  const match = prefix.match(/\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*$/);
+  if (!match) return null;
+  return {
+    name: match[1],
+    declarationIndex: Math.max(0, index - 100) + match.index + match[0].indexOf(match[1]),
+  };
+}
+
+function collectLoaderBindings(source, code, module, violations) {
+  const bindings = [];
+  const requirePattern = /\brequire\s*\(\s*(['"])(node:)?fs(?:\/promises)?\1\s*\)/g;
+  for (const match of source.matchAll(requirePattern)) {
+    if (!/^require\b/.test(code.slice(match.index))) continue;
+    violations.push({ module, sink: 'require:fs', problem: 'filesystem module loaded with require()' });
+    const binding = assignedBinding(source, match.index);
+    if (binding) bindings.push(binding);
+  }
+  const dynamicPattern = /\bimport\s*\(\s*(['"])(node:)?fs(?:\/promises)?\1\s*\)/g;
+  for (const match of source.matchAll(dynamicPattern)) {
+    if (!/^import\b/.test(code.slice(match.index))) continue;
+    violations.push({ module, sink: 'dynamic-import:fs', problem: 'filesystem module loaded with dynamic import()' });
+    const binding = assignedBinding(source, match.index);
+    if (binding) bindings.push(binding);
+  }
+  for (const match of source.matchAll(/\bcreateRequire\s*\(/g)) {
+    if (!/^createRequire\b/.test(code.slice(match.index))) continue;
+    violations.push({ module, sink: 'createRequire', problem: 'createRequire() can bypass filesystem binding checks' });
+  }
+  return bindings;
+}
+
+function valueUses(code, name) {
+  const safe = escaped(name);
+  const pattern = new RegExp(`\\b${safe}\\b`, 'g');
+  for (const match of code.matchAll(pattern)) {
+    const before = code.slice(0, match.index).match(/(?:\\?\.|\.)\s*$/);
+    const after = code.slice(match.index + match[0].length).match(/^\s*(?:\?\.|\.)/);
+    if (!before && !after) return true;
+  }
+  return false;
+}
+
+function collectBindings(source, code, module, violations) {
+  const bindings = [
+    ...importBindings(source, code, module, violations),
+    ...collectLoaderBindings(source, code, module, violations),
+  ];
+  const byName = new Map();
+  const add = (binding) => {
+    const record = byName.get(binding.name) ?? { name: binding.name, declarations: new Set() };
+    if (binding.declarationIndex !== undefined) record.declarations.add(binding.declarationIndex);
+    byName.set(binding.name, record);
+  };
+  for (const binding of bindings) {
+    add(binding);
+  }
+
+  let added;
+  do {
+    added = false;
+    const declarations = /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*([^;\r\n]+)/g;
+    for (const match of code.matchAll(declarations)) {
+      if (byName.has(match[1])) continue;
+      if (![...byName.keys()].some((name) => valueUses(match[2], name))) continue;
+      add({ name: match[1], declarationIndex: match.index + match[0].indexOf(match[1]) });
+      added = true;
+    }
+  } while (added);
+  return [...byName.values()];
+}
+
+function escaped(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function hasDeclaration(code, name) {
+  const safe = escaped(name);
+  return new RegExp(`\\bfunction\\s+${safe}\\s*\\(|\\b(?:const|let|var)\\s+${safe}\\s*=`).test(code);
+}
+
+function callCounts(code, bindings, module, helperDefiners) {
+  const counts = new Map();
+  const writeAlternation = FILESYSTEM_WRITES.join('|');
+  for (const { name: binding } of bindings) {
+    const safe = escaped(binding);
+    const calls = new RegExp(`\\b${safe}\\s*(?:\\?\\.\\s*|\\.\\s*)(?:promises\\s*\\.\\s*)?(${writeAlternation})\\s*(?:\\?\\.)?\\s*\\(`, 'g');
+    for (const match of code.matchAll(calls)) counts.set(match[1], (counts.get(match[1]) ?? 0) + 1);
+  }
+  for (const name of GENERIC_WRITES) {
+    if (helperDefiners.get(name)?.has(module)) continue;
+    const calls = new RegExp(`\\b${name}\\s*\\(`, 'g');
+    for (const _match of code.matchAll(calls)) counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return counts;
+}
+
+function scanModule({ module, original, actualCounts, violations, helperDefiners }) {
+  if (module === ADAPTER_MODULE) return;
+  const { code, withoutComments } = lexSource(original);
+  const bindings = collectBindings(withoutComments, code, module, violations);
+  const writeAlternation = FILESYSTEM_WRITES.join('|');
+  for (const { name: binding, declarations } of bindings) {
+    const safe = escaped(binding);
+    const computed = new RegExp(`\\b${safe}\\s*(?:\\.\\s*promises\\s*)?\\s*\\[`, 'g');
+    for (const match of code.matchAll(computed)) {
+      violations.push({ module, sink: 'computed-fs-access', problem: 'computed access on filesystem binding is forbidden' });
+    }
+    const calls = new RegExp(`\\b${safe}\\s*(?:\\?\\.\\s*|\\.\\s*)(?:promises\\s*\\.\\s*)?(${writeAlternation})\\s*(?:\\?\\.)?\\s*\\(`, 'g');
+    for (const match of code.matchAll(calls)) {
+      const key = `${module}\0${match[1]}`;
+      actualCounts.set(key, (actualCounts.get(key) ?? 0) + 1);
+    }
+    const references = new RegExp(`\\b${safe}\\s*(?:\\.\\s*promises\\s*)?\\.\\s*(${writeAlternation})\\b(?!\\s*(?:\\?\\.)?\\s*\\()`, 'g');
+    for (const match of code.matchAll(references)) {
+      violations.push({ module, sink: `write-reference:${match[1]}`, problem: 'filesystem write function is referenced without a call' });
+    }
+    const assignment = new RegExp(`(?<![\\w$.])${safe}\\s*(?:=(?!=|>)|\\+=|-=|\\*=|\\/=|\\+\\+|--)`, 'g');
+    for (const match of code.matchAll(assignment)) {
+      if (declarations.has(match.index)) continue;
+      const prefix = code.slice(Math.max(0, match.index - 30), match.index);
+      if (!/\b(?:const|let|var)\s+$/.test(prefix)) {
+        violations.push({ module, sink: 'fs-binding-reassigned', problem: 'filesystem binding is reassigned' });
+      }
+    }
+    const bindingUses = new RegExp(`\\b${safe}\\b`, 'g');
+    for (const match of code.matchAll(bindingUses)) {
+      if (declarations.has(match.index)) continue;
+      if (/(?:\\?\.|\.)\s*$/.test(code.slice(0, match.index))) continue;
+      if (/^\s*(?:\?\.|\.)/.test(code.slice(match.index + match[0].length))) continue;
+      const key = `${module}\0fs-binding-escape`;
+      actualCounts.set(key, (actualCounts.get(key) ?? 0) + 1);
+    }
+  }
+  for (const [sink, count] of callCounts(code, bindings, module, helperDefiners)) {
+    actualCounts.set(`${module}\0${sink}`, count);
+  }
+  const rawCounts = callCounts(withoutComments, bindings, module, helperDefiners);
+  const maskedCounts = callCounts(code, bindings, module, helperDefiners);
+  // A literal that swallowed code and a literal that is code (cli/probe-rig.mjs writes a hook's
+  // source as a template) look the same to a lexer. Both are counted as `literal:<sink>` and must be
+  // inventoried with their exact count, so a literal can be explained but never grow unnoticed.
+  for (const [sink, rawCount] of rawCounts) {
+    const hidden = rawCount - (maskedCounts.get(sink) ?? 0);
+    if (hidden > 0) actualCounts.set(`${module}literal:${sink}`, hidden);
+  }
+}
+
+function discoverHelperDefiners(modules, repositoryRoot) {
+  const definers = new Map(GENERIC_WRITES.map((name) => [name, new Set()]));
+  for (const module of modules) {
+    const code = lexSource(fs.readFileSync(path.join(repositoryRoot, module), 'utf8')).code;
+    for (const name of GENERIC_WRITES) {
+      if (hasDeclaration(code, name)) definers.get(name).add(module);
+    }
+  }
+  return definers;
+}
+
+/** Returns unaccounted writes, inventory count drift, and fail-closed binding violations. */
+export function auditWrites({ repositoryRoot, inventory }) {
+  const modules = modulePaths(repositoryRoot);
+  const moduleSet = new Set(modules);
+  const violations = [];
+  const actualCounts = new Map();
+  const inventoryCounts = new Map();
+  for (const entry of inventory) {
+    const key = `${entry.module}\0${entry.sink}`;
+    if (inventoryCounts.has(key)) {
+      violations.push({ module: entry.module, sink: entry.sink, problem: 'duplicate inventory entry' });
+    }
+    inventoryCounts.set(key, entry.count);
+    if (!moduleSet.has(entry.module)) {
+      violations.push({ module: entry.module, sink: entry.sink, problem: 'inventory entry names a missing module' });
+    }
+  }
+  const helperDefiners = discoverHelperDefiners(modules, repositoryRoot);
+  for (const module of modules) {
+    scanModule({
+      module,
+      original: fs.readFileSync(path.join(repositoryRoot, module), 'utf8'),
+      actualCounts,
+      violations,
+      helperDefiners,
+    });
+  }
+  for (const [key, count] of actualCounts) {
+    const [module, sink] = key.split('\0');
+    const expected = inventoryCounts.get(key);
+    if (expected === undefined) {
+      violations.push({ module, sink, problem: `not inventoried (actual count ${count})` });
+    } else if (count > expected) {
+      violations.push({ module, sink, problem: `actual count ${count} exceeds inventory count ${expected}` });
+    } else if (count < expected) {
+      violations.push({ module, sink, problem: `actual count ${count} is below inventory count ${expected}` });
+    }
+  }
+  for (const [key, expected] of inventoryCounts) {
+    if (actualCounts.has(key)) continue;
+    const [module, sink] = key.split('\0');
+    if (moduleSet.has(module)) {
+      violations.push({ module, sink, problem: `actual count 0 is below inventory count ${expected}` });
+    }
+  }
+  violations.sort((left, right) => left.module.localeCompare(right.module)
+    || left.sink.localeCompare(right.sink) || left.problem.localeCompare(right.problem));
+  return { violations };
+}

package/scripts/home-write-inventory.mjs

@@ -0,0 +1,49 @@
+/**
+ * Freezes the writes that predate Plan_65 B1b so each new write or stale exception is visible.
+ * Home entries name their registered artifact and the Plan_65 order that removes the exception.
+ */
+const outside = (module, sink, count, reason) => ({ module, sink, count, kind: 'outside-home', reason });
+
+export const HOME_WRITE_INVENTORY = Object.freeze([
+  outside('cli/copy.mjs', 'mkdir', 1, 'Raw route of the planned-file copier, taken only after writer.assertOutside proves the target is beyond the home (Claude host files, Codex rules).'),
+  outside('cli/copy.mjs', 'rename', 1, 'Raw route of the planned-file copier, taken only after writer.assertOutside proves the target is beyond the home (Claude host files, Codex rules).'),
+  outside('cli/copy.mjs', 'rm', 1, 'Raw route of the planned-file copier, taken only after writer.assertOutside proves the target is beyond the home (Claude host files, Codex rules).'),
+  outside('cli/copy.mjs', 'writeFile', 1, 'Raw route of the planned-file copier, taken only after writer.assertOutside proves the target is beyond the home (Claude host files, Codex rules).'),
+  outside('cli/probe-contract.mjs', 'mkdir', 1, 'Creates the throwaway probe rig root.'),
+  outside('cli/probe-contract.mjs', 'mkdtemp', 1, 'Creates a unique throwaway probe rig.'),
+  outside('cli/probe-contract.mjs', 'rm', 1, 'Removes the throwaway probe rig after the contract probe.'),
+  outside('cli/probe-rig.mjs', 'literal:appendFileSync', 2, 'Source text of the probe hook, written into and run only inside the throwaway probe rig.'),
+  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/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.'),
+  outside('cli/rules-owners.mjs', 'withOutsideFileLock', 1, 'Locks the shared registry under the host Codex rules directory.'),
+  outside('cli/rules-owners.mjs', 'writeFile', 1, 'Writes a temporary shared host rules ownership registry.'),
+  outside('cli/settings-merge.mjs', 'mkdir', 1, 'Creates the host settings.json parent directory.'),
+  outside('cli/settings-merge.mjs', 'rename', 1, 'Atomically publishes the host settings.json update.'),
+  outside('cli/settings-merge.mjs', 'rm', 1, 'Removes a failed temporary host settings.json update.'),
+  outside('cli/settings-merge.mjs', 'writeFile', 2, 'Writes the host settings.json backup and temporary replacement.'),
+  outside('cli/record-removal.mjs', 'rm', 1, 'Raw removal taken only after writer.assertOutside proves the target is beyond the home (Claude host files, Codex rules, legacy records, logs and migrated seeds).'),
+  outside('src/home/lib/config-edit.mjs', 'rmdir', 1, 'Removes empty ancestors of the home root that this edit created, above the home.'),
+  outside('src/home/lib/file-lock.mjs', 'mkdir', 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/file-lock.mjs', 'open', 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/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/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/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/codex-cmd.mjs', 'createWriteStream', 2, 'Appends stderr.log and events.jsonl inside a run folder.'),
+  outside('src/home/lib/runner/launcher.mjs', 'mkdirSync', 2, 'Creates project and run folders under the runs root.'),
+  outside('src/home/lib/runner/launcher.mjs', 'writeFileSync', 11, 'Writes run prompt, environment, scope, schema, and launch evidence into a run folder.'),
+  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/worker-order.mjs', 'writeFileSync', 1, 'Writes worker.json inside a run folder.'),
+  outside('src/home/lib/runner/worker.mjs', 'writeFileSync', 7, 'Writes worker git snapshots and 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.'),
+].map((entry) => Object.freeze(entry)));