@lyupro/codex-bridge 0.6.15 → 0.6.16

package/CHANGELOG.md

@@ -4,6 +4,29 @@ 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.16] - 2026-10-14
+
+### Changed
+
+- `codex-bridge guidance order` now prints every rule the runner, the order gate and the dispatcher enforce on a
+  task file, under "Rules the runner enforces", straight from the registry that also builds each refusal. A rule
+  could previously be enforced without being described anywhere, and an orchestrator learned it only from a
+  refusal. The topic's own text keeps the examples and the meaning of the grants, not copies of these rules.
+- The rules core installed into the Claude Code host now says to run `codex-bridge guidance order` before every
+  task file. Run `codex-bridge update` to refresh the installed core.
+- The `records` topic describes `task.md` (the assembled input Codex receives), `raw.log` (optional transport
+  evidence) and the required fields of `review.json`. The list of shell-unsafe sequences in `order` is printed
+  from the code that refuses them, not copied by hand.
+- The dispatcher prompts and the dispatcher gate take their instructions from one catalog, so the reason a call is
+  denied is a phrase the dispatcher prompt already contains. Installed prompts change wording after
+  `codex-bridge update`; the gate's refusal texts are unchanged.
+
+### Fixed
+
+- The test-time check that every refusal text comes from the registry can no longer lose a violation when its
+  journal cannot be written: the process stops with exit code 70 and leaves a marker the test runner fails on.
+  This affects only the package's own test suite.
+
 ## [0.6.15] - 2026-10-12
 
 ### Fixed

package/README.md

@@ -62,7 +62,7 @@ Run records in `~/.lyupro/.codex-bridge/runs/` (or `~/.claude/codex-runs/` befor
 - **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 **3664 automated tests: 3661 passing and 3 skipped**.
+The current suite contains **4262 automated tests: 4259 passing and 3 skipped**.
 
 ## Verify
 

package/cli/command-registry.mjs

@@ -283,7 +283,7 @@ export const COMMANDS = [
     usage: ['codex-bridge guidance [<topic>]'],
     section: 'public',
     async handler(argv, io) {
-      const result = guidance(argv);
+      const result = await guidance(argv);
       if (result.exitCode === 2) io.error(result.output);
       else io.log(result.output);
       return result.exitCode;

package/cli/guidance-render.mjs

@@ -0,0 +1,57 @@
+/** Plan_79 B1: guidance derives owned values from the installed home, never a second list. */
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { GUIDANCE_TOPICS } from './guidance-topics.mjs';
+
+const codeList = (values) => values.map((value) =>
+  value.includes('`') ? '`` ' + value + ' ``' : '`' + value + '`').join(', ');
+
+function renderError(topic, placeholder, message) {
+  return new Error(`Cannot render guidance topic "${topic}" placeholder "${placeholder}": ${message}`);
+}
+
+export async function renderGuidance(text, { root, topic }) {
+  const values = new Map();
+  for (const [placeholder, name] of text.matchAll(/\{\{([^{}]*)\}\}/g)) {
+    if (values.has(placeholder)) continue;
+    try {
+      // The 2026-08-26 seeded-config incident requires file URLs rooted in the installed home.
+      if (name === 'shell-unsafe-sequences') {
+        const { SHELL_UNSAFE_SEQUENCES } = await import(pathToFileURL(path.join(root, 'lib', 'shell-unsafe.mjs')).href);
+        values.set(placeholder, codeList(SHELL_UNSAFE_SEQUENCES));
+      } else if (name === 'review-required-fields') {
+        const { SCHEMAS } = await import(pathToFileURL(path.join(root, 'lib', 'runner', 'schemas.mjs')).href);
+        const review = SCHEMAS['codex-review'];
+        values.set(placeholder, `Top-level fields: ${codeList(review.required)}; finding fields: ${codeList(review.properties.findings.items.required)}`);
+      } else if (name.startsWith('order-rules:')) {
+        const ruleTopic = name.slice('order-rules:'.length);
+        if (ruleTopic !== 'all' && !Object.hasOwn(GUIDANCE_TOPICS, ruleTopic)) {
+          throw new Error(`unknown order rule topic "${ruleTopic}"`);
+        }
+        const { ORDER_RULES } = await import(pathToFileURL(path.join(root, 'lib', 'order-rules.mjs')).href);
+        const rules = Object.entries(ORDER_RULES);
+        const items = (owner) => rules.filter(([, rule]) => rule.topic === owner)
+          .map(([key, rule]) => `- \`${key}\`: ${rule.rule}`).join('\n');
+        const block = ruleTopic === 'all'
+          ? Object.keys(GUIDANCE_TOPICS).map((owner) => {
+            const list = items(owner);
+            return list ? `Topic \`${owner}\`:\n${list}` : '';
+          }).filter(Boolean).join('\n\n')
+          : items(ruleTopic);
+        if (!block) throw new Error('no order rules to render');
+        values.set(placeholder, block);
+      } else {
+        throw new Error('unknown placeholder');
+      }
+    } catch (error) {
+      throw renderError(topic, placeholder, error.message);
+    }
+  }
+  const rendered = text.replace(/\{\{([^{}]*)\}\}/g, (placeholder) => values.get(placeholder));
+  const unresolved = rendered.indexOf('{{');
+  if (unresolved !== -1) {
+    const placeholder = rendered.slice(unresolved).split(/\r?\n/, 1)[0];
+    throw renderError(topic, placeholder, 'unresolved placeholder');
+  }
+  return rendered;
+}

package/cli/guidance-topics.mjs

@@ -0,0 +1,8 @@
+/** Defines the registered guidance topics and their summaries. */
+export const GUIDANCE_TOPICS = Object.freeze({
+  order: 'Task file, header labels, and scope.',
+  advisor: 'Scope and advise phases, and the continue grant.',
+  budget: 'Run deadline and slicing.',
+  records: 'Finding and reading runs.',
+  concurrency: 'Parallel and writing runs.',
+});

package/cli/guidance.mjs

@@ -2,14 +2,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { resolveBrandHome } from '../src/home/lib/brand-home.mjs';
-
-export const GUIDANCE_TOPICS = Object.freeze({
-  order: 'Task file, header labels, and scope.',
-  advisor: 'Scope and advise phases, and the continue grant.',
-  budget: 'Run deadline and slicing.',
-  records: 'Finding and reading runs.',
-  concurrency: 'Parallel and writing runs.',
-});
+import { renderGuidance } from './guidance-render.mjs';
+import { GUIDANCE_TOPICS } from './guidance-topics.mjs';
 
 const topicList = () => [
   'Topics:',
@@ -18,7 +12,7 @@ const topicList = () => [
   'Usage: codex-bridge guidance [<topic>]',
 ].join('\n');
 
-export function guidance(argv, { env = process.env, homedir } = {}) {
+export async function guidance(argv, { env = process.env, homedir } = {}) {
   if (argv.length === 0) return { exitCode: 0, output: topicList() };
   if (argv.length > 1) {
     return { exitCode: 2, output: `codex-bridge guidance accepts at most one topic.\n${topicList()}` };
@@ -31,12 +25,17 @@ export function guidance(argv, { env = process.env, homedir } = {}) {
   // The 2026-08-26 seeded-config incident forbids reading installed files from the clone.
   const { root } = resolveBrandHome({ homedir, env });
   const file = path.join(root, 'guidance', `${topic}.md`);
+  let text;
   try {
-    return { exitCode: 0, output: fs.readFileSync(file, 'utf8') };
+    text = fs.readFileSync(file, 'utf8');
   } catch (error) {
     return {
       exitCode: 1,
       output: `Cannot read guidance file ${file}: ${error.message}\nrun codex-bridge update`,
     };
   }
+  return renderGuidance(text, { root, topic }).then(
+    (output) => ({ exitCode: 0, output }),
+    (error) => ({ exitCode: 1, output: `${error.message}\nrun codex-bridge update` }),
+  );
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lyupro/codex-bridge",
-  "version": "0.6.15",
-  "description": "Claude Code-to-Codex delegation with 8 guards, 3664 tests, zero runtime dependencies, and zero build steps.",
+  "version": "0.6.16",
+  "description": "Claude Code-to-Codex delegation with 8 guards, 4262 tests, zero runtime dependencies, and zero build steps.",
   "keywords": [
     "claude-code",
     "codex",

package/scripts/home-write-inventory.mjs

@@ -46,6 +46,8 @@ export const HOME_WRITE_INVENTORY = Object.freeze([
   outside('src/home/lib/host-version.mjs', 'open', 1, 'Read-only open of a run transcript tail with the r flag.'),
   outside('src/home/lib/load-witness.mjs', 'openSync', 1, 'Read-only open with the r flag, reading at most the shared core byte ceiling plus one sentinel byte (Plan_64 D15 / review B8); all witness state writes use the registered load-witness artifact.'),
   outside('src/home/lib/meta/run-state.mjs', 'writeFileSync', 3, 'Writes status.json and meta.json inside run folders under the runs root.'),
+  outside('src/home/lib/order-text-record.mjs', 'mkdirSync', 2, 'Plan_79 D5/D6/D9 creates the outgoing/parameter journal under CODEX_BRIDGE_TEST_TMP and, only on journal failure, its sibling fault directory outside the throwaway root.'),
+  outside('src/home/lib/order-text-record.mjs', 'appendFileSync', 2, 'Plan_79 D5/D6/D9 appends outgoing/parameter violations under CODEX_BRIDGE_TEST_TMP and, only on journal failure, the same entries plus the error to a sibling fault marker.'),
   outside('src/home/lib/run-codex.mjs', 'appendFileSync', 1, 'Appends a crash diagnostic to stderr.log inside a run folder.'),
   outside('src/home/lib/retention.mjs', 'fs-binding-escape', 1, 'The injected filesystem falls back to fs while cleaning run folders under the runs root, which is operator data outside the home writer even when it is runs/ of the home (Plan_77).'),
   outside('src/home/lib/retention.mjs', 'unlinkSync', 1, 'Removes transport files inside run folders under the runs root, which is operator data outside the home writer even when it is runs/ of the home (Plan_77).'),

package/scripts/run-tests.mjs

@@ -31,6 +31,41 @@ import { auditWrites } from './home-write-audit.mjs';
 import { HOME_WRITE_INVENTORY } from './home-write-inventory.mjs';
 import { readmeText, suiteCountMismatch } from './suite-count.mjs';
 import { snapshotRoot, addedEntries } from './root-guard/root-entries.mjs';
+import { orderTextFaultDirectory } from '../src/home/lib/order-text-record.mjs';
+
+// Plan_79 B5b2b D5/D6: migration is complete, so every journal line is fatal.
+export function inspectOutgoingRefusals(directory, report) {
+  let fatal = 0;
+  if (fs.existsSync(directory)) {
+    for (const file of fs.readdirSync(directory)) {
+      const lines = fs.readFileSync(path.join(directory, file), 'utf8').split(/\r?\n/).filter(Boolean);
+      for (const line of lines) {
+        report(`run-tests: refusal text outside the registry: ${line}\n`);
+        fatal++;
+      }
+    }
+  }
+  return fatal;
+}
+
+// Plan_79 D9: a child whose fault exit is expected must still leave runner-visible evidence.
+export function inspectOrderTextFaults(directory, report) {
+  let fatal = 0;
+  if (fs.existsSync(directory)) {
+    for (const file of fs.readdirSync(directory)) {
+      const lines = fs.readFileSync(path.join(directory, file), 'utf8').split(/\r?\n/).filter(Boolean);
+      if (!lines.length) lines.push(`empty fault marker: ${file}`);
+      for (const line of lines) {
+        report(`run-tests: refusal check could not journal: ${line}\n`);
+        fatal++;
+      }
+    }
+  }
+  return fatal;
+}
+
+// Importing the journal checker in isolated tests must not launch another suite.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
 
 // One pattern only: on 2026-09-25 three files passed as three arguments ran just the first, and a
 // verification reported green for two files it never touched. Refuse before any root is created.
@@ -76,6 +111,13 @@ try {
   });
   const additions = addedEntries(before, snapshotRoot(repositoryRoot));
   process.exitCode = result.status ?? 1;
+  // Plan_79 D5: inspect before cleanup, even when every expected refusal test passed.
+  const refusalJournal = path.join(testTmpRoot, 'order-text-violations');
+  const fatalRefusals = inspectOutgoingRefusals(refusalJournal,
+    (line) => process.stderr.write(line));
+  const fatalFaults = inspectOrderTextFaults(orderTextFaultDirectory(testTmpRoot),
+    (line) => process.stderr.write(line));
+  if ((fatalRefusals || fatalFaults) && process.exitCode === 0) process.exitCode = 1;
   for (const name of additions) {
     process.stderr.write(`run-tests: the suite left ${name} in the repository root (or something else created it while the suite ran)\n`);
   }
@@ -96,5 +138,7 @@ try {
 } finally {
   for (const [, directory] of created) fs.rmSync(directory, { recursive: true, force: true });
   fs.rmSync(testTmpRoot, { recursive: true, force: true });
+  fs.rmSync(orderTextFaultDirectory(testTmpRoot), { recursive: true, force: true });
   if (tapFile) fs.rmSync(path.dirname(tapFile), { recursive: true, force: true });
 }
+}

package/src/claude/rules/core.md

@@ -9,10 +9,11 @@ code: a `scope` phase, then `advise`).
 
 - The call is one line, `task file: <absolute path>`. Labels go in the task-file header, free text in its body. A
   refused call costs nothing: read the refusal, fix the task file, call again.
-- Before writing a task file, run `codex-bridge guidance <topic>` and follow it: `order` (header labels, scope),
-  `advisor` (two phases, the `continue:` grant), `budget` (run deadline, slicing), `records` (finding and reading
-  runs), `concurrency` (parallel and writing runs). `codex-bridge guidance` lists the topics. If it fails, stop and
-  show its output to the operator — never guess the contract.
+- Before every task file, run `codex-bridge guidance order` and follow it: it lists the enforced rules.
+  Other topics, via `codex-bridge guidance <topic>`: `advisor` (two phases, the `continue:` grant),
+  `budget` (run deadline, slicing), `records` (finding and reading runs), `concurrency` (parallel and writing
+  runs); `codex-bridge guidance` lists them. If it fails, stop and show its output to the operator — never guess
+  the contract.
 - Every `codex-build` task file carries exactly one `advice:` line.
 - A writing run has a hard deadline: slice the task before the launch, not after a failure. After a deadline `FAIL`,
   look at `git status` before deciding anything.

package/src/home/guidance/order.md

@@ -4,14 +4,11 @@ Write a task file that gives each dispatcher the complete order and the build's
 ## Call and header
 
 The call is exactly one line: `task file: <task-file path from the orchestrator>`.
-The path must be absolute and name a file the orchestrator wrote with its file tool.
 The dispatcher never creates, reads or rewrites it. The whole order lives in that file's header.
 The runner checks the header, never the dispatcher. Free text belongs in the task file.
 
 Start at the first line with consecutive lowercase `label: value` lines, then a blank line and the task body.
-Labels must use their exact spelling, start at column one and have a non-empty value; duplicates are refused.
 The header ends at the first line that is not a recognized label line, including a blank line.
-Do not put grants or advice below the header, even in a code fence; quote examples with `>` or reword them inside a sentence.
 
 | Agent | Required labels | Conditional labels | Optional labels |
 | --- | --- | --- | --- |
@@ -20,22 +17,20 @@ Do not put grants or advice below the header, even in a code fence; quote exampl
 | codex-review | `order id` | `continue`, `retry` | `repository`, `slug`, `effort`, `changeset` |
 | codex-advisor | `order id`, `phase` | `continue`, `retry` | `repository`, `slug`, `effort` |
 
-Both grant labels are conditional when this pass continues or repeats a named run. Keep exactly one grant label:
-`continue` names the continued run; `retry` repeats a failed pass and does not authorize the next pass.
-Each value names a bare run folder (not a path, `.` or `..`) and a non-placeholder reason, separated by ` — `, ` - ` or `:`.
+Both grant labels are conditional when this pass continues or repeats a named run: `continue` names the continued run; `retry` repeats a failed pass and does not authorize the next pass.
 For advisor, pass `scope` first, then `advise` with a `continue:` grant naming the scope run of the same order.
 
 `repository` is the repository path; `slug` names this pass without replacing the order id.
 The runner checks accepted `effort` values. `changeset` is `uncommitted`, `base:<branch>` or `commit:<sha>`.
-Keep header values short and free of forbidden shell sequences. Empty or placeholder values are refused;
-`phase: scope` and `effort: none` are real values.
+Forbidden shell sequences are {{shell-unsafe-sequences}}.
+`phase: scope` and `effort: none` are real values, not placeholders.
 
 ## File boundary
 
 `scope`: Comma-separated globs relative to the repository root, listing every file the run may touch — including each caller of what changes, not only the file being edited. Anything outside the list fails the run.
 
 `scope new`: Comma-separated globs for new files this build may create, relative to the repository root.
-`scope` must declare at least one existing path pattern; `scope new` does not replace it.
+Paths listed in `scope new` are already inside the run's boundary, so they are not repeated in `scope`.
 <!-- service-folders:begin -->
 Never name service folders in scope: `.git/`, `.claude/`, `.codex/`, `.omx/`, `.omc/`, `node_modules/`.
 <!-- service-folders:end -->
@@ -52,15 +47,19 @@ advice: docs-only
 
 ## Advice
 
-Every build task header contains exactly one `advice:` line. Its value is an absolute path to an existing run folder
-whose `meta.json` identifies a `codex-advisor` advise pass with status `OK`, or exactly `mechanical`, `revert`,
-`docs-only`, or `test-only`. Anything else is refused before the run starts.
+Every build task header contains exactly one `advice:` line.
 
 ## Verify
 
-Put the verification command in the task file under a `## Verify` heading, one line.
+Put the verification command in the task file under a `## Verify` heading.
 The dispatcher never reads that file and never puts the command on the command line.
 
+## Rules the runner enforces
+
+These are the rules a pre-start refusal names.
+
+{{order-rules:all}}
+
 ## Free refusals
 
 A pre-start refusal creates no run folder and spends no quota; the same order id remains reusable for the corrected order.

package/src/home/guidance/records.md

@@ -16,10 +16,12 @@ A started run records its lifecycle and output in its run folder:
 
 - `meta.json`: agent, phase and final status; use it to identify an advisor advise pass before citing it in `advice:`.
 - `status.json`: lifecycle state (`running`, `finished`, `failed` or `abandoned`) and runner PID.
+- `task.md`: the task the runner assembled for the executor, not a byte copy of the orchestrator's task file.
 - `result.json`: structured scout, build or advisor result; build includes `summary`, `changes`, `verify_command`, `verify_passed`, `leftovers` and `report_markdown`.
-- `review.json`: the review agent's structured result instead of `result.json`.
+- `review.json`: the review agent's structured result instead of `result.json`. {{review-required-fields}}.
 - `report.md`: the full report; the runner expands a build result's `report_markdown` into this file.
 - `events.jsonl` and `stderr.log`: transport evidence for progress, deadline or startup failures.
+- `raw.log`: transport evidence when present; retention may remove it.
 
 A failed or interrupted run may have no complete result. Read the recorded status and available evidence rather than treating a missing report as an empty successful run.
 

package/src/home/hooks/dispatcher-gate.mjs

@@ -20,14 +20,20 @@ import {
 } from '../lib/dispatcher-state.mjs';
 import { recordInterceptedAttempt, witnessHostVersion } from '../lib/handback-witness.mjs';
 import { observeSessionHost } from '../lib/host-observations.mjs';
+import { orderDiagnosticMessage } from '../lib/order-diagnostics.mjs';
+import { checkOutgoingRefusal } from '../lib/order-text-record.mjs';
 
 function emit(decision, toolInput) {
   const hookSpecificOutput = {
     hookEventName: 'PreToolUse',
     permissionDecision: decision.kind,
   };
-  if (decision.kind === 'deny') hookSpecificOutput.permissionDecisionReason = decision.reason;
+  if (decision.kind === 'deny') {
+    checkOutgoingRefusal(decision.reason, 'deny');
+    hookSpecificOutput.permissionDecisionReason = decision.reason;
+  }
   if (decision.kind === 'allow') {
+    checkOutgoingRefusal(decision.message, 'handback');
     hookSpecificOutput.updatedInput = { ...toolInput, message: decision.message };
   }
   process.stdout.write(`${JSON.stringify({ hookSpecificOutput })}\n`);
@@ -93,7 +99,7 @@ async function main() {
     } catch (error) {
       decision = {
         kind: 'deny',
-        reason: `codex-bridge dispatcher gate: internal error: ${errorMessage(error)}`,
+        reason: orderDiagnosticMessage('dispatcher-gate-internal-error', { message: errorMessage(error) }),
       };
     }
 

package/src/home/hooks/order-gate.mjs

@@ -30,6 +30,9 @@ import { runsRoot } from '../lib/runner/runs-root.mjs';
 import { parseTaskDocument } from '../lib/runner/task-file.mjs';
 import { parseTaskHeader, taskHeaderRefusal } from '../lib/task-header.mjs';
 import { envModelProblem } from '../lib/subagent-model-env.mjs';
+import { orderRuleMessage } from '../lib/order-rules.mjs';
+import { orderDiagnosticMessage } from '../lib/order-diagnostics.mjs';
+import { checkOutgoingRefusal } from '../lib/order-text-record.mjs';
 
 const GUARDED = new Set(Object.keys(AGENTS));
 /**
@@ -41,10 +44,15 @@ const SUBAGENT_TOOL_NAMES = new Set(SUBAGENT_TOOLS);
 
 let systemMessage;
 const pass = () => {
-  if (systemMessage) process.stdout.write(JSON.stringify({ systemMessage }));
+  if (systemMessage) {
+    checkOutgoingRefusal(systemMessage, 'system-message');
+    process.stdout.write(JSON.stringify({ systemMessage }));
+  }
   process.exit(0);
 };
 const deny = (reason) => {
+  checkOutgoingRefusal(reason, 'deny');
+  if (systemMessage) checkOutgoingRefusal(systemMessage, 'system-message');
   process.stdout.write(JSON.stringify({
     ...(systemMessage ? { systemMessage } : {}),
     hookSpecificOutput: {
@@ -75,11 +83,8 @@ if (!GUARDED.has(toolInput.subagent_type)) pass();
 // Plan_67 D6: one installed model contract; refuse even matching aliases before prompt exits.
 const agentType = toolInput.subagent_type;
 if (Object.hasOwn(toolInput, 'model')) {
-  deny(
-    "Order gate denied the Agent call because it passes `model`: a dispatcher's model is set in one place, "
-      + `its installed agent file. Call ${agentType} without model. `
-      + 'The run folder was not created; quota was not spent.',
-  );
+  deny([orderRuleMessage('agent-call-model', { agentType }),
+    orderDiagnosticMessage('run-not-created')].join(' '));
 }
 try {
   const hostVersion = await transcriptHostVersion(input.transcript_path).catch(() => null);
@@ -93,9 +98,9 @@ try {
   const latch = modelLatch({ ledger: readDispatcherModel({ stateDir: BRAND_STATE_DIR }), agentType });
   if (latch.active) {
     const { data, at } = latch.violation;
-    systemMessage = `codex-bridge: the last ${agentType} ran on ${data.parsed.join(', ')} `
-      + `while the installed contract pins ${data.pinFamily} (${data.hostVersion ?? 'unknown'}, ${at}); `
-      + 'the cause is outside this call — another hook or the host; run codex-bridge doctor.';
+    systemMessage = orderDiagnosticMessage('dispatcher-model-latch', {
+      agentType, models: data.parsed.join(', '), pinFamily: data.pinFamily, hostVersion: data.hostVersion, at,
+    });
   }
 } catch {
   // D4 (a): a corrupt ledger must not turn a diagnostic warning into a refusal.
@@ -111,11 +116,7 @@ if (typeof toolInput.prompt !== 'string') pass();
 const teammateField = ['name', 'team_name']
   .find((key) => typeof toolInput[key] === 'string' && toolInput[key].trim());
 if (teammateField) {
-  deny(
-    `Order gate denied the Agent call because it passes \`${teammateField}\`: a dispatcher launched as a ` +
-      'teammate escapes the dispatcher gate, whose agent_type becomes the teammate name. Call ' +
-      `${toolInput.subagent_type} with subagent_type only, without name or team_name.`,
-  );
+  deny(orderRuleMessage('agent-call-teammate', { field: teammateField, agentType: toolInput.subagent_type }));
 }
 
 // Plan_76 D1: exact registry labels prevent the scope-new and repository-prose incident of 2026-10-04.
@@ -144,7 +145,7 @@ const headerRefusal = taskHeaderRefusal(parsed);
 if (headerRefusal) deny(headerRefusal);
 const { order, problems } = orderFromHeader(toolInput.subagent_type, parsed);
 if (problems.length) {
-  deny(`${renderOrderProblems(toolInput.subagent_type, problems)}\nThe run folder was not created; quota was not spent.`);
+  deny([renderOrderProblems(toolInput.subagent_type, problems), orderDiagnosticMessage('run-not-created')].join('\n'));
 }
 const orderId = order.get('order id');
 // Plan_63 D9 / OW-054: only a validated header grant reaches the runner's grant rules.

package/src/home/lib/dispatcher-call.mjs

@@ -15,10 +15,12 @@ import {
   isInputPlaceholder,
 } from './order-values.mjs';
 import { firstShellUnsafeSequence } from './shell-unsafe.mjs';
+import { orderRuleMessage } from './order-rules.mjs';
+import { orderDiagnosticMessage } from './order-diagnostics.mjs';
 
 export const TASK_FILE_INPUT = Object.freeze({
   label: 'task file',
-  explanation: 'Absolute path to a file holding the task statement verbatim, written by the orchestrator with its file tool. The dispatcher passes the path to the runner and never creates, reads or rewrites the file: writing it from the shell reintroduces the permission prompt this file channel exists to remove. Given no path, return the refusal.',
+  explanation: orderRuleMessage('dispatcher-task-file-help'),
   example: 'C:/Users/me/AppData/Local/Temp/claude/<session>/scratchpad/task-plan-13.md',
 });
 
@@ -28,7 +30,7 @@ export function callInputsFor(agentType) {
 
 const knownLabels = new Set(ALL_ORDER_LABELS);
 
-const freeTextReason = 'not a `label: value` line; free text belongs in the task file';
+const freeTextReason = orderRuleMessage('dispatcher-call-shape', { violation: 'free-text' });
 
 function normaliseLabel(label) {
   return label.toLowerCase().replace(/^[-*] /, '').replace(/[*`]/g, '')
@@ -51,8 +53,7 @@ function shellRewrittenSequence(value) {
 }
 
 function shellRewrittenReason(label, sequence) {
-  return `label \`${label}\` contains ${JSON.stringify(sequence)}, which the shell rewrites inside double quotes; `
-    + 'write the path with forward slashes and without `$`';
+  return orderRuleMessage('dispatcher-call-shape', { violation: 'rewritten', label, sequence });
 }
 
 /** Returns the accepted label values and every refusal; one reader for the gate, the command and the transcript. */
@@ -64,7 +65,7 @@ export function parseDispatcherCall(agentType, promptText) {
   const acceptedLines = new Map();
 
   if (!ORDER_AGENTS.includes(agentType)) {
-    problems.push({ line: null, text: '', reason: `unknown dispatcher agent ${JSON.stringify(agentType)}` });
+    problems.push({ line: null, text: '', reason: orderDiagnosticMessage('dispatcher-agent-input-known', { agentType }) });
     return { inputs, problems };
   }
 
@@ -78,13 +79,13 @@ export function parseDispatcherCall(agentType, promptText) {
     const value = tail.trim();
 
     if (labels.has(label) && !value) {
-      problems.push({ line, text, reason: `label \`${label}\` has an empty value` });
+      problems.push({ line, text, reason: orderRuleMessage('dispatcher-call-shape', { violation: 'empty', label }) });
       return;
     }
     if (labels.has(label) && /^[ \t]+/.test(tail)) {
       if (inputs.has(label)) {
         const first = acceptedLines.get(label).line;
-        problems.push({ line, text, reason: `label \`${label}\` is given twice (line ${first} and line ${line})` });
+        problems.push({ line, text, reason: orderRuleMessage('dispatcher-call-shape', { violation: 'duplicate', label, first, line }) });
         return;
       }
       inputs.set(label, value);
@@ -95,29 +96,30 @@ export function parseDispatcherCall(agentType, promptText) {
     const normalised = label === null ? null : normaliseLabel(label);
     let reason = freeTextReason;
     if (labels.has(normalised)) {
-      reason = `write the label exactly as \`${normalised}:\``;
+      reason = orderRuleMessage('dispatcher-call-shape', { violation: 'spelling', label: normalised });
     } else if (knownLabels.has(normalised)) {
-      reason = `label \`${normalised}\` moved to the task-file header; the call is only \`task file: <absolute path>\``;
+      reason = orderRuleMessage('dispatcher-call-shape', { violation: 'header', label: normalised });
     }
     problems.push({ line, text, reason });
   });
 
   for (const entry of entries) {
     if (!entry.conditional && !entry.optional && !inputs.has(entry.label)) {
-      problems.push({ line: null, text: '', label: entry.label, reason: `missing required label \`${entry.label}\`` });
+      problems.push({ line: null, text: '', label: entry.label,
+        reason: orderRuleMessage('dispatcher-call-shape', { violation: 'missing', label: entry.label }) });
     }
   }
   for (const [label, value] of inputs) {
     const location = acceptedLines.get(label);
     if (isInputPlaceholder(value, label)) {
-      problems.push({ ...location, reason: `label \`${label}\` is still a placeholder` });
+      problems.push({ ...location, reason: orderRuleMessage('dispatcher-call-shape', { violation: 'placeholder', label }) });
     }
     if (label === 'task file' && !isAbsoluteTaskFilePath(value)) {
-      problems.push({ ...location, reason: 'label `task file` must be an absolute path' });
+      problems.push({ ...location, reason: orderRuleMessage('dispatcher-call-shape', { violation: 'absolute' }) });
     }
     const sequence = unsafeSequence(value);
     if (sequence !== null) {
-      const reason = `label \`${label}\` contains ${JSON.stringify(sequence)}; put free text in the task file`;
+      const reason = orderRuleMessage('dispatcher-call-shape', { violation: 'unsafe', label, sequence });
       problems.push({ ...location, reason });
     } else {
       const expanding = shellRewrittenSequence(value);
@@ -129,17 +131,20 @@ export function parseDispatcherCall(agentType, promptText) {
 
 /** Names each refused line and the agent's header template, so one free refusal carries its own repair. */
 export function renderCallRefusal(agentType, problems) {
-  const lines = ['Order gate denied the Agent call: the call text must be only `label: value` lines.'];
+  const lines = [orderRuleMessage('dispatcher-call-refusal', { part: 'intro' })];
   const entries = callInputsFor(agentType);
   for (const { line, text, reason, label } of problems) {
-    const entry = line === null && reason === `missing required label \`${label}\``
+    const entry = line === null && reason === orderRuleMessage('dispatcher-call-shape', { violation: 'missing', label })
       ? entries.find((entry) => entry.label === label) : undefined;
-    const detail = entry ? ` — ${entry.explanation} Example: \`${entry.label}: ${entry.example}\`.` : '';
-    lines.push(line === null ? `- ${reason}${detail}` : `- line ${line}: \`${text}\` — ${reason}`);
+    const detail = entry ? orderRuleMessage('dispatcher-call-refusal', {
+      part: 'detail', explanation: entry.explanation, label: entry.label, example: entry.example,
+    }) : '';
+    lines.push(line === null ? orderRuleMessage('dispatcher-call-refusal', { part: 'problem', reason, detail })
+      : orderRuleMessage('dispatcher-call-refusal', { part: 'line', line, text, reason }));
   }
-  lines.push('The call is only `task file: <absolute path>`.',
-    'The order goes in the header at the top of that file:',
-    ...renderOrderHeaderHelp(agentType).split('\n'), 'Free text belongs in the task file.');
+  lines.push(orderRuleMessage('dispatcher-call-refusal', { part: 'call' }),
+    orderRuleMessage('dispatcher-call-refusal', { part: 'header' }),
+    ...renderOrderHeaderHelp(agentType).split('\n'), orderRuleMessage('dispatcher-call-refusal', { part: 'free-text' }));
   return lines.join('\n');
 }
 
@@ -159,13 +164,11 @@ function conditionFor(entry) {
 
 /** Keeps the caller's short prompt aligned with the header registry, including grant conditions. */
 export function renderRequiredInputSummary(agentType) {
-  if (!ORDER_AGENTS.includes(agentType)) return '';
+  if (!ORDER_AGENTS.includes(agentType)) return orderRuleMessage('dispatcher-call-summary', { variant: 'unknown-agent' });
   const entries = headerInputsFor(agentType);
   const required = entries.filter(({ required }) => required).map(({ label }) => `\`${label}\``);
   const conditional = entries.filter(({ conditional }) => conditional)
     .map((entry) => `\`${entry.label}\` (${conditionFor(entry)})`);
   const optional = entries.filter(({ optional }) => optional).map(({ label }) => `\`${label}\``);
-  return `The call is only \`task file\` (an absolute path). The task-file header requires ${required.join(', ')}; `
-    + `conditional labels: ${conditional.join(', ')}; optional labels: ${optional.join(', ')}. `
-    + 'Free text belongs in the task file.';
+  return orderRuleMessage('dispatcher-call-summary', { variant: 'labels', required, conditional, optional });
 }