@lyupro/codex-bridge 0.6.14 → 0.6.16

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

@@ -1,5 +1,6 @@
 /** Checks whether this host's Codex sandbox can start a process before a run spends quota. */
 import { performance } from 'node:perf_hooks';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 import { sandboxModeFor } from './codex-args.mjs';
 import { codexSpawnSpec, spawnCaptured } from './codex-cmd.mjs';
 import { platformSandboxArgs } from './sandbox-flags.mjs';
@@ -12,15 +13,6 @@ export const SANDBOX_PROBE_MARKER = 'codex-bridge-sandbox-ok';
 // on the same host after the AppArmor repair. macOS has never been observed.
 export const PROBED_PLATFORMS = new Set(['win32', 'linux']);
 
-// Ubuntu 23.10+ forbids unprivileged user namespaces unless an AppArmor profile allows bwrap; that
-// is the ordinary state of a fresh server, not an accident like the corrupted Windows state file.
-const LINUX_REPAIR = [
-  'On Ubuntu 23.10 and later this usually means AppArmor does not let bubblewrap create a user namespace.',
-  'Official repair: https://learn.chatgpt.com/docs/sandboxing — the bwrap-userns-restrict AppArmor profile',
-  '(Ubuntu 24.04) or the bubblewrap package (25.04 and later). Do not set',
-  'kernel.apparmor_restrict_unprivileged_userns=0: it lifts the restriction for every program on the host.',
-].join(' ');
-
 const echoArgs = (platform) => platform === 'win32'
   ? ['cmd', '/d', '/c', 'echo', SANDBOX_PROBE_MARKER]
   : ['echo', SANDBOX_PROBE_MARKER];
@@ -28,12 +20,12 @@ const echoArgs = (platform) => platform === 'win32'
 function inconclusiveReason(result, form) {
   if (result.error) {
     return result.error.code === 'ETIMEDOUT'
-      ? `The ${form} sandbox probe timed out.`
-      : `The ${form} sandbox probe could not start or complete.`;
+      ? orderDiagnosticMessage('sandbox-probe-reason', { variant: 'timeout', form })
+      : orderDiagnosticMessage('sandbox-probe-reason', { variant: 'incomplete', form });
   }
-  if (result.signal) return `The ${form} sandbox probe was terminated by ${result.signal}.`;
-  if (result.status === 2) return `Codex rejected the ${form} sandbox probe arguments.`;
-  if (result.status == null) return `The ${form} sandbox probe returned no exit status.`;
+  if (result.signal) return orderDiagnosticMessage('sandbox-probe-reason', { variant: 'signal', form, signal: result.signal });
+  if (result.status === 2) return orderDiagnosticMessage('sandbox-probe-reason', { variant: 'arguments', form });
+  if (result.status == null) return orderDiagnosticMessage('sandbox-probe-reason', { variant: 'no-status', form });
   return null;
 }
 
@@ -43,7 +35,7 @@ export async function probeSandbox({
 }) {
   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');
+  if (typeof repo !== 'string' || !repo) throw new Error(orderDiagnosticMessage('sandbox-probe-repository-required'));
   const echo = echoArgs(platform);
   const attempts = [];
   // The 2026-10-10 TradeForge refusals showed only "setup refresh had errors"; capture the
@@ -95,43 +87,42 @@ export async function probeSandbox({
   const flaggedReason = inconclusiveReason(flagged, 'flagged');
   if (flaggedReason) return finish('inconclusive', flaggedReason);
   if (flagged.status === 0 && flagged.marker) {
-    return finish('alive', 'The Codex sandbox started a process.');
+    return finish('alive', orderDiagnosticMessage('sandbox-probe-reason', { variant: 'alive' }));
   }
   // D16: the marker proves a process started, so a nonzero exit cannot prove a dead sandbox.
   if (flagged.marker) {
-    return finish('inconclusive', `The flagged sandbox probe printed the marker but exited ${flagged.status}.`);
+    return finish('inconclusive', orderDiagnosticMessage('sandbox-probe-reason', { variant: 'marker-exit', status: flagged.status }));
   }
 
   const control = await attempt('control', ['sandbox', '--', ...echo]);
   const controlReason = inconclusiveReason(control, 'control');
   if (controlReason) return finish('inconclusive', controlReason);
   if (control.marker) {
-    return finish('inconclusive', 'This version of Codex no longer accepts the package sandbox flags.');
+    return finish('inconclusive', orderDiagnosticMessage('sandbox-probe-reason', { variant: 'flags' }));
   }
 
   const version = await attempt('version', ['--version']);
   if (version.error || version.signal || version.status !== 0) {
     // codexAvailabilityRefusal() owns the refusal for an unavailable CLI, earlier in the same pre-flight pass.
-    return finish('inconclusive', 'Codex CLI is unavailable.');
+    return finish('inconclusive', orderDiagnosticMessage('sandbox-probe-reason', { variant: 'unavailable' }));
   }
-  return finish('dead', 'The Codex sandbox on this host cannot start a process.');
+  return finish('dead', orderDiagnosticMessage('sandbox-probe-reason', { variant: 'dead' }));
 }
 
 export function sandboxRefusal(result, platform = process.platform) {
-  const control = ['codex', 'sandbox', '--', ...echoArgs(platform)].join(' ');
+  const controlCommand = ['codex', 'sandbox', '--', ...echoArgs(platform)].join(' ');
   const stderr = result.attempts
     .filter(({ form }) => form === 'flagged' || form === 'control')
-    .map(({ form, stderrTail }) =>
-      `${form} stderr:\n> ${(stderrTail || '(empty)').replace(/\r\n?/g, '\n').replace(/\n/g, '\n> ')}`);
+    .map(({ form, stderrTail }) => orderDiagnosticMessage('sandbox-stderr-evidence', { form, stderrTail }));
   // Only a dead result is refused, and its reason already is the headline; printing both said it twice.
   return [
     result.reason,
-    'Repair the host sandbox; do not rewrite or retry the order.',
-    ...(platform === 'linux' ? [LINUX_REPAIR] : []),
-    `Operator check (run from the repository directory): ${control}`,
+    orderDiagnosticMessage('sandbox-refusal-repair'),
+    ...(platform === 'linux' ? [orderDiagnosticMessage('sandbox-linux-repair')] : []),
+    orderDiagnosticMessage('sandbox-operator-check', { command: controlCommand }),
     ...stderr,
     ...(result.diagnosis && typeof result.diagnosis === 'object'
       ? [formatSandboxDiagnosis(result.diagnosis).join('\n')] : []),
-    'The run folder was not created; quota was not spent.',
+    orderDiagnosticMessage('run-not-created'),
   ].join('\n\n');
 }

package/src/home/lib/runner/scope-check.mjs

@@ -9,6 +9,7 @@ import path from 'node:path';
 import { listRepositoryPaths } from './git-paths.mjs';
 import { globToRegExp, normalizePath, SERVICE_RE } from '../meta/paths.mjs';
 import { orderInputName } from '../order-schema.mjs';
+import { orderRuleMessage } from '../order-rules.mjs';
 
 // Directories a self-walk must never descend into. Only reached when the repository has no git:
 // with git present the file list comes from the repository itself, which already knows what is
@@ -29,41 +30,41 @@ function structuralRefusal(repoRoot, pattern) {
   // Plan_73 D7: scope lists store one pattern per line; literal line breaks cannot round-trip.
   if (/[\n\r]/.test(pattern)) {
     return {
-      reason: 'contains a newline or carriage return',
-      action: 'use a glob instead of a literal path containing a line break',
+      reason: orderRuleMessage('scope-pattern-shape', { violation: 'line-break', part: 'reason' }),
+      action: orderRuleMessage('scope-pattern-shape', { violation: 'line-break', part: 'action' }),
     };
   }
   if (absolutePattern(pattern)) {
     return {
-      reason: 'is an absolute or drive-qualified path',
-      action: 'use a path relative to the repository root with forward slashes',
+      reason: orderRuleMessage('scope-pattern-shape', { violation: 'absolute', part: 'reason' }),
+      action: orderRuleMessage('scope-pattern-shape', { violation: 'absolute', part: 'action' }),
     };
   }
   if (pattern.includes('\\')) {
     return {
-      reason: 'uses backslash separators',
-      action: 'replace backslashes with forward slashes',
+      reason: orderRuleMessage('scope-pattern-shape', { violation: 'backslash', part: 'reason' }),
+      action: orderRuleMessage('scope-pattern-shape', { violation: 'backslash', part: 'action' }),
     };
   }
   if (pattern.split('/').some((segment) => segment === '..')) {
     return {
-      reason: 'contains a parent-directory (..) segment',
-      action: 'remove the .. segment and keep the path relative to the repository root',
+      reason: orderRuleMessage('scope-pattern-shape', { violation: 'parent-directory', part: 'reason' }),
+      action: orderRuleMessage('scope-pattern-shape', { violation: 'parent-directory', part: 'action' }),
     };
   }
   // Plan_59 S1: 2026-09-22_235724_plan59-d1-advisor-docs-surface spent 22 minutes on a
   // service-directory scope the verdict could never authorise. Refuse it before a run exists.
   if (SERVICE_RE.test(normalizePath(pattern))) {
     return {
-      reason: 'lies inside a service directory that no scope can authorise',
-      action: 'name the file outside the service directory, or make that edit yourself',
+      reason: orderRuleMessage('scope-pattern-shape', { violation: 'service-directory', part: 'reason' }),
+      action: orderRuleMessage('scope-pattern-shape', { violation: 'service-directory', part: 'action' }),
     };
   }
   // Plan_58 D7: 2026-09-19_191402_ports-infra spent a run on a bare scope-new directory,
   // which the verdict could only match as a file. Refuse that intent before spending a run.
   if (!pattern || /[*?]/.test(pattern)) return null;
-  const reason = 'names a directory rather than a file';
-  const action = `write ${pattern.replace(/\/$/, '')}/** for everything inside it, or name the file itself`;
+  const reason = orderRuleMessage('scope-pattern-shape', { violation: 'directory', part: 'reason' });
+  const action = orderRuleMessage('scope-pattern-shape', { violation: 'directory', part: 'action', pattern });
   if (pattern.endsWith('/')) return { reason, action };
 
   let entry;
@@ -76,7 +77,7 @@ function structuralRefusal(repoRoot, pattern) {
   if (!entry && !pattern.split('/').at(-1).includes('.')) {
     return {
       reason,
-      action: `write ${pattern}/** if it is a directory, or declare the new file by its own name with an extension; a new extensionless file is declared through its directory`,
+      action: orderRuleMessage('scope-pattern-shape', { violation: 'new-directory', part: 'action', pattern }),
     };
   }
   return null;
@@ -88,16 +89,18 @@ function noMatchRefusal(pattern, repoRoot, gitListed) {
   if (gitListed === false) {
     return {
       pattern,
-      reason: `does not match any existing path under ${repoRoot}; ` +
-        'git could not list that folder as a repository, so it was walked instead',
-      action: `start the run from the repository root (cd into it, or pass ${orderInputName('repository')} <repository root>); ` +
-        'if this folder is the intended one, correct the pattern',
+      reason: orderRuleMessage('scope-pattern-match', { violation: 'not-repository', part: 'reason', repoRoot }),
+      action: orderRuleMessage('scope-pattern-match', {
+        violation: 'not-repository', part: 'action', labelName: orderInputName('repository'),
+      }),
     };
   }
   return {
     pattern,
-    reason: 'does not match any existing path in the repository',
-    action: `correct the pattern or declare an intentionally new path with ${orderInputName('scope new')}`,
+    reason: orderRuleMessage('scope-pattern-match', { violation: 'missing', part: 'reason' }),
+    action: orderRuleMessage('scope-pattern-match', {
+      violation: 'missing', part: 'action', labelName: orderInputName('scope new'),
+    }),
   };
 }
 
@@ -193,8 +196,10 @@ export function validateScope(repoRoot, patterns, scopeNewPatterns = []) {
     return {
       pattern: required[0],
       label: 'scope',
-      reason: `could not parse the pattern: ${error.message}`,
-      action: 'correct the pattern and retry',
+      reason: orderRuleMessage('scope-pattern-match', {
+        violation: 'invalid-glob', part: 'reason', message: error.message,
+      }),
+      action: orderRuleMessage('scope-pattern-match', { violation: 'invalid-glob', part: 'action' }),
     };
   }
 
@@ -206,8 +211,10 @@ export function validateScope(repoRoot, patterns, scopeNewPatterns = []) {
     return {
       pattern: required[0],
       label: 'scope',
-      reason: error.message,
-      action: 'rename the non-UTF-8 file using a UTF-8 file name and retry',
+      reason: orderRuleMessage('scope-pattern-match', {
+        violation: 'non-utf8', part: 'reason', message: error.message,
+      }),
+      action: orderRuleMessage('scope-pattern-match', { violation: 'non-utf8', part: 'action' }),
     };
   }
   const missing = matchers.find((matcher) => !matches.matched.has(matcher.pattern));

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

@@ -6,6 +6,8 @@
  * text in the file while the headingless form preserves every existing task file.
  */
 
+import { orderRuleMessage } from '../order-rules.mjs';
+
 const SECTION_HEADING = /^ {0,3}(#{1,6})[ \t]+(.+?)[ \t]*$/;
 const LIST_ITEM = /^\s*(?:[-*]|\d+\.)[ \t]+(.+?)\s*$/;
 const SECTION_NAMES = new Map([
@@ -72,16 +74,16 @@ export function parseTaskDocument(text) {
     if (!line.trim()) continue;
     const item = LIST_ITEM.exec(line);
     if (!item) {
-      throw new Error(`Questions section contains a non-list line: ${JSON.stringify(line.trim())}`);
+      throw new Error(orderRuleMessage('scout-questions', { violation: 'non-list-line', line }));
     }
     questions.push(item[1].trim());
   }
-  if (sawQuestions && !questions.length) throw new Error('Questions section is empty');
+  if (sawQuestions && !questions.length) throw new Error(orderRuleMessage('scout-questions', { violation: 'empty' }));
 
   const verifyContent = verifyLines.filter((line) => line.trim());
-  if (sawVerify && !verifyContent.length) throw new Error('Verify section is empty');
+  if (sawVerify && !verifyContent.length) throw new Error(orderRuleMessage('verify-line', { violation: 'empty' }));
   if (verifyContent.length > 1) {
-    throw new Error('Verify section must contain exactly one non-empty line');
+    throw new Error(orderRuleMessage('verify-line', { violation: 'multiple-lines' }));
   }
 
   return {

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

@@ -10,6 +10,8 @@ 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';
+import { orderRuleMessage, orderLabelReason } from '../order-rules.mjs';
+import { orderDiagnosticMessage } from '../order-diagnostics.mjs';
 
 /**
  * OW-061: outside git the launcher keeps `repository:` as given and the project folder takes its
@@ -21,18 +23,17 @@ import { orderOptions } from './order-options.mjs';
  */
 export function repositoryRefusal(value) {
   if (!path.isAbsolute(value)) {
-    return `must be an absolute path to the repository; got ${JSON.stringify(value)}.`;
+    return orderRuleMessage('repository-path', { violation: 'relative', 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)}.`;
+    return orderRuleMessage('repository-path', { violation: 'altered-segment', value, segment: altered });
   }
   let isDirectory = false;
   try {
     isDirectory = fs.statSync(value).isDirectory();
   } catch {}
-  return isDirectory ? null : `must name an existing directory; ${JSON.stringify(value)} is not one.`;
+  return isDirectory ? null : orderRuleMessage('repository-path', { violation: 'not-directory', value });
 }
 
 export function settleTaskInput(opts, { cwd = process.cwd() } = {}) {
@@ -43,11 +44,13 @@ export function settleTaskInput(opts, { cwd = process.cwd() } = {}) {
   }
   const normalized = orderOptions(opts.agent, order, { cwd });
   if (normalized.problems.length) {
-    die(normalized.problems.map(({ label, reason }) => `${orderInputName(label)} ${reason}`).join('\n'));
+    die(normalized.problems.map(({ label, reason }) => orderLabelReason(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.`);
+    die(orderRuleMessage('repository-path', {
+      context: 'task-input', label: orderInputName('repository'), reason: repositoryReason,
+    }));
   }
   Object.assign(opts, normalized.options);
   opts.continue = Boolean(header.grant);
@@ -56,23 +59,16 @@ export function settleTaskInput(opts, { cwd = process.cwd() } = {}) {
   // Still before the run folder exists and before a token of someone else's quota is touched,
   // which is where every refusal of this kind belongs.
   if (opts.agent === 'codex-scout' && !opts.questions?.length) {
-    die(
-      'a sub-question is required for codex-scout: put one Markdown list item per sub-question ' +
-        'under a `Questions` heading in the task document. ' +
-        'The runner will not infer questions from the task text; no quota was spent.',
-    );
+    die(orderRuleMessage('scout-questions', { violation: 'missing' }));
   }
   if (opts.agent === 'codex-scout') {
     const refusal = questionKindRefusal(opts.questions);
     if (refusal) {
-      die(
-        `${refusal}; the marker is exactly [context-only] followed by a space and the question; no quota was spent.`,
-      );
+      die(orderRuleMessage('question-context-marker', { context: 'task-input', refusal }));
     }
   }
   if (opts.noWait && opts.continue) {
-    die(`--no-wait cannot be combined with a ${orderInputName(header.grant.kind)} grant: ` +
-      'checking an existing run must never authorize a new one.');
+    die(orderDiagnosticMessage('no-wait-grant-conflict', { grant: orderInputName(header.grant.kind) }));
   }
   return { task, header };
 }

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

@@ -9,6 +9,9 @@ import { readJsonFileSync } from '../json-file.mjs';
 import { writeStatus } from '../meta/run-state.mjs';
 import { acquireOrderClaim } from './order-claim.mjs';
 
+// Plan_79 B4e: admission reasons are machine-readable codes, not refusal prose.
+const REASONS = Object.freeze({ claimTimeout: 'claim-timeout', closed: 'closed' });
+
 export async function admitWorker({ runDir, orderId, timing, platform, createServer }) {
   const claim = await acquireOrderClaim({
     projectRunsRoot: path.dirname(runDir),
@@ -19,7 +22,7 @@ export async function admitWorker({ runDir, orderId, timing, platform, createSer
     ...(createServer !== undefined ? { createServer } : {}),
   });
   try {
-    if (claim.busy) return { admitted: false, reason: 'claim-timeout', holder: claim.holder };
+    if (claim.busy) return { admitted: false, reason: REASONS.claimTimeout, holder: claim.holder };
     let status = null;
     try {
       status = readJsonFileSync(path.join(runDir, 'status.json'));
@@ -27,7 +30,7 @@ export async function admitWorker({ runDir, orderId, timing, platform, createSer
       // 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 };
+      return { admitted: false, reason: REASONS.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.

package/src/home/lib/subagent-model-env.mjs

@@ -4,10 +4,11 @@
  * Unknown host versions are not evidence for a pre-start refusal.
  */
 import { modelFamily } from './model-family.mjs';
+import { orderDiagnosticMessage } from './order-diagnostics.mjs';
 
 // Host contract facts, not package versions or volatile model identifiers (Plan_67 D6 (b)).
-export const FRONTMATTER_PRECEDENCE_VERSION = '2.1.251';
-export const SUBAGENT_MODEL_FORCE_VERSION = '2.1.257';
+export const FRONTMATTER_PRECEDENCE_VERSION = '2.1.251'; // order-guard: not-a-refusal — host version boundary compared as data
+export const SUBAGENT_MODEL_FORCE_VERSION = '2.1.257'; // order-guard: not-a-refusal — host version boundary compared as data
 
 function versionParts(value) {
   if (typeof value !== 'string' || !/^\d+\.\d+\.\d+(?:\.\d+)*$/.test(value)) return null;
@@ -37,8 +38,6 @@ export function envModelProblem({ env, hostVersion, pinFamily }) {
   const model = env.CLAUDE_CODE_SUBAGENT_MODEL;
   const family = modelFamily(model);
   if (family === null || pinFamily === null || family === pinFamily) return null;
-  return `Order gate denied the Agent call because CLAUDE_CODE_SUBAGENT_MODEL=${JSON.stringify(model)} `
-    + `overrides the installed dispatcher pin ${pinFamily} on host ${hostVersion}. `
-    + `Unset CLAUDE_CODE_SUBAGENT_MODEL or set it to the pinned family ${pinFamily}. `
-    + 'The run folder was not created; quota was not spent.';
+  return [orderDiagnosticMessage('subagent-model-env-pin', { model, pinFamily, hostVersion }),
+    orderDiagnosticMessage('run-not-created')].join(' ');
 }