@lyupro/codex-bridge 0.6.8 → 0.6.10

package/cli/model-set.mjs

@@ -5,6 +5,7 @@ import { ROLES, validateRunConfig } from '../src/home/lib/config-validate.mjs';
 import { readJsonFileSync } from '../src/home/lib/json-file.mjs';
 import { editRunConfig } from '../src/home/lib/config-edit.mjs';
 import { fetchCatalogue, parseCatalogue } from './model-catalogue.mjs';
+import { withCommandHelp } from './command-help.mjs';
 
 const failure = (exitCode, message) => ({ exitCode, output: `codex-bridge model: ${message}` });
 const refusal = (message) => Object.assign(new Error(message), { exitCode: 2 });
@@ -17,14 +18,14 @@ function parseChanges(args) {
     let value = argument;
     if (argument.startsWith('-')) {
       if (argument !== '--model' && argument !== '--effort') {
-        throw new Error(`unexpected argument "${argument}".`);
+        throw new Error(withCommandHelp('model set', `unexpected argument "${argument}".`));
       }
       field = argument.slice(2);
       value = args[++index];
       if (value === undefined || value.startsWith('-')) throw new Error(`missing value for ${argument}.`);
     } else {
       field = ['model', 'effort'].find((key) => changes[key] === undefined);
-      if (!field) throw new Error(`unexpected argument "${argument}".`);
+      if (!field) throw new Error(withCommandHelp('model set', `unexpected argument "${argument}".`));
     }
     if (changes[field] !== undefined) throw new Error(`${field} was supplied more than once.`);
     if (!value || /\s/.test(value)) {
@@ -65,7 +66,7 @@ export async function editModelProfile(action, argv, options) {
   }
   let changes;
   try {
-    if (action === 'unset' && args.length) throw new Error(`unexpected argument "${args[0]}".`);
+    if (action === 'unset' && args.length) throw new Error(withCommandHelp('model unset', `unexpected argument "${args[0]}".`));
     if (action === 'set') changes = parseChanges(args);
   } catch (error) {
     return failure(2, error.message);

package/cli/model-speed.mjs

@@ -5,12 +5,19 @@ import { ROLES, validateRunConfig } from '../src/home/lib/config-validate.mjs';
 import { editRunConfig } from '../src/home/lib/config-edit.mjs';
 import { fetchCatalogue, parseCatalogue } from './model-catalogue.mjs';
 import { describe, readProfiles } from './model-set.mjs';
+import { withCommandHelp } from './command-help.mjs';
 
 const failure = (exitCode, message) => ({ exitCode, output: `codex-bridge model: ${message}` });
 const refusal = (message) => Object.assign(new Error(message), { exitCode: 2 });
+const unexpected = (argument) => {
+  const result = failure(2, `unexpected argument "${argument}".`);
+  return { ...result, output: withCommandHelp('model speed', result.output) };
+};
 
 export async function editModelSpeed(argv, options) {
   const [role, speed, confirmation, ...extra] = argv;
+  const dashArgument = argv.find((arg) => typeof arg === 'string' && arg.startsWith('-'));
+  if (dashArgument !== undefined) return unexpected(dashArgument);
   if (!ROLES.includes(role)) {
     return failure(2, `${role ? `unknown role "${role}"` : 'role is required'}. Allowed roles: ${ROLES.join(', ')}.`);
   }
@@ -18,9 +25,9 @@ export async function editModelSpeed(argv, options) {
     return failure(2, 'speed requires a tier identifier: a non-empty single word with no whitespace, or unset.');
   }
   if (confirmation !== undefined && (speed === 'unset' || confirmation !== 'confirm')) {
-    return failure(2, `unexpected argument "${confirmation}".`);
+    return unexpected(confirmation);
   }
-  if (extra.length) return failure(2, `unexpected argument "${extra[0]}".`);
+  if (extra.length) return unexpected(extra[0]);
 
   try {
     const configPath = path.resolve(options.configPath ?? CONFIG_PATH);

package/cli/model.mjs

@@ -8,6 +8,7 @@ import { editModelProfile } from './model-set.mjs';
 import { editModelSpeed } from './model-speed.mjs';
 import { readCodexUserTier } from './codex-user-config.mjs';
 import { renderTable } from './table.mjs';
+import { withCommandHelp } from './command-help.mjs';
 
 const PROFILE_COLUMNS = ['role', 'model', 'effort', 'speed', 'source']
   .map((key) => ({ key, header: key, fixed: true }));
@@ -43,10 +44,10 @@ export async function model(argv = [], options = {}) {
   }
   if (action === 'speed') return editModelSpeed(optionArgs, options);
   if (action && action !== 'list') {
-    return { exitCode: 2, output: `codex-bridge model: unknown action "${action}". Use model, model list, model set, model unset or model speed.` };
+    return { exitCode: 2, output: withCommandHelp('model', `codex-bridge model: unknown action "${action}". Use model, model list, model set, model unset or model speed.`) };
   }
   if (optionArgs.length) {
-    return { exitCode: 2, output: `codex-bridge model: unexpected argument "${optionArgs[0]}".` };
+    return { exitCode: 2, output: withCommandHelp('model', `codex-bridge model: unexpected argument "${optionArgs[0]}".`) };
   }
 
   try {
@@ -75,7 +76,8 @@ export async function model(argv = [], options = {}) {
     return {
       exitCode: 0,
       output: `${renderTable(PROFILE_COLUMNS, rows, options.terminalWidth)}\n\nConfig file: ${configPath}\n`
-        + 'Machine-wide: shared by every project on this machine, not per-project.',
+        + 'Machine-wide: shared by every project on this machine, not per-project.\n'
+        + 'Set: codex-bridge model set <role> <model> [effort] · catalogue: codex-bridge model list',
     };
   } catch (error) {
     const subject = action === 'list' ? 'live catalogue unavailable; refusing to list models' : 'cannot read profile';

package/cli/owner-record.mjs

@@ -0,0 +1,40 @@
+/**
+ * Builds one owner's installation-record row from what is on disk after its files and hooks were written.
+ * Install and the owner sync (Plan_65 D7) both advance a row; two copies of this construction would let
+ * a synced owner carry fingerprints or `createdGroup` flags that its own install would never write.
+ */
+import { fileFingerprint } from './manifest.mjs';
+import { INSTALL_METHOD_COPY, INSTALL_METHOD_KEY } from './install-record.mjs';
+
+export async function ownerRecord({ plan, rule, targets, hookResults, prior, currentPackage }) {
+  const fingerprints = {};
+  for (const item of plan) {
+    fingerprints[item.root] ??= {};
+    fingerprints[item.root][item.relativeToRoot] = await fileFingerprint(item.target);
+  }
+  const hooks = targets.map(({ definition, relative, registration }, index) => {
+    const recorded = prior?.hooks?.find((hook) => hook.event === definition.event
+      && hook.root === 'brand' && hook.path === relative);
+    // A group we created stays ours after a later run merely joins it; losing the flag would make
+    // uninstall leave behind an empty group that only this package ever put there.
+    const createdGroup = hookResults[index].createdGroup || recorded?.createdGroup === true;
+    const command = registration.command;
+    return {
+      event: definition.event,
+      root: 'brand',
+      path: relative,
+      command,
+      form: command.startsWith('codex-bridge hook ') ? 'short' : 'path',
+      ...(createdGroup ? { createdGroup: true } : {}),
+    };
+  });
+  return {
+    ...currentPackage,
+    installedAt: new Date().toISOString(),
+    [INSTALL_METHOD_KEY]: INSTALL_METHOD_COPY,
+    files: plan.map((item) => ({ root: item.root, path: item.relativeToRoot })),
+    fingerprints,
+    rules: { path: rule.target, fingerprint: await fileFingerprint(rule.target) },
+    hooks,
+  };
+}

package/cli/owner-sync-apply.mjs

@@ -0,0 +1,108 @@
+/**
+ * Applies other owners' host updates under the initiator's lifecycle lock (Plan_65 D7, advice A6).
+ * Replacing the shared image must bring eligible owners' files and hooks along, without extending
+ * the initiator's force to their edits, permissions, seeds, or Codex rules registry. An owner row
+ * advances only after its whole host update verifies; failures must not stop the remaining owners.
+ * In-sync rows are stamped with the image fingerprint too (D11): clones of one version ship different
+ * images (A6), so only the stamp tells doctor which image a host was last verified against.
+ */
+import fs from 'node:fs/promises';
+import { normalizeRepoPath } from '../src/home/lib/runner/project-dir.mjs';
+import { buildInstallPlan, packageInfo, rulesPlan } from './manifest.mjs';
+import { copyPlannedFile, planHomeWriter } from './copy.mjs';
+import { readInstallRecordFile, writeInstallRecord } from './install-record.mjs';
+import { imageFingerprint, ownerView } from './install-owners.mjs';
+import { ownerRecord } from './owner-record.mjs';
+import { ownerHost, ownerSyncLines, planOwner, planOwnerSync } from './owner-sync.mjs';
+import { mergeHook } from './settings-merge.mjs';
+
+async function applyOwner(owner, initiator, { packageRoot, env }) {
+  const host = ownerHost(owner, initiator);
+  // D7: a root lost after planning must not be recreated by the copy or settings writers.
+  if (!(await fs.stat(host.root)).isDirectory()) throw new Error('owner root is not a directory');
+  const record = await readInstallRecordFile(host);
+  const prior = ownerView(record, host);
+  if (!prior) throw new Error('owner is not recorded');
+  const plan = await buildInstallPlan(host, packageRoot);
+  const { writer } = planHomeWriter(host.brandRoot, plan);
+  let files = 0;
+  for (const { item, state } of owner.files) {
+    if (state !== 'replace' && state !== 'create') continue;
+    await copyPlannedFile(item, host.brandRoot, { writer });
+    files += 1;
+  }
+  const hookResults = [];
+  let hooks = 0;
+  for (const { item, state } of owner.hooks) {
+    if (state === 'register') {
+      hookResults.push(await mergeHook(host.settingsPath, item.spec));
+      hooks += 1;
+    } else {
+      hookResults.push({ createdGroup: false });
+    }
+  }
+  const verified = await planOwner(record, record.owners[normalizeRepoPath(host.root)], initiator,
+    { packageRoot, env });
+  // A bare status word made the operator line read "Left <root> behind: conflict", naming no cause.
+  if (verified.status !== 'in-sync') throw new Error(`verification after the update found ${verified.status}`);
+  // D7: resolving an explicit root must not relabel a recorded user/project owner as host.
+  await writeInstallRecord({ ...host, scope: owner.scope }, await ownerRecord({
+    plan,
+    rule: rulesPlan(host, packageRoot),
+    targets: owner.hooks.map(({ item }) => item),
+    hookResults,
+    prior,
+    currentPackage: await packageInfo(packageRoot),
+  }), {});
+  return { root: owner.root, status: 'updated', files, hooks };
+}
+
+export async function applyOwnerSync(plan, initiator, { packageRoot, env } = {}) {
+  const record = await readInstallRecordFile(initiator);
+  const fingerprint = imageFingerprint(record.image);
+  const owners = [];
+  for (const owner of plan.owners) {
+    if (owner.status === 'in-sync'
+      // An image without fingerprints yields null; a row can then never carry a stamp to match.
+      && (record.owners[normalizeRepoPath(owner.root)]?.imageFingerprint ?? null) === fingerprint) {
+      owners.push({ root: owner.root, status: 'in-sync' });
+    } else if (owner.status !== 'eligible' && owner.status !== 'in-sync') {
+      owners.push(owner);
+    } else {
+      try {
+        const applied = await applyOwner(owner, initiator, { packageRoot, env });
+        owners.push(owner.status === 'in-sync' && applied.files === 0 && applied.hooks === 0
+          ? { root: owner.root, status: 'in-sync' } : applied);
+      } catch (error) {
+        owners.push({ root: owner.root, status: 'failed', reason: error.message });
+      }
+    }
+  }
+  return { owners, complete: owners.every(({ status }) => status === 'in-sync' || status === 'updated') };
+}
+
+/**
+ * One entrance for every command that replaced the image: install and update both call it, so neither
+ * can sync the other owners differently. A dry run only plans; it never counts as incomplete.
+ */
+export async function syncOtherOwners(initiator, { packageRoot, env, dryRun = false } = {}) {
+  const record = await readInstallRecordFile(initiator);
+  if (record?.format !== 2) return { complete: true, lines: [] };
+  const plan = await planOwnerSync(record, initiator, { packageRoot, env });
+  if (dryRun) return { complete: true, lines: ownerSyncLines(plan) };
+  // Plan_65 D7: the initiator's force never authorizes another owner's edits.
+  const result = await applyOwnerSync(plan, initiator, { packageRoot, env });
+  return { complete: result.complete, lines: ownerApplyLines(result) };
+}
+
+export function ownerApplyLines(result) {
+  return result.owners.flatMap((owner) => {
+    if (owner.status === 'updated') {
+      return [`Updated ${owner.files} file(s) and ${owner.hooks} hook(s) of ${owner.root}.`];
+    }
+    if (owner.status === 'failed') {
+      return [`Left ${owner.root} behind: ${owner.reason}; run codex-bridge update --host "${owner.root}".`];
+    }
+    return ownerSyncLines({ owners: [owner] });
+  });
+}

package/cli/owner-sync.mjs

@@ -0,0 +1,115 @@
+/**
+ * Plans other owners' host updates without writes or locks (Plan_65 D7, advice A6).
+ * Replacing the shared image leaves their agents, commands, and guards behind. Only an owner's
+ * recorded, unedited files may catch up; the initiator's force never authorizes another owner's
+ * conflicts, permissions, seeds, or unrelated settings. B13e2 applies and verifies this plan.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeRepoPath } from '../src/home/lib/runner/project-dir.mjs';
+import { resolveHost } from './hosts.mjs';
+import { buildInstallPlan, fileFingerprint } from './manifest.mjs';
+import { targetMatches } from './copy.mjs';
+import { fingerprintFor, recordFileKey } from './install-record.mjs';
+import { ownerView, validateFormat2 } from './install-owners.mjs';
+import { hookTargets } from './hook-targets.mjs';
+import { inspectHook } from './settings-merge.mjs';
+
+async function fileState(item, host, view) {
+  let target;
+  try {
+    target = await fs.lstat(item.target);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  // D7: lstat must precede content reads, including for dangling links and Windows junctions.
+  if (target?.isSymbolicLink()) return { item, state: 'conflict', reason: 'link' };
+  if (!target) {
+    const recorded = view.files.some((file) => recordFileKey(file) === recordFileKey(item));
+    return recorded
+      ? { item, state: 'conflict', reason: 'missing' }
+      : { item, state: 'create' };
+  }
+  if (target.isFile()) {
+    if (await targetMatches(item, host.brandRoot)) return { item, state: 'current' };
+    const recorded = fingerprintFor(view, item);
+    if (recorded !== undefined && await fileFingerprint(item.target) === recorded) {
+      return { item, state: 'replace' };
+    }
+  }
+  return { item, state: 'conflict', reason: 'changed' };
+}
+
+/** The owner's host seen from the initiator: same home and Codex home, the owner's own root and scope. */
+export function ownerHost(owner, initiator) {
+  return resolveHost({
+    host: owner.root,
+    scope: owner.scope,
+    brandRoot: initiator.brandRoot,
+    // A resolved host has no codexHome field; it keeps the Codex home only as `<home>/rules`.
+    codexHome: path.dirname(initiator.codexRulesDir),
+  });
+}
+
+export async function planOwner(record2, owner, initiator, { packageRoot, env }) {
+  const entry = { root: owner.root, scope: owner.scope, version: owner.version, files: [], hooks: [] };
+  const host = ownerHost(owner, initiator);
+  try {
+    if (!(await fs.stat(host.root)).isDirectory()) {
+      return { ...entry, status: 'unreachable', reason: 'ENOTDIR' };
+    }
+    await fs.readdir(host.root);
+  } catch (error) {
+    return { ...entry, status: 'unreachable', reason: error.code === 'ENOENT' ? 'absent' : error.code };
+  }
+
+  const view = ownerView(record2, host);
+  const items = (await buildInstallPlan(host, packageRoot)).filter((item) => item.root === 'claude');
+  try {
+    for (const item of items) entry.files.push(await fileState(item, host, view));
+  } catch (error) {
+    return { ...entry, status: 'unreachable', reason: error.code ?? error.message };
+  }
+  const targets = hookTargets(host, env);
+  try {
+    for (const item of targets) {
+      const inspected = await inspectHook(host.settingsPath, item.spec);
+      entry.hooks.push({ item, state: inspected.current ? 'current' : 'register' });
+    }
+  } catch (error) {
+    return { ...entry, status: 'unreachable', reason: `settings unreadable: ${error.message}` };
+  }
+  const conflict = entry.files.some(({ state }) => state === 'conflict');
+  const pending = entry.files.some(({ state }) => state === 'replace' || state === 'create')
+    || entry.hooks.some(({ state }) => state === 'register');
+  return { ...entry, status: conflict ? 'conflict' : pending ? 'eligible' : 'in-sync' };
+}
+
+export async function planOwnerSync(record2, initiator, { packageRoot, env } = {}) {
+  validateFormat2(record2);
+  const key = normalizeRepoPath(initiator.root);
+  const others = Object.values(record2.owners)
+    .filter((owner) => normalizeRepoPath(owner.root) !== key)
+    .sort((a, b) => a.root.localeCompare(b.root));
+  const owners = [];
+  for (const owner of others) owners.push(await planOwner(record2, owner, initiator, { packageRoot, env }));
+  return { owners };
+}
+
+export function ownerSyncLines(plan) {
+  const lines = [];
+  for (const owner of plan.owners) {
+    if (owner.status === 'eligible') {
+      const files = owner.files.filter(({ state }) => state === 'replace' || state === 'create').length;
+      const hooks = owner.hooks.filter(({ state }) => state === 'register').length;
+      lines.push(`Would update ${files} file(s) and ${hooks} hook(s) of ${owner.root}.`);
+    } else if (owner.status === 'conflict') {
+      const conflicts = owner.files.filter(({ state }) => state === 'conflict')
+        .map(({ item, reason }) => `${item.relativeToRoot} (${reason})`).join(', ');
+      lines.push(`Left ${owner.root} behind: ${conflicts}; run codex-bridge update --host "${owner.root}" after resolving it.`);
+    } else if (owner.status === 'unreachable') {
+      lines.push(`Left ${owner.root} behind: ${owner.reason}; run codex-bridge update --host "${owner.root}" when it is available.`);
+    }
+  }
+  return lines;
+}

package/cli/projects.mjs

@@ -1,4 +1,5 @@
 /** Implements the projects command. */
+import { withCommandHelp } from './command-help.mjs';
 import { listProjectRuns, listProjects } from './runs-inventory.mjs';
 import { renderTable } from './table.mjs';
 import { allLiveRuns } from '../src/home/hooks/live-runs.mjs';
@@ -69,11 +70,13 @@ function parseArgs(args) {
       json = true;
       continue;
     }
-    if (arg.startsWith('-')) return { error: `codex-bridge projects: unknown option "${arg}"` };
+    if (arg.startsWith('-')) {
+      return { error: withCommandHelp('projects', `codex-bridge projects: unknown option "${arg}"`) };
+    }
     positional.push(arg);
   }
   if (positional.length > 1) {
-    return { error: 'codex-bridge projects accepts at most one project name.' };
+    return { error: withCommandHelp('projects', 'codex-bridge projects accepts at most one project name.') };
   }
   return { json, projectName: positional[0] || null };
 }

package/cli/prune-args.mjs

@@ -1,5 +1,6 @@
 /** Parses prune scopes and refuses combinations that could widen destructive reach. */
 import path from 'node:path';
+import { withCommandHelp } from './command-help.mjs';
 
 const DURATION = /^(\d+)([dh])$/;
 const DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
@@ -8,6 +9,10 @@ function error(message) {
   return { error: `codex-bridge prune: ${message}` };
 }
 
+function usageError(message) {
+  return { error: withCommandHelp('prune', error(message).error) };
+}
+
 function validCalendarDate(value) {
   const match = DATE.exec(value);
   if (!match) return false;
@@ -87,18 +92,18 @@ export function parsePruneArgs(argv = []) {
       olderThanExplicit = true;
       continue;
     }
-    if (arg.startsWith('-')) return error(`unknown option "${arg}"`);
+    if (arg.startsWith('-')) return usageError(`unknown option "${arg}"`);
     positional.push(arg);
   }
 
   if (allProjects && purge) {
-    return error('--all-projects cannot be combined with --purge; all-projects is gentle only');
+    return usageError('--all-projects cannot be combined with --purge; all-projects is gentle only');
   }
   if (allProjects && positional.length) {
-    return error('--all-projects does not accept a project or run name');
+    return usageError('--all-projects does not accept a project or run name');
   }
   if (!allProjects && (positional.length < 1 || positional.length > 2)) {
-    return error('expected <project>, optional <run>, or --all-projects');
+    return usageError('expected <project>, optional <run>, or --all-projects');
   }
 
   const projectName = positional[0] || null;

package/cli/prune.mjs

@@ -1,11 +1,10 @@
 /** Confirms, executes, and reports the destructive actions in a prune plan. */
 import fs from 'node:fs';
-import path from 'node:path';
-import readline from 'node:readline/promises';
-import { normalizePath } from '../src/home/hooks/live-runs.mjs';
+import { inspectSegments } from './link-segments.mjs';
 import { parsePruneArgs } from './prune-args.mjs';
 import { prunePlan } from './prune-plan.mjs';
 import { recursiveSize } from './runs-inventory.mjs';
+import { askYesNo, isInteractive } from './terminal-question.mjs';
 
 function formatBytes(bytes) {
   if (!Number.isFinite(bytes)) return 'unknown';
@@ -102,64 +101,6 @@ function result(exitCode, text) {
   return { exitCode, output: text };
 }
 
-// One spelling only. A guard that answers to several option names is a guard with several ways
-// to be switched off by accident.
-function tty(options) {
-  if (options.isTTY !== undefined) return Boolean(options.isTTY);
-  return Boolean((options.stdin || process.stdin).isTTY);
-}
-
-async function defaultPrompt(question, options = {}) {
-  const input = options.stdin || process.stdin;
-  const outputStream = options.promptOutput || process.stderr;
-  const interfaceHandle = readline.createInterface({ input, output: outputStream });
-  try {
-    const answer = await interfaceHandle.question(`${question} [y/N] `);
-    return /^(y|yes)$/i.test(answer.trim());
-  } finally {
-    interfaceHandle.close();
-  }
-}
-
-function accepted(answer) {
-  return answer === true || /^(y|yes)$/i.test(String(answer ?? '').trim());
-}
-
-// The package compares paths through one function, and this guard is the last thing standing
-// between a bug and rm -r. Raw string comparison is case-sensitive: a runs root spelled
-// `C:\Users\...` against a target resolved as `c:\users\...` would put every target "outside the
-// root", and the deletion would fail with a reason that names the wrong problem.
-function targetInsideRoot(target, root) {
-  const normalizedRoot = normalizePath(root);
-  const normalizedTarget = normalizePath(target);
-  if (!normalizedRoot || !normalizedTarget) return false;
-  return normalizedTarget !== normalizedRoot && normalizedTarget.startsWith(`${normalizedRoot}/`);
-}
-
-/**
- * Refuses a target reached through a link. Independent review found that lexical containment alone
- * is satisfiable: replace `<root>/<project>` with a junction to an external directory and a target
- * that still spells out as inside the root deletes what is outside it. The package deliberately
- * does not resolve paths (`realpath` returns `\\?\` and UNC forms on Windows and creates a new
- * class of mismatch), so the check is the cheap half instead: every segment from the root down to
- * the target must be a real directory, verified with lstat right before deletion.
- */
-function linkedSegment(target, root) {
-  const normalizedRoot = normalizePath(root);
-  let current = path.resolve(target);
-  while (normalizePath(current) !== normalizedRoot) {
-    try {
-      if (fs.lstatSync(current).isSymbolicLink()) return current;
-    } catch {
-      return null; // Already gone: rmSync will report it honestly.
-    }
-    const parent = path.dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-  return null;
-}
-
 function currentTargetBytes(target, strategy) {
   if (strategy === 'purge') {
     // The inventory's recursive measurement is the same accounting used by projects and keeps
@@ -174,18 +115,21 @@ function currentTargetBytes(target, strategy) {
 }
 
 async function confirmAll(plan, args, options) {
-  const prompt = options.prompt || defaultPrompt;
   for (const action of plan.actions) {
     const question = action.strategy === 'purge'
       ? `Delete folder ${action.path}?`
       : `Delete archived transport from ${action.project}/${action.run}?\n  ${action.targets.join('\n  ')}`;
-    let answer;
+    let outcome;
     try {
-      answer = await prompt(question, action, options);
+      const prompt = options.prompt;
+      outcome = await askYesNo(question, {
+        ...options,
+        prompt: prompt ? (text) => prompt(text, action, options) : undefined,
+      });
     } catch (err) {
       return { error: `codex-bridge prune: confirmation failed: ${err.message}` };
     }
-    if (!accepted(answer)) return { declined: true };
+    if (outcome !== 'yes') return { declined: true };
   }
   return { declined: false };
 }
@@ -196,21 +140,30 @@ function bytesAfterRemoval(values) {
     : null;
 }
 
+/**
+ * Uses the shared top-down check before deletion: the old leaf-up walk inspected descendants under
+ * a link, and its catch treated every lstat error as a clear path.
+ */
 async function execute(plan, options) {
   const removed = [];
   const sizes = [];
   const failed = [];
   for (const action of plan.actions) {
     for (const target of action.targets) {
-      if (!targetInsideRoot(target, plan.root)) {
+      const inspection = inspectSegments(target, plan.root);
+      if (inspection.kind === 'outside') {
         failed.push({ target, error: 'target is outside the configured runs root' });
         continue;
       }
-      const linked = linkedSegment(target, plan.root);
-      if (linked) {
-        failed.push({ target, error: `refusing to delete through a link: ${linked}` });
+      if (inspection.kind === 'link') {
+        failed.push({ target, error: `refusing to delete through a link: ${inspection.at}` });
         continue;
       }
+      if (inspection.kind === 'error') {
+        failed.push({ target, error: `cannot inspect ${inspection.at} (${inspection.code}); nothing deleted` });
+        continue;
+      }
+      // `missing` goes on: rmSync reports the vanished target honestly, as it always did.
       const bytes = currentTargetBytes(target, action.strategy);
       try {
         fs.rmSync(target, { recursive: action.strategy === 'purge', force: false });
@@ -253,7 +206,7 @@ export async function prune(argv = [], options = {}) {
     const payload = { status: 'completed', ...basePayload(plan), removed: [], bytesFreed: 0, failed: [] };
     return result(0, output(payload, args.json));
   }
-  if (!tty(options)) {
+  if (!isInteractive(options)) {
     const message = 'No TTY: refusing deletion because deletion is an operator action; no files were changed.';
     const payload = { status: 'refused', ...basePayload(plan), error: message, removed: [], bytesFreed: 0 };
     return result(1, output(payload, args.json));
@@ -274,5 +227,3 @@ export async function prune(argv = [], options = {}) {
     ? output(executed.payload, true)
     : reportLines(executed.payload, executed.payload.status));
 }
-
-export { defaultPrompt };