@lyupro/codex-bridge 0.6.8 → 0.6.10

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

@@ -0,0 +1,43 @@
+/**
+ * Admits a worker and records its identity under its order claim before any paid work starts.
+ * Plan_60 D4/D4c, A4 r4: a launcher killed after spawn frees the claim before recording the
+ * detached worker, so a second launcher could abandon its run and start another paid run.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { readJsonFileSync } from '../json-file.mjs';
+import { writeStatus } from '../meta/run-state.mjs';
+import { acquireOrderClaim } from './order-claim.mjs';
+
+export async function admitWorker({ runDir, orderId, timing, platform, createServer }) {
+  const claim = await acquireOrderClaim({
+    projectRunsRoot: path.dirname(runDir),
+    orderId,
+    role: 'worker',
+    ...(timing !== undefined ? { timing } : {}),
+    ...(platform !== undefined ? { platform } : {}),
+    ...(createServer !== undefined ? { createServer } : {}),
+  });
+  try {
+    if (claim.busy) return { admitted: false, reason: 'claim-timeout', holder: claim.holder };
+    let status = null;
+    try {
+      status = readJsonFileSync(path.join(runDir, 'status.json'));
+    } catch {
+      // Plan_60 A4 r4: an unreadable run cannot authorize paid work after a launcher dies.
+    }
+    if (status?.state !== 'running' || fs.existsSync(path.join(runDir, 'meta.json'))) {
+      return { admitted: false, reason: 'closed', state: status?.state ?? null };
+    }
+    // The launcher cannot know this detached process's clock origin; takeover must record the
+    // worker's own identity before it starts producing the run's artifacts.
+    writeStatus(runDir, {
+      pid: process.pid,
+      runner_pid: process.pid,
+      process_started_at: performance.timeOrigin,
+    });
+    return { admitted: true };
+  } finally {
+    await claim.release?.();
+  }
+}

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

@@ -3,7 +3,7 @@
  *
  * It takes its whole order from worker.json, written by launcher.mjs into the run folder —
  * after the split that file is the only connection between the two halves. Read here:
- * `repo`, `agent`, `args`, `is_git_repo`, `budget_minutes`. Written there: those five plus
+ * `repo`, `agent`, `args`, `is_git_repo`, `budget_minutes`, `order_id`. Written there: those six plus
  * `phase`, `slug`, `launcher_pid` and `scope_new`, which nothing here needs but a run folder read back
  * months later does. The launcher must write the selected phase's budget into worker.json before
  * spawning this half, so the worker never re-reads config.json and one run cannot acquire two
@@ -13,11 +13,14 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { readJsonFileSync } from '../json-file.mjs';
-import { collect, exitCodeFor, AGENTS } from '../write-meta.mjs';
+import { collect, exitCodeFor, AGENTS, writeFailure } from '../write-meta.mjs';
 import { writeStatus } from '../meta/run-state.mjs';
 import { setRun, emitReply } from './run-context.mjs';
-import { git, headSha, branchName, worktreeSnapshot, findFakeDone } from './git-state.mjs';
+import { writeBuildAfter } from './build-evidence.mjs';
 import { runCodex } from './codex-cmd.mjs';
+import { admitWorker } from './worker-admission.mjs';
+import { orderClaimHolderText } from './order-claim.mjs';
+import { EXIT } from './exit-codes.mjs';
 
 /**
  * Runs the order in runDir and answers into reply.txt, never to a console — nothing here
@@ -27,13 +30,18 @@ export async function worker(runDir) {
   const cfg = readJsonFileSync(path.join(runDir, 'worker.json'));
   const repoRoot = cfg.repo;
   setRun(runDir, cfg.agent);
-  // The launcher cannot know this detached process's clock origin; takeover must record the
-  // worker's own identity before it starts producing the run's artifacts.
-  writeStatus(runDir, {
-    pid: process.pid,
-    runner_pid: process.pid,
-    process_started_at: performance.timeOrigin,
-  });
+  const admission = await admitWorker({ runDir, orderId: cfg.order_id });
+  if (!admission.admitted) {
+    // Plan_60 A4 r4: a replacement launcher may have closed this run while the worker was starting.
+    if (admission.reason === 'claim-timeout') {
+      const { reply } = writeFailure(
+        runDir, cfg.agent, 'run worker was not admitted: the order claim stayed busy',
+        [`Claim held by ${orderClaimHolderText(admission.holder)}`, 'Codex was not started; quota was not spent'],
+      );
+      emitReply(reply);
+    }
+    process.exit(EXIT.FAIL);
+  }
 
   const run = await runCodex(
     cfg.args,
@@ -52,14 +60,7 @@ export async function worker(runDir) {
     stdio_drained: run.stdioDrained,
   });
 
-  if (cfg.agent === 'codex-build') {
-    fs.writeFileSync(path.join(runDir, 'head-after.txt'), `${cfg.is_git_repo ? headSha(repoRoot) : ''}\n`);
-    fs.writeFileSync(path.join(runDir, 'branch-after.txt'), `${cfg.is_git_repo ? branchName(repoRoot) : ''}\n`);
-    fs.writeFileSync(path.join(runDir, 'git-after.txt'), git(repoRoot, ['status', '--porcelain']).stdout || '');
-    fs.writeFileSync(path.join(runDir, 'state-after.txt'), `${worktreeSnapshot(repoRoot)}\n`);
-    fs.writeFileSync(path.join(runDir, 'diff.stat'), git(repoRoot, ['diff', '--stat']).stdout || '');
-    fs.writeFileSync(path.join(runDir, 'flags.txt'), findFakeDone(repoRoot));
-  }
+  if (cfg.agent === 'codex-build') writeBuildAfter({ runDir, repoRoot, isGitRepo: cfg.is_git_repo });
 
   // Human-readable report is carried inside the schema: a read-only scout cannot write
   // files itself, so the runner unpacks it.

package/src/home/lib/task-header.mjs

@@ -0,0 +1,127 @@
+/**
+ * Reads the orchestrator's metadata header at the top of a task file — the one place a grant or an
+ * advice line may stand.
+ *
+ * Plan_75 D5: on 2026-10-03 20:42 wrapped prose in a task file began a line with `continue:`, and
+ * the runner, which looked for grants on any line, refused the order over its own prose. Grants and
+ * advice had two parsers and the task hash a third rule; this module is the single reader, and a
+ * line below the header that still looks like real metadata is refused rather than silently obeyed
+ * or silently ignored.
+ */
+import path from 'node:path';
+import { splitGrantValue } from './required-inputs.mjs';
+
+const BARE_RUN = /^(?!\.{1,2}$)[A-Za-z0-9._-]+$/;
+const MISPLACED_GRANT = /^[A-Za-z0-9._-]+(?:$| — | - |:)/;
+
+function validateGrant(value) {
+  const grant = splitGrantValue(value);
+  return grant && BARE_RUN.test(grant.run)
+    ? null
+    : 'grant must name a bare run folder (not . or ..) and a non-placeholder reason';
+}
+
+function descriptor(label, validate, misplaced) {
+  const spellings = [`${label}[ \\t]*[:=]`];
+  for (const wrapper of ['\\*', '_', '`', '\\*\\*', '__']) {
+    spellings.push(`${wrapper}${label}${wrapper}[ \\t]*[:=]`);
+    spellings.push(`${wrapper}${label}[ \\t]*[:=]${wrapper}`);
+  }
+  return Object.freeze({
+    label,
+    validate,
+    misplaced,
+    shape: new RegExp(
+      // Plan_75 D5: try a wrapper before treating its first star as a list marker.
+      `^[ \\t]*(?:[-*][ \\t]*)??(?:${spellings.join('|')})[ \\t]*(.*?)[ \\t]*$`,
+      'i',
+    ),
+    repairHint: `move it into the header at the top of the file, spelled ${label}: <value>; `
+      + 'if it is an example, quote it with > or reword it inside a sentence',
+  });
+}
+
+// Plan_75 D5, 2026-10-03 20:42: one registry prevents wrapped task prose becoming a grant.
+const LABELS = Object.freeze([
+  // Plan_75 D5: empty advice closes the strict header but must still explain the missing value.
+  descriptor('advice', (value) => value.trim() && !/[\r\n]/.test(value)
+    ? null : 'advice value must be non-empty and single line',
+  (value) => !value || /^\S+$/.test(value)
+    || path.posix.isAbsolute(value) || path.win32.isAbsolute(value)),
+  descriptor('continue', validateGrant, (value) => MISPLACED_GRANT.test(value)),
+  descriptor('retry', validateGrant, (value) => MISPLACED_GRANT.test(value)),
+]);
+
+const HEADER_LINE = new RegExp(`^(${LABELS.map(({ label }) => label).join('|')}):[ \\t]*(\\S.*?)[ \\t]*$`);
+
+export function parseTaskHeader(text) {
+  const lines = text.replace(/^\uFEFF/, '').split(/\r\n|\n|\r/);
+  const fields = {};
+  const entries = [];
+  const problems = [];
+  let headerEnd = 0;
+
+  for (const line of lines) {
+    const match = line.match(HEADER_LINE);
+    if (!match) break;
+    const [, label, value] = match;
+    const entry = { label, value, lineNo: headerEnd + 1, line };
+    if (Object.hasOwn(fields, label)) {
+      problems.push({ lineNo: entry.lineNo, line, reason: `duplicate ${label} label` });
+    } else {
+      fields[label] = value;
+    }
+    entries.push(entry);
+    headerEnd++;
+  }
+
+  // Plan_75 D5: conflicting authorization is a label-presence error even if a value is invalid.
+  if (Object.hasOwn(fields, 'continue') && Object.hasOwn(fields, 'retry')) {
+    const conflict = entries.find(({ label }) => label === 'retry');
+    problems.push({
+      lineNo: conflict.lineNo,
+      line: conflict.line,
+      reason: 'continue and retry cannot both be present; keep exactly one grant label',
+    });
+  }
+
+  let grant = null;
+  let advice = null;
+  for (const entry of entries) {
+    const definition = LABELS.find(({ label }) => label === entry.label);
+    const reason = definition.validate(entry.value);
+    if (reason) {
+      problems.push({ lineNo: entry.lineNo, line: entry.line, reason: `${entry.label}: ${reason}` });
+    } else if (entry.value !== fields[entry.label]) {
+      continue;
+    } else if (entry.label === 'advice') {
+      advice ??= entry.value;
+    } else {
+      grant ??= { kind: entry.label, ...splitGrantValue(entry.value) };
+    }
+  }
+
+  // Plan_75 D5, 2026-10-03 20:42: fences are examples, not an escape from the misplaced guard.
+  for (let index = headerEnd; index < lines.length; index++) {
+    for (const definition of LABELS) {
+      const match = lines[index].match(definition.shape);
+      if (!match || !definition.misplaced(match[1])) continue;
+      const reason = match[1] ? `misplaced ${definition.label} metadata`
+        : `${definition.label} value must be non-empty and single line`;
+      problems.push({
+        lineNo: index + 1,
+        line: lines[index],
+        reason: `${reason}; ${definition.repairHint}`,
+      });
+    }
+  }
+
+  problems.sort((a, b) => a.lineNo - b.lineNo);
+  return { fields, grant, advice, body: lines.slice(headerEnd).join('\n'), problems };
+}
+
+export function taskHeaderRefusal(parsed) {
+  if (!parsed.problems.length) return null;
+  return parsed.problems.map(({ lineNo, line, reason }) => `line ${lineNo}: ${reason}: ${line}`)
+    .concat('The run folder was not created; quota was not spent.').join('\n');
+}

package/src/home/lib/write-meta.mjs

@@ -19,6 +19,7 @@
  * run-state.mjs keeps status.json honest, verdict.mjs decides OK/FAIL/LIMIT, reply.mjs
  * renders the lines. Importers name this file and nothing below it.
  */
+import { EXIT } from './runner/exit-codes.mjs';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -28,7 +29,7 @@ import { splitRunChanges } from './meta/environment.mjs';
 import { readEvents } from './meta/events.mjs';
 import { writeStatus } from './meta/run-state.mjs';
 import { resolveStatus } from './meta/verdict.mjs';
-import { AGENTS, failReply, limitReply, withProfileRow } from './meta/reply.mjs';
+import { AGENTS, failReply, limitReply, unavailableReply, withProfileRow } from './meta/reply.mjs';
 import { withLaunchRows } from './meta/launch-rows.mjs';
 
 function readRunnerVersion() {
@@ -164,7 +165,13 @@ export function collect(runDir, agent, exitCode) {
   const reply =
     withProfileRow(
       withLaunchRows(
-        status === 'OK' ? cfg.reply(ctx) : status === 'LIMIT' ? limitReply(ctx, meta) : failReply(ctx, meta),
+        status === 'OK'
+          ? cfg.reply(ctx)
+          : status === 'LIMIT'
+            ? limitReply(ctx, meta)
+            : status === 'UNAVAILABLE'
+              ? unavailableReply(ctx, meta)
+              : failReply(ctx, meta),
         runDir,
       ),
       meta,
@@ -173,8 +180,13 @@ export function collect(runDir, agent, exitCode) {
   return { meta, reply: reply.join('\n') };
 }
 
-/** Exit code mirrors the status so an orchestrator can branch without parsing text. */
-export const exitCodeFor = (status) => (status === 'OK' ? 0 : status === 'LIMIT' ? 3 : 1);
+/**
+ * Exit code numbers live in runner/exit-codes.mjs.
+ * USAGE is the launcher's argument error and never comes from here.
+ */
+export const exitCodeFor = (status) =>
+  (status === 'OK' ? EXIT.OK : status === 'LIMIT' ? EXIT.LIMIT :
+    status === 'UNAVAILABLE' ? EXIT.UNAVAILABLE : EXIT.FAIL);
 
 const invokedDirectly =
   process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url));
@@ -183,7 +195,7 @@ if (invokedDirectly) {
   const [runDir, agent, exitCode] = process.argv.slice(2);
   if (!runDir || !agent) {
     console.error('usage: node write-meta.mjs <runDir> <agent> <exitCode>');
-    process.exit(1);
+    process.exit(EXIT.FAIL);
   }
   const { meta, reply } = collect(runDir, agent, exitCode);
   console.log(reply);