@lyupro/codex-bridge 0.6.12 → 0.6.15

package/src/home/lib/runner/sandbox-diagnosis.mjs

@@ -0,0 +1,180 @@
+/** Owns read-only sandbox log evidence and repair formatting after 2026-10-10 TradeForge orders exposed only "setup refresh had errors". */
+import fs from 'node:fs';
+import path from 'node:path';
+
+const LOG_LIMIT = 64 * 1024;
+const SETUP_LIMIT = 8 * 1024;
+const ERROR_LINE = /setup error|setup refresh completed with errors|failed|error/i;
+// A successful refresh logs `errors=[]`; on the 2026-10-10 log five of them pushed the real error out.
+const CLEAN_REFRESH = /errors=\[\]/;
+const NO_REPAIR = 'No verified repair signature; inspect this log.';
+
+// Plan_78 A1: a repair needs all incident fragments on one fresh line, not a generic error word.
+const SIGNATURES = Object.freeze([
+  Object.freeze({
+    id: 'runtime-file-locked',
+    observed: Object.freeze({ date: '2026-10-10', codexCli: '0.162.1' }),
+    predicate: (line) => ['runtime read/execute validation failed',
+      'open ACL target for root-only update', 'os error 32'].every((fragment) => line.includes(fragment)),
+    summary: 'A file under the Codex runtimes folder is held open by another process, so sandbox setup cannot update its access rights (openai/codex #51634).',
+    repair: () => 'Find and close the process holding the file named in the line (on 2026-10-10, the Codex desktop app\'s computer-use helper), then rerun codex-bridge doctor; on Codex CLI 0.162.x the proven workaround is npm install -g @openai/codex@0.160.1.',
+  }),
+  Object.freeze({
+    id: 'deny-read-state-corrupt',
+    observed: Object.freeze({ date: '2026-09-16' }),
+    predicate: (line) => ['deny_read_acl_state.json', 'expected value at line 1 column 1']
+      .every((fragment) => line.includes(fragment)),
+    summary: 'The sandbox state file is empty or corrupt.',
+    repair: (codexHome) => `Back up and rename ${path.join(codexHome, '.sandbox', 'deny_read_acl_state.json')}, then rerun codex-bridge doctor; the helper recreates it.`,
+  }),
+]);
+
+function logPath(codexHome, date) {
+  const day = [date.getFullYear(), String(date.getMonth() + 1).padStart(2, '0'),
+    String(date.getDate()).padStart(2, '0')].join('-');
+  return path.join(codexHome, '.sandbox', `sandbox.${day}.log`);
+}
+
+function sandboxState(codexHome) {
+  try {
+    // Plan_78 B4a: a linked sandbox folder can redirect every evidence read outside CODEX_HOME.
+    return fs.lstatSync(path.join(codexHome, '.sandbox')).isDirectory() ? 'ready' : 'unknown';
+  } catch (error) {
+    return error.code === 'ENOENT' ? 'missing' : 'unknown';
+  }
+}
+
+function fileSize(file, folderState) {
+  if (folderState !== 'ready') return folderState === 'missing' ? 0 : null;
+  try {
+    const stat = fs.lstatSync(file);
+    return stat.isFile() ? stat.size : null;
+  } catch (error) {
+    // Only ENOENT proves absence; permission failures must not become a zero-byte baseline.
+    return error.code === 'ENOENT' ? 0 : null;
+  }
+}
+
+function readRange(file, start, limit, tail, folderState) {
+  if (folderState !== 'ready') return { state: folderState };
+  let fd;
+  try {
+    // Plan_78 B4a: opening a FIFO can block; links must not redirect sandbox evidence reads.
+    if (!fs.lstatSync(file).isFile()) return { state: 'unknown' };
+    fd = fs.openSync(file, 'r');
+    const stat = fs.fstatSync(fd);
+    if (!stat.isFile()) return { state: 'unknown' };
+    const offset = tail ? Math.max(start, stat.size - limit) : start;
+    const length = Math.min(limit, Math.max(0, stat.size - offset));
+    const buffer = Buffer.alloc(length);
+    let read = 0;
+    while (read < length) {
+      const count = fs.readSync(fd, buffer, read, length - read, offset + read);
+      if (count === 0) break;
+      read += count;
+    }
+    let text = buffer.subarray(0, read).toString('utf8');
+    // A capped tail can begin inside a signature; that fragment is not a complete error line.
+    if (tail && offset > start) {
+      const newline = text.indexOf('\n');
+      text = newline < 0 ? '' : text.slice(newline + 1);
+    }
+    return { state: 'read', text, bytes: read, size: stat.size, mtime: stat.mtimeMs };
+  } catch (error) {
+    return { state: error.code === 'ENOENT' ? 'missing' : 'unknown' };
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch { /* Evidence collection must not hide the dead-probe refusal. */ }
+    }
+  }
+}
+
+function readSetupError(file, folderState) {
+  const result = readRange(file, 0, SETUP_LIMIT, false, folderState);
+  return {
+    state: result.state,
+    text: result.state === 'read' ? result.text : result.state === 'missing' ? null
+      : `Unknown: unable to read ${file}.`,
+  };
+}
+
+export function snapshotSandboxLogs({ codexHome, now = new Date() }) {
+  const folderState = sandboxState(codexHome);
+  const previous = new Date(now);
+  // Local calendar arithmetic survives DST; subtracting 24 hours can choose the wrong day.
+  previous.setDate(previous.getDate() - 1);
+  return {
+    logs: [now, previous].map((date) => {
+      const file = logPath(codexHome, date);
+      return { path: file, size: fileSize(file, folderState) };
+    }),
+    setupError: readSetupError(path.join(codexHome, '.sandbox', 'setup_error.json'), folderState),
+  };
+}
+
+export function diagnoseSandbox({ codexHome, before, now = new Date() }) {
+  const folderState = sandboxState(codexHome);
+  const baselines = new Map(before.logs.map((log) => [log.path, log.size]));
+  const paths = [...new Set([...baselines.keys(), logPath(codexHome, now)])].sort();
+  const sources = [];
+  const appended = [];
+  const recent = [];
+  const unknown = [];
+  let attributed = false;
+  for (const file of paths) {
+    const baseline = baselines.has(file) ? baselines.get(file) : 0;
+    const result = readRange(file, baseline ?? 0, LOG_LIMIT, true, folderState);
+    if (result.state === 'missing') continue;
+    sources.push(file);
+    if (result.state === 'unknown') {
+      unknown.push(`Unknown: unable to read ${file}.`);
+      continue;
+    }
+    if (baseline !== null && result.bytes > 0) {
+      attributed = true;
+      appended.push(result.text);
+    }
+    recent.push({ file, mtime: result.mtime });
+    if (baseline === null) unknown.push(`Unknown: pre-probe size unavailable for ${file}.`);
+  }
+
+  let text = appended.join('\n');
+  if (!attributed && recent.length) {
+    const newest = recent.sort((a, b) => b.mtime - a.mtime || b.file.localeCompare(a.file))[0];
+    const fallback = readRange(newest.file, 0, LOG_LIMIT, true, folderState);
+    if (fallback.state === 'read') text = fallback.text;
+    else unknown.push(`Unknown: unable to read ${newest.file}.`);
+  }
+  const errors = text.split(/\r?\n/)
+    .filter((line) => ERROR_LINE.test(line) && !CLEAN_REFRESH.test(line)).slice(-5);
+  const match = attributed && [...errors].reverse()
+    .map((line) => SIGNATURES.find((signature) => signature.predicate(line))).find(Boolean);
+  const setupPath = path.join(codexHome, '.sandbox', 'setup_error.json');
+  const setup = readSetupError(setupPath, folderState);
+  if (setup.state !== 'missing') sources.push(setupPath);
+  return {
+    codexHome, sources, attributed,
+    lines: [...errors, ...unknown].map((line) => line.slice(0, 400)),
+    setupError: {
+      text: setup.text,
+      changed: setup.state === 'unknown' || before.setupError.state === 'unknown'
+        ? null : setup.text !== before.setupError.text,
+    },
+    signature: match ? { id: match.id, summary: match.summary, repair: match.repair(codexHome) } : null,
+  };
+}
+
+export function formatSandboxDiagnosis(diagnosis) {
+  return [
+    ...diagnosis.sources.map((source) => `Sandbox diagnosis source: ${source}`),
+    diagnosis.attributed ? 'Sandbox log lines attributed to this probe:'
+      : 'Recent sandbox log lines only; not attributed to this probe:',
+    ...diagnosis.lines.map((line) => `> ${line}`),
+    ...(diagnosis.setupError.text === null ? [] : [
+      `setup_error.json changed since snapshot: ${diagnosis.setupError.changed === null
+        ? 'unknown' : diagnosis.setupError.changed ? 'yes' : 'no'}`,
+      ...diagnosis.setupError.text.split(/\r?\n/).map((line) => `> ${line}`),
+    ]),
+    ...(diagnosis.signature ? [diagnosis.signature.summary, diagnosis.signature.repair] : [NO_REPAIR]),
+  ];
+}

package/src/home/lib/runner/sandbox-probe.mjs

@@ -3,6 +3,8 @@ import { performance } from 'node:perf_hooks';
 import { sandboxModeFor } from './codex-args.mjs';
 import { codexSpawnSpec, spawnCaptured } from './codex-cmd.mjs';
 import { platformSandboxArgs } from './sandbox-flags.mjs';
+import { resolveCodexHome } from '../codex-home.mjs';
+import { snapshotSandboxLogs, diagnoseSandbox, formatSandboxDiagnosis } from './sandbox-diagnosis.mjs';
 
 export const SANDBOX_PROBE_MARKER = 'codex-bridge-sandbox-ok';
 // Plan_57 D12/D19: a platform is judged only after both outcomes were seen live. Linux joined on
@@ -37,13 +39,37 @@ function inconclusiveReason(result, form) {
 
 export async function probeSandbox({
   agent, repo, platform = process.platform, run = spawnCaptured, timeoutMs = 30_000,
+  codexHome = resolveCodexHome(), clock = () => new Date(),
 }) {
   if (!PROBED_PLATFORMS.has(platform)) return { outcome: 'skipped' };
   const sandbox = sandboxModeFor(agent);
   if (typeof repo !== 'string' || !repo) throw new Error('sandbox probe requires a repository path');
   const echo = echoArgs(platform);
   const attempts = [];
-  const finish = (outcome, reason) => ({ outcome, reason, attempts });
+  // The 2026-10-10 TradeForge refusals showed only "setup refresh had errors"; capture the
+  // baseline before any attempt so old log errors cannot prescribe a repair for this probe.
+  let before = null;
+  try {
+    before = snapshotSandboxLogs({ codexHome, now: clock() });
+  } catch {
+    // Same rule as the diagnosis below: a log that cannot be read never stops the probe.
+  }
+  const finish = (outcome, reason) => {
+    const result = { outcome, reason, attempts };
+    if (outcome === 'dead') {
+      if (before === null) {
+        result.diagnosis = null;
+        return result;
+      }
+      // D2: logs, like stderr, are operator evidence, never input to the verdict.
+      try {
+        result.diagnosis = diagnoseSandbox({ codexHome, before, now: clock() });
+      } catch {
+        result.diagnosis = null;
+      }
+    }
+    return result;
+  };
   const attempt = async (form, args) => {
     const spec = codexSpawnSpec(args, platform);
     const started = performance.now();
@@ -104,6 +130,8 @@ export function sandboxRefusal(result, platform = process.platform) {
     ...(platform === 'linux' ? [LINUX_REPAIR] : []),
     `Operator check (run from the repository directory): ${control}`,
     ...stderr,
+    ...(result.diagnosis && typeof result.diagnosis === 'object'
+      ? [formatSandboxDiagnosis(result.diagnosis).join('\n')] : []),
     'The run folder was not created; quota was not spent.',
   ].join('\n\n');
 }

package/src/home/lib/runner/task-input.mjs

@@ -4,11 +4,37 @@
  *
  * Plan_63 D1/D8: transport arguments carry no order fields; file and stdin share this boundary.
  */
+import fs from 'node:fs';
+import path from 'node:path';
 import { die, readTaskDocument } from './args.mjs';
 import { questionKindRefusal } from './question-kind.mjs';
 import { orderFromHeader, orderInputName, renderOrderProblems } from '../order-schema.mjs';
 import { orderOptions } from './order-options.mjs';
 
+/**
+ * OW-061: outside git the launcher keeps `repository:` as given and the project folder takes its
+ * last segment, so a dispatcher that folded its own instructions into the value left run folders
+ * named `Obsidian. Run the scope phase. Return ≤5 lines and the run folder path.` and
+ * `tradeforge.loc (do not cd into codex-runs).` — names with a trailing dot that Windows cannot
+ * open through an ordinary path. Only an existing absolute directory whose segments Windows keeps
+ * verbatim may name the repository.
+ */
+export function repositoryRefusal(value) {
+  if (!path.isAbsolute(value)) {
+    return `must be an absolute path to the repository; got ${JSON.stringify(value)}.`;
+  }
+  const altered = value.split(/[\\/]/).find((segment) => /[. ]$/.test(segment) && segment !== '.' && segment !== '..');
+  if (altered !== undefined) {
+    return `has a path segment ending in a dot or a space (${JSON.stringify(altered)}), which Windows strips; ` +
+      `got ${JSON.stringify(value)}.`;
+  }
+  let isDirectory = false;
+  try {
+    isDirectory = fs.statSync(value).isDirectory();
+  } catch {}
+  return isDirectory ? null : `must name an existing directory; ${JSON.stringify(value)} is not one.`;
+}
+
 export function settleTaskInput(opts, { cwd = process.cwd() } = {}) {
   const { task, header, questions: fileQuestions, verify: fileVerify } = readTaskDocument(opts);
   const { order, problems } = orderFromHeader(opts.agent, header);
@@ -19,6 +45,10 @@ export function settleTaskInput(opts, { cwd = process.cwd() } = {}) {
   if (normalized.problems.length) {
     die(normalized.problems.map(({ label, reason }) => `${orderInputName(label)} ${reason}`).join('\n'));
   }
+  const repositoryReason = order.has('repository') ? repositoryRefusal(order.get('repository')) : null;
+  if (repositoryReason) {
+    die(`${orderInputName('repository')} ${repositoryReason}\nThe run folder was not created; quota was not spent.`);
+  }
   Object.assign(opts, normalized.options);
   opts.continue = Boolean(header.grant);
   opts.questions = fileQuestions.length ? fileQuestions : undefined;

package/src/home/lib/runner/worker.mjs

@@ -21,6 +21,7 @@ import { runCodex } from './codex-cmd.mjs';
 import { admitWorker } from './worker-admission.mjs';
 import { orderClaimHolderText } from './order-claim.mjs';
 import { EXIT } from './exit-codes.mjs';
+import { commitRunRecord } from './run-autocommit.mjs';
 
 /**
  * Runs the order in runDir and answers into reply.txt, never to a console — nothing here
@@ -39,6 +40,8 @@ export async function worker(runDir) {
         [`Claim held by ${orderClaimHolderText(admission.holder)}`, 'Codex was not started; quota was not spent'],
       );
       emitReply(reply);
+      // Plan_77 B6: publish the verdict before Git can wait on a lock or repository hook.
+      commitRunRecord({ runDir });
     }
     process.exit(EXIT.FAIL);
   }
@@ -78,5 +81,7 @@ export async function worker(runDir) {
   // seeing a reply is proof the verdict behind it is already on disk.
   const { meta, reply } = collect(runDir, cfg.agent, run.exit);
   emitReply(reply);
+  // Plan_77 B6: the launcher must receive its reply before any autocommit delay.
+  commitRunRecord({ runDir });
   process.exit(exitCodeFor(meta.status));
 }