@lyupro/codex-bridge 0.6.15 → 0.6.16

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

@@ -17,6 +17,8 @@ import {
 } from '../write-meta.mjs';
 import { TASK_HASH_SCHEME } from '../meta/chain.mjs';
 import { orderInputName } from '../order-schema.mjs';
+import { orderLabelReason, orderRuleMessage } from '../order-rules.mjs';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 import { EXIT } from './exit-codes.mjs';
 import { passGate } from './pass-gate.mjs';
 import { setRun } from './run-context.mjs';
@@ -53,7 +55,10 @@ const RUNNER_ENTRY = fileURLToPath(new URL('../run-codex.mjs', import.meta.url))
 const stamp = () => {
   const d = new Date();
   const p = (n) => String(n).padStart(2, '0');
-  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}_${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+  return [
+    [d.getFullYear(), p(d.getMonth() + 1), p(d.getDate())].join('-'),
+    [p(d.getHours()), p(d.getMinutes()), p(d.getSeconds())].join(''),
+  ].join('_');
 };
 
 /**
@@ -69,7 +74,7 @@ export function makeRunDir(base) {
       return dir;
     } catch (err) {
       if (err.code !== 'EEXIST') throw err;
-      dir = `${base}-${n}`;
+      dir = [base, n].join('-');
     }
   }
 }
@@ -108,16 +113,14 @@ export async function launcher(argv = process.argv.slice(2)) {
   // lists are empty and the check passes. Only paths named in `scope new:` may be absent.
   const scopeRefusal = validateScope(repoRoot, opts.scopePatterns, opts.scopeNewPatterns);
   if (scopeRefusal) {
-    die(
-      `${orderInputName(scopeRefusal.label)} pattern ${JSON.stringify(scopeRefusal.pattern)} refused: ` +
-        `${scopeRefusal.reason}. ` +
-        `Action: ${scopeRefusal.action}. The run folder was not created; quota was not spent.`,
-    );
+    die([orderLabelReason(orderInputName(scopeRefusal.label), orderRuleMessage('scope-pattern-refusal', {
+      pattern: scopeRefusal.pattern, reason: scopeRefusal.reason, action: scopeRefusal.action,
+    })), orderDiagnosticMessage('run-not-created')].join(' '));
   }
   // Plan_77 D6: project-dir.mjs:84 recursively recreated a retired CODEX_RUNS_ROOT.
   // Refuse before that mkdir, using the same resolution that checked the advice header.
   const stale = staleOverrideRefusal(resolution);
-  if (stale) die(`${stale}\nThe run folder was not created; quota was not spent.`, EXIT.FAIL);
+  if (stale) die([stale, orderDiagnosticMessage('run-not-created')].join('\n'), EXIT.FAIL);
   const projectRunsRoot = resolveProjectRunsDir(resolution.root, repoRoot).dir;
   // Plan_60 D4c, 2026-09-24: two launchers of one order both billed. The claim comes before markAbandoned, or a
   // contender could close a run whose worker is admitting itself and start a second paid one.
@@ -134,10 +137,9 @@ export async function launcher(argv = process.argv.slice(2)) {
     if (isGitRepo) {
       const drift = abandonedBranchDrift(projectRunsRoot, repoRoot, branchName(repoRoot));
       if (drift) {
-        die(
-          `repository is detached after abandoned run ${drift.run}, which recorded branch ${drift.branch}. ` +
-            `Return with: git checkout ${drift.branch}. No run folder was created and no quota was spent.`,
-        );
+        die(orderDiagnosticMessage('repository-detached-after-abandoned-run', {
+          run: drift.run, branch: drift.branch,
+        }));
       }
     }
 
@@ -302,8 +304,8 @@ export async function launcher(argv = process.argv.slice(2)) {
       const { reply } = writeFailure(
         runDir,
         opts.agent,
-        `argument cannot be passed through cmd.exe (contains % or "): ${unsafe}`,
-        ['Codex was not started; quota was not spent'],
+        orderDiagnosticMessage('cmd-argument-transport', { argument: unsafe }),
+        [orderDiagnosticMessage('codex-not-started')],
         true,
       );
       console.log(reply);
@@ -335,9 +337,9 @@ export async function launcher(argv = process.argv.slice(2)) {
     const started = await new Promise((resolve) => {
       worker.once('spawn', () => resolve(true));
       worker.once('error', (err) => {
-        const { reply } = writeFailure(runDir, opts.agent, `run worker process failed to start: ${err.message}`, [
-          'Codex was not started; quota was not spent',
-        ], true);
+        const { reply } = writeFailure(runDir, opts.agent,
+          orderDiagnosticMessage('run-worker-start-failure', { message: err.message }),
+          [orderDiagnosticMessage('codex-not-started')], true);
         console.log(reply);
         resolve(false);
       });

package/src/home/lib/runner/order-claim.mjs

@@ -10,17 +10,19 @@ import {
 } from '../kernel-lock.mjs';
 import { parseJsonText } from '../json-file.mjs';
 import { chainRuns, readJson } from '../write-meta.mjs';
+import { orderRuleMessage } from '../order-rules.mjs';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 
 // Plan_60 D4/D4c: preparation takes seconds; expiry must refuse rather than permit double billing.
 export const ORDER_CLAIM_TIMING = Object.freeze({ waitMs: 60_000, retryMs: 100, answerTimeoutMs: 1_000 });
 
 export function orderClaimAddress(projectRunsRoot, orderId, platform = process.platform) {
   if (typeof orderId !== 'string' || orderId.length === 0) {
-    throw new TypeError('orderId must be a non-empty string');
+    throw new TypeError(orderDiagnosticMessage('order-claim-input-valid', { violation: 'order-id' }));
   }
   // Plan_60 A4 r5: owner matching is case-sensitive; retries must retain the exact order id.
   const digest = directoryDigest(projectRunsRoot, { suffix: orderId });
-  if (digest === null) throw new Error(`project runs folder does not exist: ${projectRunsRoot}`);
+  if (digest === null) throw new Error(orderDiagnosticMessage('project-runs-folder-required', { projectRunsRoot }));
   if (kernelLockStrategy(platform) === null) return null;
   return kernelLockAddress('order', digest, platform);
 }
@@ -30,7 +32,7 @@ export async function acquireOrderClaim({
   timing = ORDER_CLAIM_TIMING, createServer,
 }) {
   if (role !== 'launcher' && role !== 'worker') {
-    throw new TypeError('role must be launcher or worker');
+    throw new TypeError(orderDiagnosticMessage('order-claim-input-valid', { violation: 'role' }));
   }
   const address = orderClaimAddress(projectRunsRoot, orderId, platform);
   if (address === null) return { claimed: false, unsupported: true, release: async () => {} };
@@ -60,13 +62,16 @@ export function parseClaimHolder(line) {
 // Plan_60 D4/D4c: a holder answer diagnoses contention but cannot authorize anything.
 export function orderClaimHolderText(holder) {
   return holder === null
-    ? 'a process that did not answer (unverified)'
-    : `${holder.role} pid ${holder.pid} since ${holder.acquiredAt}`;
+    ? orderRuleMessage('order-launch-exclusive', { variant: 'holder-unverified' })
+    : orderRuleMessage('order-launch-exclusive', {
+      variant: 'holder', role: holder.role, pid: holder.pid, acquiredAt: holder.acquiredAt,
+    });
 }
 
 export function orderClaimBusyText(orderId, holder) {
-  return `order id "${orderId}" is being launched by ${orderClaimHolderText(holder)}; repeat the same command later — `
-    + 'it attaches to that run instead of starting another. The run folder was not created; quota was not spent.';
+  return [orderRuleMessage('order-launch-exclusive', {
+    variant: 'busy', orderId, holderDescription: orderClaimHolderText(holder),
+  }), orderDiagnosticMessage('run-not-created')].join(' ');
 }
 
 /**
@@ -79,6 +84,7 @@ export function unclaimedRaceRefusal({ projectRunsRoot, repoRoot, slug, taskHash
   const appeared = chain.find((run) => !before.has(run)
     && readJson(path.join(projectRunsRoot, run, 'status.json'))?.order_id === orderId);
   if (!appeared) return null;
-  return `another launch of order id "${orderId}" registered ${appeared} while this one was preparing; `
-    + 'repeat the same command — it attaches to that run. The run folder was not created; quota was not spent.';
+  return [orderRuleMessage('order-launch-exclusive', {
+    variant: 'race', orderId, run: appeared,
+  }), orderDiagnosticMessage('run-not-created')].join(' ');
 }

package/src/home/lib/runner/order-options.mjs

@@ -1,5 +1,6 @@
 /** Normalises one order's values into runner options, whatever channel carried them (Plan_63 D5). */
 import path from 'node:path';
+import { orderRuleMessage } from '../order-rules.mjs';
 
 export function orderOptions(agentType, order, { cwd = process.cwd() } = {}) {
   const options = { orderId: (order.get('order id') ?? '').trim() };
@@ -10,7 +11,7 @@ export function orderOptions(agentType, order, { cwd = process.cwd() } = {}) {
     options.effort = order.get('effort');
     if (!options.effort || /\s/.test(options.effort)) {
       problems.push({ label: 'effort',
-        reason: `must be a non-empty single word with no whitespace; got ${JSON.stringify(options.effort)}` });
+        reason: orderRuleMessage('effort-value', { value: options.effort }) });
     }
   }
   options.repo = path.resolve(order.get('repository') || cwd);
@@ -18,7 +19,7 @@ export function orderOptions(agentType, order, { cwd = process.cwd() } = {}) {
   // Plan_29 incident: a generic slug let an honest order inherit a days-old chain.
   if (!/[A-Za-z0-9]/.test(options.slug)) {
     problems.push({ label: order.has('slug') ? 'slug' : 'order id',
-      reason: `produces an unusable run folder name after sanitization: ${JSON.stringify(options.slug)} must contain a letter or digit.` });
+      reason: orderRuleMessage('run-slug', { value: options.slug }) });
   }
   options.changeset = order.get('changeset') || 'uncommitted';
   const declaredScopePatterns = (order.get('scope') || '').split(',').map((p) => p.trim()).filter(Boolean);

package/src/home/lib/runner/order-owner.mjs

@@ -1,6 +1,7 @@
 /** Keeps the runner and producer hook on one definition of which task owns an order id. */
 import { TASK_HASH_SCHEME } from '../meta/chain.mjs';
 import { orderInputName } from '../order-schema.mjs';
+import { orderRuleMessage } from '../order-rules.mjs';
 
 const byStartThenName = (left, right) => {
   const leftAt = String(left.status.started_at || '');
@@ -34,14 +35,15 @@ export function ownerPredatesHashScheme(owner) {
 }
 
 export function orderOwnerConflictText(owner, ownerDir, orderId) {
-  const identity = `Order id collision: ${JSON.stringify(String(orderId ?? ''))} already belongs to run folder ${ownerDir} ` +
-    `(slug ${owner.status.slug}, started_at ${owner.status.started_at})`;
   // Plan_75 D5, 2026-10-03: an old hash cannot prove that a repeated order is a different task.
   if (ownerPredatesHashScheme(owner)) {
-    return `${identity}, recorded before the task header (hash scheme ${TASK_HASH_SCHEME}), so its task cannot be compared. ` +
-      `Its answer is already on disk in that folder (codex-bridge read "${ownerDir}"). ` +
-      'Another pass of that order needs a continue:/retry: header line; a new task needs a new order id.';
+    return orderRuleMessage('order-id-owner', {
+      violation: 'predates-hash-scheme', orderId, ownerDir,
+      slug: owner.status.slug, startedAt: owner.status.started_at, hashScheme: TASK_HASH_SCHEME,
+    });
   }
-  return `${identity} with a different task. Use a new order id (${orderInputName('order id')}), or a continue:/retry: header line ` +
-    'if this is another pass of that order.';
+  return orderRuleMessage('order-id-owner', {
+    violation: 'different-task', orderId, ownerDir,
+    slug: owner.status.slug, startedAt: owner.status.started_at, labelName: orderInputName('order id'),
+  });
 }

package/src/home/lib/runner/pass-gate.mjs

@@ -15,6 +15,8 @@ import { continuationRefusal, retryRefusal, readyGrantLines } from './continuati
 import { advisorTaskOrRefuse } from './advise-carry.mjs';
 import { scopeRunRefusal } from './preflight.mjs';
 import { orderInputName } from '../order-schema.mjs';
+import { orderRuleMessage } from '../order-rules.mjs';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 
 export async function passGate({ opts, taskText, header, projectRunsRoot, repoRoot, beforeWait }) {
   // A second pass at the same task is a real need — after a timeout or a LIMIT the work has
@@ -30,10 +32,9 @@ export async function passGate({ opts, taskText, header, projectRunsRoot, repoRo
   const grant = header.grant;
   // OW-040, 2026-09-30: only a retry repeats failed scope without spending advise's continuation.
   if (opts.agent === 'codex-advisor' && opts.phase === 'scope' && opts.continue && grant?.kind !== 'retry') {
-    die(`codex-advisor ${orderInputName('phase')} scope refuses ${orderInputName('continue')}: a scope pass is never continued, and continuing one ` +
-      "spends the order's single continuation that its advise phase needs. Action: repeat the scope under a new order id " +
-      `without ${orderInputName('continue')} and without a continue: grant, then run advise as that order's continuation; a ` +
-      'scope run that failed is repeated with a `retry:` grant instead. The run folder was not created; quota was not spent.');
+    die([orderRuleMessage('advisor-scope-continuation', {
+      phaseLabel: orderInputName('phase'), continueLabel: orderInputName('continue'),
+    }), orderDiagnosticMessage('run-not-created')].join(' '));
   }
   let continuationGrant = grant?.kind === 'continue' ? grant : null;
   const retryOf = grant?.kind === 'retry' ? grant.run : null;
@@ -60,8 +61,9 @@ export async function passGate({ opts, taskText, header, projectRunsRoot, repoRo
     // A run written before phases existed has none; for every agent but the advisor that is 'default'.
     const phaseOf = (value) => String(value ?? '').trim() || 'default';
     if (namedStatus.agent !== opts.agent || phaseOf(namedStatus.phase) !== phaseOf(opts.phase)) {
-      die(`a retry repeats the named run's own agent and phase: ${namedStatus.agent}/${namedStatus.phase}. ` +
-        'The run folder was not created; quota was not spent.');
+      die([orderRuleMessage('retry-pass-identity', {
+        agent: namedStatus.agent, phase: namedStatus.phase,
+      }), orderDiagnosticMessage('run-not-created')].join(' '));
     }
     // Plan_75 D4, TradeForge capacity incident: retry advise against its original successful scope.
     continuationGrant = String(namedStatus.continued_from ?? '').trim()
@@ -93,18 +95,12 @@ export async function passGate({ opts, taskText, header, projectRunsRoot, repoRo
     const last = startedChain[startedChain.length - 1];
     const lastSlug = String(readJson(path.join(projectRunsRoot, last, 'status.json'))?.slug || '');
     const renamed = lastSlug && lastSlug.toLowerCase() !== String(opts.slug).toLowerCase();
-    die(
-      `${orderInputName('continue')} is required: ${
-        renamed
-          ? `this task already ran in this repository under the name “${lastSlug}”`
-          : `runs for task “${opts.slug}” already exist in this repository`
-      } (${startedChain.length}), latest: ${path.join(projectRunsRoot, last)}. ` +
-        'A repeat run is allowed, but the orchestrator decides, not the runner: it read the ' +
-        `previous response and knows whether work remains. Add ${orderInputName('continue')} if you are finishing ` +
-        `the same task; changing ${orderInputName('slug')} with the same task text does not stop it being a repeat. ` +
-        `${readyGrantLines(projectRunsRoot, startedChain)} ` +
-        'The run folder was not created; quota was not spent.',
-    );
+    die([orderRuleMessage('repeat-task-grant-required', {
+      violation: renamed ? 'renamed' : 'existing',
+      continueLabel: orderInputName('continue'), slugLabel: orderInputName('slug'),
+      slug: renamed ? lastSlug : opts.slug, count: startedChain.length, latest: path.join(projectRunsRoot, last),
+      hints: readyGrantLines(projectRunsRoot, startedChain),
+    }), orderDiagnosticMessage('run-not-created')].join(' '));
   }
 
   return { taskHash, chain, startedChain, continuationGrant, advisorTask, retryOf };

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

@@ -6,36 +6,34 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import { advisorTaskRefusal } from '../meta/advisor-task.mjs';
-import { unavailableRows } from '../meta/reply.mjs';
+import { unavailableRows } from '../meta/unavailable-rows.mjs';
 import { activeRunDetails, readJson } from '../write-meta.mjs';
 import { probeCodexAvailability } from './codex-availability.mjs';
 import { agentRole } from '../agents.mjs';
 import { die } from './args.mjs';
 import { orderInputName } from '../order-schema.mjs';
 import { retiredPathRefusal, runsRootResolution } from './runs-root.mjs';
+import { orderRuleMessage } from '../order-rules.mjs';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 
 /** Plan_60 D2: only conclusive evidence says UNAVAILABLE; a PATH miss is inconclusive (Plan_78 D5). */
 export async function codexAvailabilityRefusal({ probe = probeCodexAvailability } = {}) {
   const result = await probe();
   if (result.state === 'available') return null;
   const unavailable = result.state === 'logged-out';
-  const rows = unavailable ? unavailableRows(result.detail) : result.pathMiss === true ? [
-    `Codex CLI readiness unconfirmed: ${result.detail}`,
-    'Do not skip this bridge: check codex --version for up to about 2 minutes; when it answers, repeat the same order exactly once; if it does not answer, hand the order to the next executor and name that in the summary.',
-  ] : [
-    `Codex CLI unavailable: ${result.detail}`,
-    'Operator check: codex --version (and codex login if authorization is rejected)',
-  ];
+  const rows = unavailable ? unavailableRows(result.detail) : [orderDiagnosticMessage(
+    result.pathMiss === true ? 'codex-readiness-unconfirmed' : 'codex-unavailable', { detail: result.detail },
+  )];
   return {
     unavailable,
-    text: [...rows, 'The run folder was not created; quota was not spent.'].join('\n'),
+    text: [...rows, orderDiagnosticMessage('run-not-created')].join('\n'),
   };
 }
 
 /** Plan_59 D5/D6: settle design authority before any probe can spend quota. */
 export function taskPreflight({ agent, taskText, header, resolution = runsRootResolution() }) {
   const freeRefusal = (reason) => ({
-    refusal: `${reason}\nThe run folder was not created; quota was not spent.`,
+    refusal: [reason, orderDiagnosticMessage('run-not-created')].join('\n'),
   });
   if (agent === 'codex-advisor') {
     const reason = advisorTaskRefusal(taskText);
@@ -64,11 +62,7 @@ export function taskPreflight({ agent, taskText, header, resolution = runsRootRe
       }
     }
   }
-  return freeRefusal('codex-build requires the task file to start with the header line `advice: <value>`, where the ' +
-    'value is mechanical | revert | docs-only | test-only ' +
-    '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.');
+  return freeRefusal(orderRuleMessage('build-advice-required'));
 }
 
 /** Plan_59 D14: an advice pass may continue only a completed, successful advisor scope run. */
@@ -81,44 +75,40 @@ export function scopeRunRefusal({ agent, phase, runsRoot, grantRun }) {
     meta = null;
   }
   const failed = [
-    meta?.agent === 'codex-advisor' ? null : "agent must be 'codex-advisor'",
-    meta?.phase === 'scope' ? null : "phase must be 'scope'",
-    meta?.status === 'OK' ? null : "status must be 'OK'",
+    meta?.agent === 'codex-advisor' ? null : orderRuleMessage('advise-scope-run-required', { violation: 'agent' }),
+    meta?.phase === 'scope' ? null : orderRuleMessage('advise-scope-run-required', { violation: 'phase' }),
+    meta?.status === 'OK' ? null : orderRuleMessage('advise-scope-run-required', { violation: 'status' }),
   ].filter(Boolean);
   if (!failed.length) return null;
-  return `continued run meta.json failed ${failed.join(', ')}. The run folder was not created; quota was not spent.`;
+  return [orderRuleMessage('advise-scope-run-required', {
+    violation: 'meta', failed: failed.join(', '),
+  }), orderDiagnosticMessage('run-not-created')].join(' ');
 }
 
 /** D2: phase mistakes must refuse before even the sandbox probe can spend quota. */
 export function resolveRunPhase({ agent, phase, continue: isContinue }, budgets) {
   // Plan_59 D7: phase 2 must retain the scope run's predictions before quota is spent.
   if (agent === 'codex-advisor' && phase === 'advise' && !isContinue) {
-    die(`codex-advisor ${orderInputName('phase')} advise requires a ${orderInputName('continue')} grant naming the scope run: phase 2 continues the scope run of the same order ` +
-      'so it can settle the risks phase 1 predicted. The run folder was not created; quota was not spent.');
+    die([orderRuleMessage('advisor-advise-continuation', {
+      phaseLabel: orderInputName('phase'), continueLabel: orderInputName('continue'),
+    }), orderDiagnosticMessage('run-not-created')].join(' '));
   }
   const phases = budgets[agentRole(agent)];
   const names = Object.keys(phases);
-  if (phase === undefined && names.length === 1 && names[0] === 'default') return 'default';
+  if (phase === undefined && names.length === 1 && names[0] === 'default') return names[0];
   if (phase !== undefined && Object.hasOwn(phases, phase)) return phase;
-  die(`${phase === undefined ? `${orderInputName('phase')} is required` : `undeclared ${orderInputName('phase')} ${JSON.stringify(phase)}`} ` +
-    `for ${agent}. Action: pass ${orderInputName('phase')} <name>; allowed phases: ${names.join(', ')}. ` +
-    'The run folder was not created; quota was not spent.');
+  die([orderRuleMessage('run-phase-required', {
+    violation: phase === undefined ? 'missing' : 'undeclared', phaseLabel: orderInputName('phase'), phase, agent, names,
+  }), orderDiagnosticMessage('run-not-created')].join(' '));
 }
 
 export function preflightRefusal({ agent, projectRunsRoot, repoRoot }) {
   // Two writing runs share one tree: the second snapshot would include the first one's edits.
   const busy = agent === 'codex-build' ? activeRunDetails(projectRunsRoot, repoRoot) : null;
   if (busy) {
-    const identityNote = busy.identity === 'unverified'
-      ? '; process identity could not be confirmed'
-      : '';
-    return [
-      `run ${busy.run} is already active for this repository; two writing runs in one tree are prohibited${identityNote}`,
-      `Active run: ${path.join(projectRunsRoot, busy.run)}`,
-      // One sentence, the same one every other pre-flight refusal ends with. The older wording
-      // said the identical thing twice, which is how two copies of a rule start to drift.
-      'The run folder was not created; quota was not spent.',
-    ].join('\n');
+    return [orderRuleMessage('writing-run-exclusive', {
+      run: busy.run, activePath: path.join(projectRunsRoot, busy.run), identity: busy.identity,
+    }), orderDiagnosticMessage('run-not-created')].join('\n');
   }
 
   return null;

package/src/home/lib/runner/question-kind.mjs

@@ -3,6 +3,8 @@
  * Plan_60 D1: only the orderer knows whether a question concerns handed startup context or code;
  * the scout cannot choose its own kind, and startup context currently fails without a command.
  */
+import { orderRuleMessage } from '../order-rules.mjs';
+
 export const CONTEXT_ONLY_MARKER = '[context-only]';
 export const QUESTION_KIND = Object.freeze({
   STARTUP_CONTEXT: 'startup-context',
@@ -14,13 +16,13 @@ export function questionKindRefusal(texts = []) {
     const tokens = text.matchAll(/\[\s*context[\s_-]*only\s*\]/gi);
     for (const token of tokens) {
       if (token.index !== 0 || token[0] !== CONTEXT_ONLY_MARKER) {
-        return `Q${index + 1} has an invalid context-only marker in ${JSON.stringify(text)}`;
+        return orderRuleMessage('question-context-marker', { index, text });
       }
     }
     if (text.startsWith(CONTEXT_ONLY_MARKER)) {
       const question = text.slice(CONTEXT_ONLY_MARKER.length);
       if (!/^\s/.test(question) || !question.trim()) {
-        return `Q${index + 1} has an invalid context-only marker in ${JSON.stringify(text)}`;
+        return orderRuleMessage('question-context-marker', { index, text });
       }
     }
   }

package/src/home/lib/runner/retired-roots.mjs

@@ -11,6 +11,8 @@ import { writeHomeJsonAtomic } from '../atomic-json.mjs';
 import { stateDirWriter } from '../home-write.mjs';
 import { parseJsonText } from '../json-file.mjs';
 import { normalizeRepoPath } from './project-dir.mjs';
+import { orderRuleMessage } from '../order-rules.mjs';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 
 export const RUNS_MOVE_RECORD = 'runs-root.json';
 
@@ -21,25 +23,31 @@ export function readRunsMoveRecord(stateDir) {
     text = fs.readFileSync(file, 'utf8');
   } catch (error) {
     if (error.code === 'ENOENT') return null;
-    throw new Error(`Cannot read runs move record ${file}: ${error.message}`, { cause: error });
+    throw new Error(orderDiagnosticMessage('runs-move-record-readable', {
+      file, message: error.message,
+    }), { cause: error });
   }
   let record;
   try {
     record = parseJsonText(file, text);
   } catch (error) {
-    throw new Error(`Invalid runs move record ${file}: ${error.message}`, { cause: error });
+    throw new Error(orderDiagnosticMessage('runs-move-record-invalid', {
+      file, violation: 'parse', detail: error.message,
+    }), { cause: error });
   }
-  const invalid = (defect) => { throw new Error(`Invalid runs move record ${file}: ${defect}`); };
-  if (record?.version !== 1) invalid('version must be 1');
+  const invalid = (violation, index) => {
+    throw new Error(orderDiagnosticMessage('runs-move-record-invalid', { file, violation, index }));
+  };
+  if (record?.version !== 1) invalid('version');
   if (!Array.isArray(record.retired) || record.retired.length === 0) {
-    invalid('retired must be a non-empty array');
+    invalid('retired-array');
   }
   for (const [index, entry] of record.retired.entries()) {
     if (typeof entry?.root !== 'string' || !path.isAbsolute(entry.root)) {
-      invalid(`retired[${index}].root must be an absolute path`);
+      invalid('retired-root', index);
     }
     if (typeof entry.movedAt !== 'string' || !Number.isFinite(Date.parse(entry.movedAt))) {
-      invalid(`retired[${index}].movedAt must be a parseable ISO time`);
+      invalid('retired-time', index);
     }
   }
   return record;
@@ -63,8 +71,9 @@ export function retiredRootOf(candidate, retiredRoots) {
 
 export function retiredRootRefusal({ candidate, retired, destination }) {
   const equivalent = retired.suffix ? path.join(destination, retired.suffix) : destination;
-  return `Run records moved from ${retired.root} to ${destination}. Equivalent path: ${equivalent}. ` +
-    'Update advice: or pass this new path explicitly. No path was remapped.';
+  return orderRuleMessage('advice-retired-root', {
+    candidate, retiredRoot: retired.root, destination, equivalent,
+  });
 }
 
 /**

package/src/home/lib/runner/runs-root.mjs

@@ -13,6 +13,7 @@ import path from 'node:path';
 import { resolveBrandHome } from '../brand-home.mjs';
 import { RUN_RECORDS_DIR } from '../home-registry.mjs';
 import { readRunsMoveRecord, retiredRootOf, retiredRootRefusal } from './retired-roots.mjs';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 
 export function runsRootResolution({ env = process.env, homedir = os.homedir() } = {}) {
   const brandHome = resolveBrandHome({ env, homedir });
@@ -50,7 +51,6 @@ export function retiredPathRefusal(candidate, resolution = runsRootResolution())
 
 export function staleOverrideRefusal(resolution = runsRootResolution()) {
   if (!resolution.staleOverride) return null;
-  return retiredRootRefusal({ candidate: resolution.root, retired: resolution.staleOverride,
-    destination: resolution.homeRoot }) + '\n' +
-    'CODEX_RUNS_ROOT points under a retired runs root; remove it or set it to the new location.';
+  return [retiredRootRefusal({ candidate: resolution.root, retired: resolution.staleOverride,
+    destination: resolution.homeRoot }), orderDiagnosticMessage('stale-runs-root-override')].join('\n');
 }

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

@@ -1,13 +1,13 @@
 /** 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';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 
 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([
@@ -16,16 +16,18 @@ const SIGNATURES = Object.freeze([
     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.',
+    summary: orderDiagnosticMessage('sandbox-known-failure-runtime-file-locked', { part: 'summary' }),
+    repair: () => orderDiagnosticMessage('sandbox-known-failure-runtime-file-locked', { part: 'repair' }),
   }),
   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.`,
+    summary: orderDiagnosticMessage('sandbox-known-failure-deny-read-state-corrupt', { part: 'summary' }),
+    repair: (codexHome) => orderDiagnosticMessage('sandbox-known-failure-deny-read-state-corrupt', {
+      part: 'repair', file: path.join(codexHome, '.sandbox', 'deny_read_acl_state.json'),
+    }),
   }),
 ]);
 
@@ -94,7 +96,7 @@ function readSetupError(file, folderState) {
   return {
     state: result.state,
     text: result.state === 'read' ? result.text : result.state === 'missing' ? null
-      : `Unknown: unable to read ${file}.`,
+      : orderDiagnosticMessage('sandbox-evidence-unknown', { variant: 'unreadable', file }),
   };
 }
 
@@ -127,7 +129,7 @@ export function diagnoseSandbox({ codexHome, before, now = new Date() }) {
     if (result.state === 'missing') continue;
     sources.push(file);
     if (result.state === 'unknown') {
-      unknown.push(`Unknown: unable to read ${file}.`);
+      unknown.push(orderDiagnosticMessage('sandbox-evidence-unknown', { variant: 'unreadable', file }));
       continue;
     }
     if (baseline !== null && result.bytes > 0) {
@@ -135,7 +137,7 @@ export function diagnoseSandbox({ codexHome, before, now = new Date() }) {
       appended.push(result.text);
     }
     recent.push({ file, mtime: result.mtime });
-    if (baseline === null) unknown.push(`Unknown: pre-probe size unavailable for ${file}.`);
+    if (baseline === null) unknown.push(orderDiagnosticMessage('sandbox-evidence-unknown', { variant: 'baseline', file }));
   }
 
   let text = appended.join('\n');
@@ -143,7 +145,7 @@ export function diagnoseSandbox({ codexHome, before, now = new Date() }) {
     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}.`);
+    else unknown.push(orderDiagnosticMessage('sandbox-evidence-unknown', { variant: 'unreadable', file: newest.file }));
   }
   const errors = text.split(/\r?\n/)
     .filter((line) => ERROR_LINE.test(line) && !CLEAN_REFRESH.test(line)).slice(-5);
@@ -166,15 +168,13 @@ export function diagnoseSandbox({ codexHome, before, now = new Date() }) {
 
 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.sources.map((source) => orderDiagnosticMessage('sandbox-diagnosis-source', { source })),
+    orderDiagnosticMessage('sandbox-diagnosis-attribution', { attributed: diagnosis.attributed }),
+    ...diagnosis.lines.map((line) => orderDiagnosticMessage('sandbox-evidence-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}`),
+      orderDiagnosticMessage('sandbox-setup-change', { changed: diagnosis.setupError.changed }),
+      ...diagnosis.setupError.text.split(/\r?\n/).map((line) => orderDiagnosticMessage('sandbox-evidence-line', { line })),
     ]),
-    ...(diagnosis.signature ? [diagnosis.signature.summary, diagnosis.signature.repair] : [NO_REPAIR]),
+    ...(diagnosis.signature ? [diagnosis.signature.summary, diagnosis.signature.repair] : [orderDiagnosticMessage('sandbox-no-repair')]),
   ];
 }