@lyupro/codex-bridge 0.6.5 → 0.6.6

package/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.6] - 2026-09-23
+
+### Fixed
+
+- The advise phase is handed the risks it is judged on. `--continue` only grants permission to
+  continue: Codex starts a fresh session, and the advise prompt never listed the `predicted_risks` or
+  `missing_paths` of the scope run — it even forbade reading those paths — while the judge read them
+  from the scope run folder on its own. Every advise run therefore failed with
+  `risk_outcomes … count 0`. The launcher now takes one snapshot of the scope result into the advise
+  run's `advisor-task.json` (field `scope`) before the run folder exists; the prompt's
+  "Scope phase results" section is rendered from that snapshot and the judge reads only it. A scope
+  result that cannot be carried is refused before the run starts, spending no quota.
+- Repeating a `--continue` call returns the verdict of the run it started. The launcher starts a run
+  and returns, and only a repeated identical call attaches and returns the verdict — but a
+  continuation refused to attach, and the repeat was then rejected as reusing a spent grant. No
+  continuation of any agent could bring its verdict back to chat: a dispatcher reported `FAIL` while
+  its run was still working. A `--continue` call now first attaches to the run of the same order id
+  whose `continued_from` names the grant; with no such run a new pass starts as before. The grant stays
+  single-use.
+
 ## [0.6.5] - 2026-09-23
 
 ### Added

package/README.md

@@ -62,7 +62,7 @@ If a global install and a clone coexist, you have two package copies. `codex-bri
 - **Every run leaves an audit folder.** The verbatim task, scope, before/after git state, events, report, verdict, and reason remain together.
 - **Zero runtime dependencies and zero build steps.** The package is plain `.mjs` on the Node.js standard library.
 
-The current suite contains **1491 automated tests: 1490 passing and 1 skipped**.
+The current suite contains **1501 automated tests: 1500 passing and 1 skipped**.
 
 ## Verify
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lyupro/codex-bridge",
-  "version": "0.6.5",
-  "description": "Claude Code-to-Codex delegation with 6 guards, 1491 tests, zero runtime dependencies, and zero build steps.",
+  "version": "0.6.6",
+  "description": "Claude Code-to-Codex delegation with 6 guards, 1501 tests, zero runtime dependencies, and zero build steps.",
   "keywords": [
     "claude-code",
     "codex",

package/src/home/lib/meta/advice-status.mjs

@@ -32,14 +32,10 @@ export function adviceGap(runDir, result, eventData) {
 
   let scopeResult;
   if (phase === 'advise') {
-    if (typeof status.continued_from !== 'string' || !status.continued_from) {
-      reasons.push('status.json#continued_from for the phase-1 result is missing');
+    if (!task?.scope || !Array.isArray(task.scope.predicted_risks)) {
+      reasons.push('advisor-task.json#scope is missing the phase-1 predicted_risks');
     } else {
-      const scopeFile = path.join(path.dirname(runDir), status.continued_from, 'result.json');
-      scopeResult = readJson(scopeFile);
-      if (!scopeResult || typeof scopeResult !== 'object' || !Array.isArray(scopeResult.predicted_risks)) {
-        reasons.push('phase-1 result.json or its predicted_risks is missing');
-      }
+      scopeResult = { predicted_risks: task.scope.predicted_risks, missing_paths: task.scope.missing_paths };
     }
   }
   if (reasons.length) return contractReason(reasons);

package/src/home/lib/runner/advise-carry.mjs

@@ -0,0 +1,50 @@
+/** Owns the scope snapshot shared by advise readers because run 2026-09-23_141341_plan59-a1-stdin-hang left them with different inputs. */
+import path from 'node:path';
+import { readJsonFileSync } from '../json-file.mjs';
+import { parseAdvisorTask } from '../meta/advisor-task.mjs';
+import { die } from './args.mjs';
+
+export function advisorTaskArtifact({ taskText, phase, runsRoot, grantRun }) {
+  const task = parseAdvisorTask(taskText);
+  if (phase !== 'advise') return task;
+  if (typeof runsRoot !== 'string' || !runsRoot || typeof grantRun !== 'string' || !grantRun) {
+    throw new Error('Cannot carry advise scope result: runsRoot and grantRun are required.');
+  }
+  const scopeFile = path.join(runsRoot, grantRun, 'result.json');
+  let result;
+  try {
+    result = readJsonFileSync(scopeFile);
+  } catch (error) {
+    throw new Error(`Cannot read advise scope result at ${scopeFile}: ${error.message}`);
+  }
+  if (!result || typeof result !== 'object' || Array.isArray(result) ||
+      !Array.isArray(result.predicted_risks) || !Array.isArray(result.missing_paths) ||
+      result.predicted_risks.some((risk) => !risk || typeof risk.id !== 'string' || typeof risk.risk !== 'string') ||
+      result.missing_paths.some((entry) => typeof entry !== 'string')) {
+    throw new Error(`Malformed advise scope result at ${scopeFile}: expected predicted_risks and missing_paths arrays.`);
+  }
+  return { ...task, scope: { run: grantRun, predicted_risks: result.predicted_risks, missing_paths: result.missing_paths } };
+}
+
+// Called before makeRunDir: a scope result that cannot be carried is known before any quota is
+// spent, so it refuses like every other preflight gate instead of leaving a registered run behind.
+export function advisorTaskOrRefuse(input) {
+  try {
+    return advisorTaskArtifact(input);
+  } catch (error) {
+    return die(`${error.message} The run folder was not created; quota was not spent.`, 1);
+  }
+}
+
+export function adviseSection(artifact) {
+  if (!artifact?.scope) return '';
+  return [
+    '## Scope phase results',
+    '',
+    'Predicted risks:',
+    ...artifact.scope.predicted_risks.map(({ id, risk }) => `- ${id}: ${risk}`),
+    '',
+    'Paths you may additionally read and cite:',
+    ...artifact.scope.missing_paths.map((entry) => `- ${entry}`),
+  ].join('\n');
+}

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

@@ -5,6 +5,7 @@ import { readJsonFileSync } from '../json-file.mjs';
 import { workerMayBeAlive } from '../meta/run-liveness.mjs';
 import { processAlive } from '../process-identity.mjs';
 import { exitCodeFor, writeFailure, chainRuns } from '../write-meta.mjs';
+import { sameRun } from './continuation.mjs';
 import { conflictingOrderOwner, runsForOrder } from './order-owner.mjs';
 
 // The attach call is the only process that waits for a worker it did not spawn. Keeping that
@@ -93,18 +94,21 @@ export async function waitForReply(runDir, workerPid, status) {
  * path only covers a live run that has not recorded a verdict yet.
  *
  * A repeat that arrives after the verdict is answered from disk rather than refused, for the same
- * reason. `--continue` is the one case that must not attach: it is the orchestrator saying it read
- * the previous reply and wants another pass.
+ * reason. `--continue` may attach to a run created from its grant: the 2026-09-23 dispatcher
+ * incident showed that repeating the identical continuation command must return to that run.
  */
-export async function attach({ runsRoot, repo, slug, taskHash, orderId, chain, isContinue, noWait } = {}) {
-  if (isContinue) return null;
+export async function attach({ runsRoot, repo, slug, taskHash, orderId, chain, grantRun, isContinue, noWait } = {}) {
   const runs = chain || chainRuns(runsRoot, repo, slug, taskHash, orderId);
   const runRecords = runs
     .map((run) => ({ run, status: readJsonFile(path.join(runsRoot, run, 'status.json')) }))
     .filter(({ status }) => status);
   const sameOrder = runsForOrder(runRecords, orderId);
+  const attachRuns = isContinue
+    ? sameOrder.filter(({ status }) => grantRun && status.continued_from && sameRun(runsRoot, status.continued_from, grantRun))
+    : sameOrder;
+  if (isContinue && !attachRuns.length) return null;
 
-  const owner = conflictingOrderOwner(runRecords, orderId, taskHash);
+  const owner = isContinue ? null : conflictingOrderOwner(runRecords, orderId, taskHash);
   if (owner) {
     const ownerDir = path.join(runsRoot, owner.run);
     console.log(
@@ -120,8 +124,8 @@ export async function attach({ runsRoot, repo, slug, taskHash, orderId, chain, i
   // order, and while it was in flight a repeat used to be answered by the first run's reply.txt —
   // a stale verdict presented as this pass's answer. Found by the Plan_11-2 checklist, 2026-08-04.
   let candidate = null;
-  for (let i = sameOrder.length - 1; i >= 0; i -= 1) {
-    const entry = sameOrder[i];
+  for (let i = attachRuns.length - 1; i >= 0; i -= 1) {
+    const entry = attachRuns[i];
     const dir = path.join(runsRoot, entry.run);
     if (fs.existsSync(path.join(dir, 'reply.txt'))) {
       announceSavedReply(dir, orderId, entry.status.started_at);

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

@@ -9,7 +9,9 @@ import path from 'node:path';
 import { CONTINUATION_INPUT, parseContinuationGrant } from '../required-inputs.mjs';
 import { readJson } from '../write-meta.mjs';
 
-const sameRun = (runsRootPath, left, right) => {
+// One comparison of run names for the grant gate and for attach, so a repeat and a grant can never
+// disagree about whether two spellings name the same folder.
+export const sameRun = (runsRootPath, left, right) => {
   const a = path.resolve(runsRootPath, left);
   const b = path.resolve(runsRootPath, right);
   return process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;

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

@@ -27,7 +27,7 @@ import { parseArgs, die } from './args.mjs';
 import { settleTaskInput } from './task-input.mjs';
 import { parseContinuationGrant } from '../required-inputs.mjs';
 import { continuationRefusal } from './continuation.mjs';
-import { parseAdvisorTask } from '../meta/advisor-task.mjs';
+import { advisorTaskOrRefuse, adviseSection } from './advise-carry.mjs';
 import { schemaFor } from './schemas.mjs';
 import { INSTRUCTIONS } from './prompts.mjs';
 import { git, headSha, branchName, worktreeSnapshot, reviewScope } from './git-state.mjs';
@@ -146,12 +146,18 @@ export async function launcher(argv = process.argv.slice(2)) {
   const chain = chainRuns(projectRunsRoot, repoRoot, opts.slug, taskHash, opts.orderId);
   const startedChain = startedRuns(projectRunsRoot, chain);
   const continuationGrant = parseContinuationGrant(taskText);
+  const attachExistingRun = () => attach({
+    runsRoot: projectRunsRoot, repo: repoRoot, slug: opts.slug, taskHash, orderId: opts.orderId, chain,
+    grantRun: continuationGrant?.run, isContinue: opts.continue, noWait: opts.noWait,
+  });
+  let attachedExitCode = opts.continue ? await attachExistingRun() : null;
+  if (attachedExitCode !== null) return attachedExitCode;
 
   // The 2026-08-10_220535_plan25-2-install-table-two-roots incident exposed this ordering:
   // a grant without its flag must refuse before attach can print an older run's verdict.
   // markAbandoned() ran before this gate, so a dead runner already has meta.json with FAIL.
   // A run without a verdict can therefore only still be in flight; ordinary repeats go through
-  // attach(), while --continue must refuse to overlap that live work.
+  // attach() after this gate. Repeated --continue calls attach first because their grant is spent.
   const continuationError = continuationRefusal(
     projectRunsRoot,
     startedChain,
@@ -164,20 +170,13 @@ export async function launcher(argv = process.argv.slice(2)) {
   const scopeRun = continuationGrant &&
     scopeRunRefusal({ agent: opts.agent, phase: opts.phase, runsRoot: projectRunsRoot, grantRun: continuationGrant.run });
   if (scopeRun) die(scopeRun, 1);
+  // Plan_59 D22: the advise snapshot is read before the folder exists, so a broken scope result refuses for free.
+  const advisorTask = opts.agent === 'codex-advisor' ? advisorTaskOrRefuse({ taskText, phase: opts.phase, runsRoot: projectRunsRoot, grantRun: continuationGrant?.run }) : null;
 
   // One order produced six Codex runs on 2026-08-03 because the caller's time ceiling made it
   // restart the synchronous launcher. A live same-order run is now the repeat target: attach
   // before creating a folder, probing Codex or spending another token.
-  const attachedExitCode = await attach({
-    runsRoot: projectRunsRoot,
-    repo: repoRoot,
-    slug: opts.slug,
-    taskHash,
-    orderId: opts.orderId,
-    chain,
-    isContinue: opts.continue,
-    noWait: opts.noWait,
-  });
+  if (!opts.continue) attachedExitCode = await attachExistingRun();
   if (attachedExitCode !== null) return attachedExitCode;
 
   if (startedChain.length && !opts.continue) {
@@ -274,7 +273,7 @@ export async function launcher(argv = process.argv.slice(2)) {
   if (opts.agent === 'codex-scout') {
     fs.writeFileSync(path.join(runDir, 'questions.json'), `${JSON.stringify(questions, null, 2)}\n`);
   }
-  if (opts.agent === 'codex-advisor') fs.writeFileSync(path.join(runDir, 'advisor-task.json'), `${JSON.stringify(parseAdvisorTask(taskText), null, 2)}\n`);
+  if (advisorTask) fs.writeFileSync(path.join(runDir, 'advisor-task.json'), `${JSON.stringify(advisorTask, null, 2)}\n`);
 
   if (opts.agent === 'codex-build') {
     fs.writeFileSync(path.join(runDir, 'scope.txt'), `${opts.scopePatterns.join('\n')}\n`);
@@ -289,6 +288,8 @@ export async function launcher(argv = process.argv.slice(2)) {
   // and what may be edited. Both also go to disk as questions.json / scope.txt, so the verdict
   // is computed from the same list Codex was handed, not from a second reading of the wording.
   const sections = [`## Operator task (verbatim)\n\n${taskText}`];
+  const scopeResults = adviseSection(advisorTask);
+  if (scopeResults) sections.push(scopeResults);
   if (questions.length) {
     sections.push(
       [

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

@@ -16,7 +16,7 @@ const BODIES = {
     return `Judge a DESIGN before code exists.
 
 Rules for both phases:
-- Read ONLY the paths listed under \`## Paths\`, plus \`git log\` / \`git show\` on those paths.
+- Read ONLY the paths listed under \`## Paths\` and, in the advise phase, under \`## Scope phase results\`, plus \`git log\` / \`git show\` on those paths.
 - Write nothing. Do your own reading and checks; do not spawn or delegate to other agents.
 - Every claim about code must carry a \`path:line\` address inside those paths. Addresses are
   machine-checked for existence; do not invent addresses or treat an unchecked claim as evidence.
@@ -32,7 +32,7 @@ Scope phase:
   (facts accepted from the task without checking, never empty), together with predicted_risks.
 ` : `
 Advise phase:
-- Settle every predicted risk from the scope run in risk_outcomes: its risk_id, an outcome of
+- Settle every predicted risk listed under \`## Scope phase results\` in risk_outcomes: its risk_id, an outcome of
   confirmed or refuted, and an address supporting that outcome.
 - Give ONE recommendation by task option_id, or none-of-these with a described unlisted_option.
   Put every rejected task option in rejected with its cost; for none-of-these this means EVERY