@lyupro/codex-bridge 0.1.3 → 0.2.0

package/cli/runs-inventory.mjs

@@ -0,0 +1,173 @@
+/** Reads run-store directories into inventory data. */
+import fs from 'node:fs';
+import path from 'node:path';
+import { liveRuns } from '../src/hooks/live-runs.mjs';
+import { runsRoot } from '../src/runner/runs-root.mjs';
+
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value);
+
+function readRecord(file) {
+  try {
+    const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    return record(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+function directoryEntries(dir) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory())
+      .sort((left, right) => left.name.localeCompare(right.name));
+  } catch {
+    return [];
+  }
+}
+
+function measure(target) {
+  let stat;
+  try {
+    stat = fs.lstatSync(target);
+  } catch {
+    return { bytes: null, complete: false };
+  }
+  if (!stat.isDirectory()) return { bytes: stat.isFile() ? stat.size : 0, complete: true };
+
+  let entries;
+  try {
+    entries = fs.readdirSync(target, { withFileTypes: true });
+  } catch {
+    return { bytes: null, complete: false };
+  }
+
+  let bytes = 0;
+  let complete = true;
+  for (const entry of entries) {
+    const child = measure(path.join(target, entry.name));
+    if (child.bytes !== null) bytes += child.bytes;
+    if (!child.complete) complete = false;
+  }
+  return { bytes: complete ? bytes : null, complete };
+}
+
+/** Measures every readable regular file beneath a path. */
+export function recursiveSize(target) {
+  return measure(target).bytes;
+}
+
+const normalizeRoot = (value) => typeof value === 'string' && value.trim() ? value : runsRoot();
+
+const text = (value) => typeof value === 'string' && value.trim() ? value.trim() : null;
+
+const number = (value) => typeof value === 'number' && Number.isFinite(value) ? value : null;
+
+function runTimestamp(name, meta, status) {
+  return text(meta?.finished_at)
+    || text(status?.finished_at)
+    || text(status?.started_at)
+    || /^\d{4}-\d{2}-\d{2}_\d{6}/.exec(name)?.[0]
+    || null;
+}
+
+function timestampOrder(value) {
+  const candidate = String(value).replace(
+    /^(\d{4}-\d{2}-\d{2})_(\d{2})(\d{2})(\d{2})$/,
+    '$1T$2:$3:$4',
+  );
+  const parsed = Date.parse(candidate);
+  return Number.isNaN(parsed) ? candidate : parsed;
+}
+
+function newer(left, right) {
+  if (!left) return right;
+  if (!right) return left;
+  const leftOrder = timestampOrder(left);
+  const rightOrder = timestampOrder(right);
+  if (typeof leftOrder === 'number' && typeof rightOrder === 'number') {
+    return rightOrder > leftOrder ? right : left;
+  }
+  if (typeof leftOrder === 'number') return left;
+  if (typeof rightOrder === 'number') return right;
+  return rightOrder > leftOrder ? right : left;
+}
+
+function pathKey(value) {
+  const resolved = path.resolve(value);
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function readRun(runDir, livePaths) {
+  // A damaged folder still gets its row. An inventory that hides what it cannot parse is at its
+  // least useful exactly when something is wrong, which is when the operator opens it.
+  const meta = readRecord(path.join(runDir, 'meta.json'));
+  const status = readRecord(path.join(runDir, 'status.json'));
+  const facts = meta || status;
+  const live = livePaths.has(pathKey(runDir));
+  return {
+    run: path.basename(runDir),
+    agent: text(facts?.agent),
+    verdict: live ? 'running' : text(meta ? meta.status : status?.state),
+    tokens: meta ? number(meta.tokens) : null,
+    size: recursiveSize(runDir),
+    timestamp: runTimestamp(path.basename(runDir), meta, status),
+    live,
+  };
+}
+
+function publicRun(run) {
+  return {
+    run: run.run,
+    agent: run.agent,
+    verdict: run.verdict,
+    tokens: run.tokens,
+    size: run.size,
+    // Liveness travels with the row because a caller must not re-derive it: an abandoned run also
+    // says `running` in its status.json, and only the pid probe tells the two apart.
+    live: run.live,
+  };
+}
+
+function buildProject(projectDir) {
+  const runDirs = directoryEntries(projectDir).map((entry) => path.join(projectDir, entry.name));
+  // live-runs owns PID and status interpretation after the 2026-08-05 live probe incident;
+  // this module only maps its result back to the corresponding inventory row.
+  const livePaths = new Set(liveRuns(projectDir).map(({ dir }) => pathKey(dir)));
+  const details = runDirs.map((runDir) => readRun(runDir, livePaths));
+  // Sum what is known instead of blanking the column. One archived run without accounting used to
+  // erase the total of every run beside it, which reads as "spent nothing" — the opposite of true.
+  const counted = details.filter((run) => run.tokens !== null);
+  const latest = details.reduce((current, run) => newer(current, run.timestamp), null);
+  return {
+    summary: {
+      project: path.basename(projectDir),
+      runs: details.length,
+      size: recursiveSize(projectDir),
+      totalTokens: counted.length ? counted.reduce((sum, run) => sum + run.tokens, 0) : null,
+      liveNow: details.filter((run) => run.live).length,
+      lastRun: latest,
+    },
+    details,
+  };
+}
+
+function projectDirectory(root, name) {
+  return directoryEntries(root)
+    .find((entry) => entry.name === name)
+    ? path.join(root, name)
+    : null;
+}
+
+/** 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);
+}
+
+/** Lists one detail row per run directory in a named project, or null when there is no such project. */
+export function listProjectRuns(runsRootPath = runsRoot(), projectName) {
+  const root = normalizeRoot(runsRootPath);
+  const projectDir = projectDirectory(root, projectName);
+  if (!projectDir) return null;
+  return buildProject(projectDir).details.map(publicRun);
+}

package/cli/settings-merge.mjs

@@ -57,13 +57,24 @@ function groupHooks(group) {
   return Array.isArray(group?.hooks) ? group.hooks : [];
 }
 
+const hasOwnCommand = (group, command) =>
+  groupHooks(group).some((hook) => hook?.type === 'command' && hook.command === command);
+
+/**
+ * Presence is decided by the command, not by the matcher it currently sits under.
+ *
+ * The matcher is generated from the tool list in hook-definitions.mjs, so it changes whenever a
+ * host spelling is added — `Agent` became `Agent|Task` in one release, and the write-tool matcher
+ * will grow the same way. A host installed under the old matcher would then be invisible to the
+ * new lookup: update would register a duplicate and uninstall would leave a hook pointing at a
+ * deleted file. The command is this package's own absolute path, so it identifies our entry
+ * wherever the group ended up.
+ */
 export async function inspectHook(settingsPath, specOrPath) {
   const state = await readSettings(settingsPath);
   const spec = normalizeSpec(specOrPath);
   const present = groups(state.settings, spec.event)
-    .filter((group) => group?.matcher === spec.matcher)
-    .some((group) => groupHooks(group)
-      .some((hook) => hook?.type === 'command' && hook.command === spec.command));
+    .some((group) => hasOwnCommand(group, spec.command));
   return { ...state, ...spec, present };
 }
 
@@ -110,9 +121,12 @@ export async function removeHook(settingsPath, specOrPath, { createdGroup = fals
   if (!state.present) return { changed: false };
   const settings = structuredClone(state.settings);
   const eventGroups = groups(settings, spec.event);
+  // Removal follows the same rule as the lookup above: our command, whatever matcher it is
+  // filed under. A foreign hook is left alone because its command is not ours, not because it
+  // sits in another group.
   for (let index = eventGroups.length - 1; index >= 0; index -= 1) {
     const group = eventGroups[index];
-    if (group?.matcher !== spec.matcher) continue;
+    if (!hasOwnCommand(group, spec.command)) continue;
     if (!Array.isArray(group?.hooks)) continue;
     group.hooks = group.hooks.filter((hook) =>
       !(hook?.type === 'command' && hook.command === spec.command));

package/cli/stop.mjs

@@ -1,35 +1,16 @@
 /** Stops a live run and records the same abandoned FAIL artifacts as the normal sweep. */
-import fs from 'node:fs';
 import path from 'node:path';
 import { stopCodex } from '../src/runner/codex-cmd.mjs';
 import { git, worktreeSnapshot } from '../src/runner/git-state.mjs';
 import { markAbandoned, readJson } from '../src/write-meta.mjs';
-import { resolveProjectRunsDir } from '../src/runner/project-dir.mjs';
 import { runsRoot } from '../src/runner/runs-root.mjs';
+import { resolveRunFolder } from './run-lookup.mjs';
 
 const EXIT_POLL_MS = 25;
 const EXIT_WAIT_MS = 2000;
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
-function projectRoot(cwd) {
-  const result = git(cwd, ['rev-parse', '--show-toplevel']);
-  return result.status === 0 && result.stdout.trim() ? result.stdout.trim() : cwd;
-}
-
-function resolveRunFolder(run, cwd, runsRootPath) {
-  const value = String(run ?? '').trim();
-  if (!value || value === '.' || value === '..') {
-    throw new Error('stop requires a run folder (full path or bare folder name)');
-  }
-  if (path.isAbsolute(value)) return path.resolve(value);
-  if (path.dirname(value) !== '.') {
-    throw new Error('a bare run folder name or a full path is required');
-  }
-  const projectRuns = resolveProjectRunsDir(runsRootPath, projectRoot(cwd), { create: false });
-  return path.join(projectRuns.dir, value);
-}
-
 /** The stopped run's worktree as it stands now, or undefined when the repo is not a git one. */
 function treeOf(repo) {
   const root = String(repo ?? '').trim();
@@ -72,23 +53,9 @@ function result(exitCode, output) {
 }
 
 export async function stop({ run, cwd = process.cwd(), runsRootPath = runsRoot() } = {}) {
-  let runDir;
-  try {
-    runDir = resolveRunFolder(run, cwd, runsRootPath);
-  } catch (err) {
-    return result(1, `codex-bridge stop: ${err.message}`);
-  }
-
-  let isDirectory = false;
-  try {
-    isDirectory = fs.statSync(runDir).isDirectory();
-  } catch {}
-  if (!isDirectory) {
-    return result(
-      1,
-      `Run folder not found: ${runDir}. Pass a full path or a bare run folder name from the current project's runs directory.`,
-    );
-  }
+  const lookup = resolveRunFolder({ command: 'stop', run, cwd, runsRootPath });
+  if (lookup.error) return result(1, lookup.error);
+  const { runDir } = lookup;
 
   const status = readJson(path.join(runDir, 'status.json'));
   const meta = readJson(path.join(runDir, 'meta.json'));

package/cli/table.mjs

@@ -0,0 +1,110 @@
+/** Renders generic rows within terminal width. */
+
+const asText = (value) => {
+  if (value === null || value === undefined || value === '') return '-';
+  if (typeof value === 'object') {
+    try {
+      return JSON.stringify(value);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+};
+
+/** Counts printable code points without imposing a dependency on terminal libraries. */
+export const displayWidth = (value) => Array.from(String(value)).length;
+
+/** Keeps the right side of a name when a flexible column must shrink. */
+export function truncateStart(value, width) {
+  const text = String(value);
+  if (displayWidth(text) <= width) return text;
+  if (width <= 1) return '…';
+  return `…${Array.from(text).slice(-(width - 1)).join('')}`;
+}
+
+function fit(value, width, mode) {
+  if (displayWidth(value) <= width) return value;
+  if (mode === 'start') return truncateStart(value, width);
+  if (mode === 'end') return `${Array.from(value).slice(0, Math.max(0, width - 1)).join('')}…`;
+  return value;
+}
+
+function normalizeColumn(column) {
+  const kind = column.kind || 'text';
+  const fixed = column.fixed === true || kind === 'number' || kind === 'date';
+  return {
+    ...column,
+    key: String(column.key ?? column.label ?? column.header),
+    header: String(column.header ?? column.label ?? column.key),
+    kind,
+    align: column.align || (kind === 'number' ? 'right' : 'left'),
+    mode: column.truncate === undefined ? (fixed ? null : 'start') : column.truncate,
+  };
+}
+
+function optionsWidth(options) {
+  if (typeof options === 'number') return options;
+  const value = options?.width ?? options?.terminalWidth ?? process.stdout.columns;
+  return Number.isFinite(value) && value > 0 ? Math.floor(value) : 80;
+}
+
+function rowValue(row, column) {
+  return asText(typeof column.value === 'function' ? column.value(row) : row?.[column.key]);
+}
+
+function columnWidths(columns, rows, width) {
+  const values = columns.map((column) => [
+    column.header,
+    ...rows.map((row) => rowValue(row, column)),
+  ]);
+  const widths = values.map((items) => Math.max(...items.map(displayWidth), 1));
+  const gaps = Math.max(0, columns.length - 1);
+  let spare = width - gaps - widths.reduce((sum, item) => sum + item, 0);
+  if (spare >= 0) return widths;
+
+  const flexible = columns
+    .map((column, index) => ({ column, index }))
+    .filter(({ column }) => column.mode === 'start' || column.mode === 'end');
+  while (spare < 0) {
+    let changed = false;
+    for (const { column, index } of flexible) {
+      const minimum = Math.max(1, Number(column.minWidth) || 1);
+      if (widths[index] <= minimum) continue;
+      widths[index] -= 1;
+      spare += 1;
+      changed = true;
+      if (spare === 0) break;
+    }
+    if (!changed) break;
+  }
+  return widths;
+}
+
+function renderRow(row, columns, widths, header = false) {
+  return columns.map((column, index) => {
+    const value = header ? column.header : rowValue(row, column);
+    const rendered = fit(value, widths[index], header ? null : column.mode);
+    const padding = Math.max(0, widths[index] - displayWidth(rendered));
+    if (index === columns.length - 1) {
+      return column.align === 'right' ? `${' '.repeat(padding)}${rendered}` : rendered;
+    }
+    return column.align === 'right'
+      ? `${' '.repeat(padding)}${rendered}`
+      : `${rendered}${' '.repeat(padding)}`;
+  }).join(' ');
+}
+
+// Columns first, rows second, always. Sniffing which argument is which would let a caller with an
+// empty column list silently render the wrong shape instead of failing where the mistake is.
+/** Renders column descriptors plus object rows as a plain table. */
+export function renderTable(columns, rows, options = {}) {
+  const normalized = (columns || []).map(normalizeColumn);
+  if (!normalized.length) return '';
+  const values = Array.isArray(rows) ? rows : [];
+  const widths = columnWidths(normalized, values, optionsWidth(options));
+  return [
+    renderRow(null, normalized, widths, true),
+    ...values.map((row) => renderRow(row, normalized, widths)),
+  ].join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lyupro/codex-bridge",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Delegate implementation, reconnaissance and code review from Claude Code to the Codex CLI: dispatcher agents, a runner that survives a dropped call, and a verdict that checks the report against the worktree.",
   "keywords": [
     "claude-code",

package/src/agents/codex-build.md

@@ -32,12 +32,13 @@ job is to report the run status honestly, including failure.
   reuse an order id from another order — the runner chains runs by that label, and a made-up label
   is how a repeat run hides. If the orchestrator did not give a required input, do not guess: start
   the runner without its flag and return the runner's refusal exactly.
-- `continue` — pass it as the `--continue` flag only if the orchestrator gave it explicitly; do not
-  add or guess it yourself. The contract is the same kind as `--scope`: if this task (the same
-  `slug` and the same repository) already had a run, the runner will refuse to start without
-  `--continue` — before
-  starting Codex, so no quota is spent. The orchestrator decides on a repeat run; your job is to
-  pass the flag if given and return the runner's refusal exactly if it is absent.
+- `continue` — pass the `--continue` flag only when the orchestrator gave the matching `continue:`
+  grant explicitly; do not add or guess it yourself. A continuation is assigned by the
+  orchestrator, never chosen by you. After the verdict, return the exact attaching output and stop;
+  do not issue or invent another continuation. The contract is the same kind as `--scope`: if this
+  task (the same `slug` and the same repository) already had a run, the runner will refuse to start
+  without `--continue` — before starting Codex, so no quota is spent. If the orchestrator did not
+  grant a repeat, return the runner's refusal exactly.
 - Optional: `effort: <none|minimal|low|medium|high|xhigh|max>`, `slug:`, `verify: <verification
   command>` (for example `npm test`, `tsc --noEmit`).
 
@@ -57,7 +58,8 @@ Add `--effort "<value>"` only when the orchestrator named a depth, and only with
 decides, which is the intended default — a placeholder copied from this template is refused before
 Codex starts.
 
-If the orchestrator gave `continue`, add the bare `--continue` flag to the command, with no value.
+If the orchestrator gave the matching `continue:` grant, add the bare `--continue` flag to the
+command, with no value.
 No value
 is passed to it: the runner accepts only `1/true/yes/0/false/no`, while a placeholder string left in
 the
@@ -152,8 +154,8 @@ orchestrator.
 ## The script determines status, not you
 
 - `OK` — `result.json` is filled, the return code is zero, and the report matches the worktree.
-- `FAIL` — the result is empty, the return code is nonzero, `raw.log` is empty (the run was
-  abandoned at startup:
+- `FAIL` — the result is empty, the return code is nonzero, the run left no event and a silent
+  `stderr.log` (abandoned at startup:
   there was no Codex process), or **the wrong work was done**: no file in `changes[]` matches
   what actually changed between the worktree snapshots. The schema cannot catch this — a report
   about
@@ -202,7 +204,7 @@ OK — Added retry to the fetch helper and a timeout test
 Files: 2 changed · src/net/fetch.ts, src/net/fetch.test.ts
 Verification: npm test — pass
 Flags: none
-Report: ...\report.md · Log: ...\raw.log
+Report: ...\report.md · Log: codex-bridge read ...\2026-08-05_120000_slug
 ```
 
 Incorrect — "Codex failed, so I finished it myself," followed by a retelling of the diff.

package/src/agents/codex-review.md

@@ -31,6 +31,10 @@ opinion, not a verdict.
   another order — the runner chains runs by that label, and a made-up label is how a repeat run
   hides. If the orchestrator did not give a required input, do not guess — start the runner without
   its flag and return the runner's refusal verbatim.
+- `continue` is conditional — pass the `--continue` flag only when the orchestrator gave the
+  matching `continue:` grant explicitly; do not add or guess it yourself. A continuation is
+  assigned by the orchestrator, never chosen by you. After the verdict, return the exact attaching
+  output and stop; do not issue or invent another continuation.
 - Optional: review focus as text ("look for races and error handling"), `slug:`, `effort:
   <none|minimal|low|medium|high|xhigh|max>`.
 
@@ -54,6 +58,9 @@ line. To get the verdict, run the **identical command a second time** — same `
 `--slug`, same flags. That second call does not start a second run and costs no quota: it attaches
 to the run already in flight, prints `ATTACH=<path>`, blocks until the verdict exists and prints it.
 
+If the orchestrator gave the matching `continue:` grant, add the bare `--continue` flag to the
+command, with no value. If it was not given, the flag must not be present in the command at all.
+
 Background execution (`run_in_background`, `&`, `nohup`) is prohibited. Interruption is no longer a
 problem worth handling: if the attaching call is killed by a time ceiling, repeat it — every repeat
 attaches to the same run. A real run takes 20-25 minutes, which is normal, not a hang. Give the
@@ -122,9 +129,8 @@ and the wait can be repeated for free, so neither has any reason to restart anyt
 ## The script determines status, not you
 
 - `OK` — `review.json` is filled, and the return code is zero.
-- `FAIL` — the result is empty, the return code is nonzero, or `raw.log` is empty (the run was
-  abandoned
-  at startup: there was no Codex process).
+- `FAIL` — the result is empty, the return code is nonzero, or the run left no event and a
+  silent `stderr.log` (abandoned at startup: there was no Codex process).
 - `LIMIT` — the result is empty and the log signals a limit. The ChatGPT quota is exhausted, and the
   review was not
   completed; this is not a review failure and not a reason to restart.
@@ -156,7 +162,7 @@ ATTACH=<artifact root>\myproject\2026-07-30_1412_review-auth started=2026-07-30T
 OK — verdict needs-attention
 Findings: critical 0 · high 1 · medium 2 · low 3
 Top: high src/api/auth.ts:88 — The promise is not awaited, and the error is lost
-Report: ...\review.json · Log: ...\raw.log
+Report: ...\review.json · Log: codex-bridge read ...\2026-08-05_120000_slug
 ```
 
 Incorrect — "I analyzed the changes manually because Codex did not perform the review correctly,"
@@ -168,4 +174,4 @@ the status from the runner and stop.
 
 Incorrect — "The review started in the background; I will notify you when it finishes." There will
 be no notification: the agent
-terminates with the response, and an abandoned run leaves an empty `raw.log` — this is FAIL.
+terminates with the response, and an abandoned run leaves no event at all — this is FAIL.

package/src/agents/codex-scout.md

@@ -32,11 +32,12 @@ files, do not run grep, do not retell the report, and do not reason about the ta
   pass one `--question "<text>"` flag exactly as given. Never invent, merge, reword, or drop a
   sub-question. If the orchestrator did not give one, do not guess — start the runner without
   the flag and return its refusal verbatim.
-- `continue` — pass it as the `--continue` flag only if the orchestrator gave it explicitly; do not
-  add or guess it yourself. The contract is strict, like `--scope` in codex-build: if this task
-  (the same `slug` and the same repository) already had a run, the runner will refuse to start
-  without `--continue` — before starting Codex, so no quota is spent. The orchestrator decides on a
-  repeat run.
+- `continue` — pass the `--continue` flag only when the orchestrator gave the matching `continue:`
+  grant explicitly; do not add or guess it yourself. A continuation is assigned by the
+  orchestrator, never chosen by you. After the verdict, return the exact attaching output and stop;
+  do not issue or invent another continuation. The contract is strict, like `--scope` in
+  codex-build: if this task (the same `slug` and the same repository) already had a run, the runner
+  will refuse to start without `--continue` — before starting Codex, so no quota is spent.
 
 ## The only thing you do
 
@@ -57,7 +58,8 @@ Add `--effort "<value>"` only when the orchestrator named a depth, and only with
 decides, which is the intended default — a placeholder copied from this template is refused before
 Codex starts.
 
-If the orchestrator gave `continue`, add the bare `--continue` flag to the command, with no value.
+If the orchestrator gave the matching `continue:` grant, add the bare `--continue` flag to the
+command, with no value.
 No value
 is passed to it: the runner accepts only `1/true/yes/0/false/no`, while a placeholder string left in
 the
@@ -135,9 +137,8 @@ An empty `answer` is FAIL with a path to the log, not a reason to choose differe
 ## The script determines status, not you
 
 - `OK` — `result.json` is filled, and the return code is zero.
-- `FAIL` — the result is empty, the return code is nonzero, or `raw.log` is empty (the run was
-  abandoned
-  at startup: there was no Codex process).
+- `FAIL` — the result is empty, the return code is nonzero, or the run left no event and a
+  silent `stderr.log` (abandoned at startup: there was no Codex process).
 - `LIMIT` — the result is empty and the log signals a limit. The ChatGPT quota is exhausted, and the
   task was not
   completed; this is not a task failure and not a reason to restart.
@@ -170,7 +171,7 @@ ATTACH=<artifact root>\myproject\2026-07-30_1412_hooks started=2026-07-30T14:12:
 OK — The settings.json hook loads twice: from the plugin and the local config
 Key finding: duplicate loader (src/hooks/loader.ts:42)
 Unresolved: why the second load is needed
-Report: ...\report.md · Log: ...\raw.log
+Report: ...\report.md · Log: codex-bridge read ...\2026-08-05_120000_slug
 ```
 
 Incorrect — "Codex started in the background (PID recorded). Waiting for scouting to finish — it

package/src/commands/usage.md

@@ -16,9 +16,10 @@ The root of the run folders comes from `CODEX_RUNS_ROOT` when it is set, otherwi
 would stop seeing runs whenever the root is overridden.
 
 The source is the `meta.json` in each run folder: it holds the spending, the model and the sandbox.
-The `raw.log` itself is not kept in git and may be deleted, so parsing it is not allowed — the
-accounting has to survive a transcript cleanup. For older runs without `meta.json` there is a
-fallback log parser.
+Transport files are not kept in git and may be deleted, so parsing them is not allowed — the
+accounting has to survive a transcript cleanup. Runs from before `meta.json` existed keep a
+fallback parser for the `raw.log` those folders still contain; current runs no longer write that
+file, and their spending comes from the CLI's own `turn.completed` events.
 
 `codex exec review` prints no spending at all, so such runs land in the "unaccounted" line. Counting
 them as zero is not allowed — that would silently understate the total.

package/src/hook-definitions.mjs

@@ -19,7 +19,29 @@ export const SUBAGENT_TOOLS = Object.freeze(['Agent', 'Task']);
 /** A PreToolUse matcher is a regular expression over tool names, so alternation covers both. */
 export const SUBAGENT_TOOL_MATCHER = SUBAGENT_TOOLS.join('|');
 
+/**
+ * File-writing tools differ across Claude Code hosts just like subagent tools do. Register every
+ * host spelling here so the worktree lock receives the edit before it can enter a live runner's
+ * before/after snapshot; a list kept only in the hook would leave one host silently unlocked.
+ */
+export const WRITE_TOOLS = Object.freeze(['Write', 'Edit', 'MultiEdit', 'NotebookEdit']);
+
+/** A PreToolUse matcher is a regular expression over tool names, so alternation covers all four. */
+export const WRITE_TOOL_MATCHER = WRITE_TOOLS.join('|');
+
+/**
+ * Shell tools, listed here for the same reason as the two lists above: the prune guard must see the
+ * command whichever name a host gives its shell, and a name known only to the hook would leave that
+ * host's agents able to delete run artifacts.
+ */
+export const SHELL_TOOLS = Object.freeze(['Bash', 'PowerShell']);
+
+/** A PreToolUse matcher is a regular expression over tool names, so alternation covers both. */
+export const SHELL_TOOL_MATCHER = SHELL_TOOLS.join('|');
+
 export const HOOK_DEFINITIONS = Object.freeze([
   Object.freeze({ event: 'SubagentStop', matcher: '*', file: 'reply-guard.mjs' }),
   Object.freeze({ event: 'PreToolUse', matcher: SUBAGENT_TOOL_MATCHER, file: 'order-gate.mjs' }),
+  Object.freeze({ event: 'PreToolUse', matcher: WRITE_TOOL_MATCHER, file: 'worktree-lock.mjs' }),
+  Object.freeze({ event: 'PreToolUse', matcher: SHELL_TOOL_MATCHER, file: 'prune-guard.mjs' }),
 ]);