@lyupro/codex-bridge 0.6.5 → 0.6.7

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/preflight.mjs

@@ -33,8 +33,10 @@ export function taskPreflight({ agent, taskText }) {
     }
     if (path.isAbsolute(advice)) {
       try {
-        if (fs.statSync(advice).isDirectory() &&
-            readJson(path.join(advice, 'meta.json'))?.agent === 'codex-advisor') {
+        // Plan_59 D26: only a judged advice authorizes a construction. On 2026-09-24 the gate took
+        // any codex-advisor folder, so a scope run or a FAIL advice would have passed as a second opinion.
+        const meta = fs.statSync(advice).isDirectory() ? readJson(path.join(advice, 'meta.json')) : null;
+        if (meta?.agent === 'codex-advisor' && meta.phase === 'advise' && meta.status === 'OK') {
           return { refusal: null, advice };
         }
       } catch {
@@ -43,7 +45,8 @@ export function taskPreflight({ agent, taskText }) {
     }
   }
   return freeRefusal('codex-build requires exactly one advice: line: mechanical | revert | docs-only | test-only ' +
-    'or an absolute path to an existing advisor run directory with meta.json agent codex-advisor. ' +
+    'or an absolute path to an existing advisor run directory whose meta.json says agent codex-advisor, ' +
+    'phase advise, status OK. ' +
     'An order that invents a construction needs a second opinion first; only work with no design choice may skip it.');
 }
 

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

@@ -16,10 +16,11 @@ 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.
+- Prose fields cite code as \`path:line\`; every \`evidence\` field is a list of
+  \`{file, line_start, line_end}\` objects, ONE location per object. Several places mean several
+  objects, never a list inside \`file\`. Locations are machine-checked for existence.
 - Do not guess which option the caller prefers: the task carries no preference on purpose.
 - Two failure modes are forbidden: agreeing without independent checks ("both options are good",
   "you know better"), and disagreeing to look independent. A disagreement without an address is
@@ -32,18 +33,18 @@ 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
-  confirmed or refuted, and an address supporting that outcome.
+- Settle every predicted risk listed under \`## Scope phase results\` in risk_outcomes with its
+  risk_id, an outcome of confirmed or refuted, a \`note\` explaining it, and evidence.
 - 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
   task option. Set unlisted_option to "none" when recommending a listed option.
 - Each field is a distinct lens: strongest_counterargument comes from a skeptic;
   pre_mortem comes from the executor who has only this advice and the repository. Give each
-  scenario an early_check of kind test | command | inspect with a target; inspect requires an address.
+  scenario an early_check of kind test | command | inspect with a target; inspect requires evidence.
 - question_defect comes from the requester who needs the problem solved, not an option picked.
-- Rate assumptions VERIFIED (requires an address) | REASONABLE | FRAGILE. Anything the requester
+- Rate assumptions VERIFIED (requires evidence) | REASONABLE | FRAGILE. Anything the requester
   could refute with knowledge you lack belongs in open_questions, not why.
-- independent_checks lists what you verified yourself, with addresses. Ground why in those checks
+- independent_checks lists what you verified yourself, with evidence. Ground why in those checks
   and state confidence honestly.
 `}`;
   },

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

@@ -150,6 +150,30 @@ const REVIEW_SCHEMA = {
   },
 };
 
+// The 2026-09-24_094352_plan62-g1-dispatcher-gate run folded 3-5 citations into one advisor
+// address; like the 2026-07-31 build changes[].file precedent, constrain a single location here.
+export const EVIDENCE_LOCATION = {
+  type: 'object',
+  additionalProperties: false,
+  required: ['file', 'line_start', 'line_end'],
+  properties: {
+    file: {
+      type: 'string',
+      minLength: 1,
+      pattern: '^[^:;,*?{}\\r\\n]+$',
+      description: 'Exactly one repository-root-relative path. Spaces are allowed; lists, globs, drive letters and line suffixes are not — use a separate location object for each place.',
+    },
+    line_start: { type: 'integer', minimum: 1 },
+    line_end: { type: 'integer', minimum: 1 },
+  },
+};
+
+const EVIDENCE_LIST = (minItems) => ({
+  type: 'array',
+  ...(minItems === undefined ? {} : { minItems }),
+  items: EVIDENCE_LOCATION,
+});
+
 /** Plan_59: execution schemas stay static; schemaFor selects the advisor contract by phase. */
 export const SCHEMAS = {
   'codex-scout': SCOUT_SCHEMA,
@@ -220,11 +244,11 @@ export const PHASE_SCHEMAS = {
           items: {
             type: 'object',
             additionalProperties: false,
-            required: ['claim', 'rating', 'address'],
+            required: ['claim', 'rating', 'evidence'],
             properties: {
               claim: { type: 'string' },
               rating: { type: 'string', enum: ['VERIFIED', 'REASONABLE', 'FRAGILE'] },
-              address: { type: 'string' },
+              evidence: EVIDENCE_LIST(),
             },
           },
         },
@@ -233,11 +257,12 @@ export const PHASE_SCHEMAS = {
           items: {
             type: 'object',
             additionalProperties: false,
-            required: ['risk_id', 'outcome', 'address'],
+            required: ['risk_id', 'outcome', 'note', 'evidence'],
             properties: {
               risk_id: { type: 'string' },
               outcome: { type: 'string', enum: ['confirmed', 'refuted'] },
-              address: { type: 'string' },
+              note: { type: 'string' },
+              evidence: EVIDENCE_LIST(1),
             },
           },
         },
@@ -254,10 +279,11 @@ export const PHASE_SCHEMAS = {
               early_check: {
                 type: 'object',
                 additionalProperties: false,
-                required: ['kind', 'target'],
+                required: ['kind', 'target', 'evidence'],
                 properties: {
                   kind: { type: 'string', enum: ['test', 'command', 'inspect'] },
                   target: { type: 'string', minLength: 3 },
+                  evidence: EVIDENCE_LIST(),
                 },
               },
             },
@@ -271,8 +297,8 @@ export const PHASE_SCHEMAS = {
           items: {
             type: 'object',
             additionalProperties: false,
-            required: ['check', 'address'],
-            properties: { check: { type: 'string' }, address: { type: 'string' } },
+            required: ['check', 'evidence'],
+            properties: { check: { type: 'string' }, evidence: EVIDENCE_LIST(1) },
           },
         },
       },