@sublang/playbook 12.1.0 → 12.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sublang/playbook",
-  "version": "12.1.0",
+  "version": "12.2.1",
   "type": "module",
   "description": "Composable XState v5 playbook runtime with compiled Captain, CODE, REVIEW, DECIDE, and DEV workflows driven by GEARS specs.",
   "license": "Apache-2.0",

package/reference/sdlc/code.playbook/playbook-captain.js

@@ -64,6 +64,10 @@ const ROLE_ID_PATTERN = /^[a-z][a-z0-9_-]*$/;
 const HOST_CAPABILITIES_OPTION_KEY = 'hostCapabilities';
 const UNRESOLVED_EFFECT_RECONCILIATION_ACTION_ID = 'reconcile:unresolved-effect';
 const UNRESOLVED_EFFECT_ABANDONMENT_ACTION_ID = 'abandon:unresolved-effect';
+// The fixed machine-syntax guard of a player's Boss-question suspension
+// (slc/link.md §Boss-reply suspension): the accepted outcome that parks on
+// Boss rather than sparing Boss a relay.
+const BOSS_QUESTION_OUTCOME = 'needsBossReply';
 const RESUMPTION_DUPLICATE_EFFECT_WARNING = 'Warning: resumption may duplicate external effects attempted after the retained boundary; verify the current world before continuing.';
 function parseRegisteredCommand(prompt) {
     const match = /^\/([A-Za-z][A-Za-z0-9_-]*)(?:\s+([\s\S]*))?$/.exec(prompt.trim());
@@ -2550,6 +2554,12 @@ export function createPlaybookCaptainShell(options, deps = {}) {
         if (summary.acceptedOutcomeTraceKeys.has(traceKey))
             return;
         summary.acceptedOutcomeTraceKeys.add(traceKey);
+        // CAPTAIN-19/20: a saved interruption is a player reply Boss did not
+        // have to relay. A Boss-question suspension is the one accepted outcome
+        // that parks on Boss instead, so it saves nothing and counts nothing —
+        // a turn that only parked must not claim it saved an interruption.
+        if (receipt.acceptedOutcome === BOSS_QUESTION_OUTCOME)
+            return;
         summary.counts.interruptions++;
         if (frame.entry.summaryPolicy?.copyPasteGuardNames.includes(receipt.acceptedOutcome)) {
             summary.counts.copyPastes++;

package/reference/sdlc/code.playbook/playbook-captain.ts

@@ -554,6 +554,10 @@ const HOST_CAPABILITIES_OPTION_KEY = 'hostCapabilities';
 const UNRESOLVED_EFFECT_RECONCILIATION_ACTION_ID =
   'reconcile:unresolved-effect';
 const UNRESOLVED_EFFECT_ABANDONMENT_ACTION_ID = 'abandon:unresolved-effect';
+// The fixed machine-syntax guard of a player's Boss-question suspension
+// (slc/link.md §Boss-reply suspension): the accepted outcome that parks on
+// Boss rather than sparing Boss a relay.
+const BOSS_QUESTION_OUTCOME = 'needsBossReply';
 const RESUMPTION_DUPLICATE_EFFECT_WARNING =
   'Warning: resumption may duplicate external effects attempted after the retained boundary; verify the current world before continuing.';
 
@@ -4293,6 +4297,11 @@ export function createPlaybookCaptainShell(
     const traceKey = `${frame.sessionId}:${trace.sequence}`;
     if (summary.acceptedOutcomeTraceKeys.has(traceKey)) return;
     summary.acceptedOutcomeTraceKeys.add(traceKey);
+    // CAPTAIN-19/20: a saved interruption is a player reply Boss did not
+    // have to relay. A Boss-question suspension is the one accepted outcome
+    // that parks on Boss instead, so it saves nothing and counts nothing —
+    // a turn that only parked must not claim it saved an interruption.
+    if (receipt.acceptedOutcome === BOSS_QUESTION_OUTCOME) return;
     summary.counts.interruptions++;
     if (
       frame.entry.summaryPolicy?.copyPasteGuardNames.includes(

package/reference/sdlc/decide.playbook/decide.playbook.js

@@ -19,7 +19,7 @@ import { randomUUID } from 'node:crypto';
 import PQueue from 'p-queue';
 import { createActor, fromPromise } from 'xstate';
 import { createAcceptedOutcomeConsumer, } from '../../../src/accepted-outcome.js';
-import { assertJsonSafe, assertPlaybookEffectLedger, assertPlaybookRuntimeSnapshot, combineAbortSignals, createNestedPlaybookBridge, detachPersistedMachineSnapshot, normalizeError, normalizePlaybookSnapshot, PlaybookSemanticCandidateStructureError, reconcilePlaybookSemanticEvidence, snapshotJsonValue, snapshotPlaybookSession, validatePlayerResult, waitForPlaybookQuiescence, } from '../../../src/xstate-runtime.js';
+import { assertJsonSafe, assertPlaybookEffectLedger, assertPlaybookRuntimeSnapshot, combineAbortSignals, createNestedPlaybookBridge, detachPersistedMachineSnapshot, normalizeError, normalizePlaybookSnapshot, PlaybookSemanticCandidateStructureError, reconcilePlaybookSemanticEvidence, renderGovernedOutcomeContract, snapshotJsonValue, snapshotPlaybookSession, validatePlayerResult, waitForPlaybookQuiescence, } from '../../../src/xstate-runtime.js';
 import decideMachine from './decide.fsm.js';
 function snapshotDecideRuntimeOptions(value) {
     const captured = snapshotJsonValue(value, 'DECIDE runtime options');
@@ -429,15 +429,19 @@ function buildAdjudicatorPrompt(input, playerOutput, correction) {
     lines.push('"""');
     lines.push('');
     lines.push('Guards (choose exactly one; the descriptions are authoritative and must be applied as written):');
+    // The shared engine's renderer (slc/link.md §Captain adjudication): each
+    // arm's meaning verbatim, with its `Output shall include` clause — authored
+    // for the complete actor output — replaced by the reply contract the
+    // outcome authority gives the judge. Rendering the clause verbatim asked
+    // the judge for presentation-owned `coderProposal` or `question`, which the
+    // reconciler rejects, spending the single correction on a self-inflicted
+    // defect.
     for (const [guard, description] of Object.entries(input.result)) {
-        const semanticFields = Object.entries(outcomes[guard]?.fields ?? {})
-            .filter(([, authority]) => authority === 'semantic')
-            .map(([field]) => field);
-        lines.push(`- ${guard}: semantic fields: ${semanticFields.length === 0 ? '(none)' : semanticFields.join(', ')}; ${description}`);
+        lines.push(...renderGovernedOutcomeContract(guard, description, outcomes[guard]));
     }
     lines.push('');
-    lines.push('Reply with exactly the chosen `guard` and every semantic-owned field for that guard, and no other field.');
-    lines.push('Do not include presentation-, effect-, or runtime-owned fields; the runtime supplies those from authoritative evidence.');
+    lines.push("Pick exactly one declared `guard` and reply with exactly that outcome's reply shape above: `guard` plus its semantic-owned fields and nothing else.");
+    lines.push('A field listed as runtime-supplied is owned by presentation, effect, or runtime evidence; the runtime fills it itself, and a reply that includes one is structurally invalid.');
     if (correction !== undefined) {
         lines.push('');
         lines.push('Your first reply was structurally invalid:');

package/reference/sdlc/decide.playbook/decide.playbook.ts

@@ -38,6 +38,7 @@ import {
   normalizePlaybookSnapshot,
   PlaybookSemanticCandidateStructureError,
   reconcilePlaybookSemanticEvidence,
+  renderGovernedOutcomeContract,
   snapshotJsonValue,
   snapshotPlaybookSession,
   validatePlayerResult,
@@ -660,22 +661,24 @@ function buildAdjudicatorPrompt(
   lines.push(
     'Guards (choose exactly one; the descriptions are authoritative and must be applied as written):',
   );
+  // The shared engine's renderer (slc/link.md §Captain adjudication): each
+  // arm's meaning verbatim, with its `Output shall include` clause — authored
+  // for the complete actor output — replaced by the reply contract the
+  // outcome authority gives the judge. Rendering the clause verbatim asked
+  // the judge for presentation-owned `coderProposal` or `question`, which the
+  // reconciler rejects, spending the single correction on a self-inflicted
+  // defect.
   for (const [guard, description] of Object.entries(input.result)) {
-    const semanticFields = Object.entries(outcomes[guard]?.fields ?? {})
-      .filter(([, authority]) => authority === 'semantic')
-      .map(([field]) => field);
     lines.push(
-      `- ${guard}: semantic fields: ${
-        semanticFields.length === 0 ? '(none)' : semanticFields.join(', ')
-      }; ${description}`,
+      ...renderGovernedOutcomeContract(guard, description, outcomes[guard]),
     );
   }
   lines.push('');
   lines.push(
-    'Reply with exactly the chosen `guard` and every semantic-owned field for that guard, and no other field.',
+    "Pick exactly one declared `guard` and reply with exactly that outcome's reply shape above: `guard` plus its semantic-owned fields and nothing else.",
   );
   lines.push(
-    'Do not include presentation-, effect-, or runtime-owned fields; the runtime supplies those from authoritative evidence.',
+    'A field listed as runtime-supplied is owned by presentation, effect, or runtime evidence; the runtime fills it itself, and a reply that includes one is structurally invalid.',
   );
   if (correction !== undefined) {
     lines.push('');

package/slc/gears2fsm.md

@@ -385,6 +385,9 @@ implementation.
 
 A literal call shall retain the existing representation: `playbookId` is the
 literal target and `text` is the composed GEARS blockquote.
+Composing that text follows the quoted-relay rules of [link](link.md): a
+relayed value that is empty contributes no line, a multi-line value is quoted
+line by line, and the composer inserts no empty quoted line of its own.
 
 A dynamic call written
 ``Captain shall call playbook selected by `<target-field>`:`` shall declare the

package/slc/link.md

@@ -1079,6 +1079,15 @@ runtime-owned payload field; `guard` shall name exactly one outcome declared
 by both the live result map and `outcomeAuthority`; and every semantic-owned
 field shall satisfy the result map's required-field type before any actor
 output is delivered.
+The judge prompt shall render each governed outcome's description with its
+meaning verbatim and its `Output shall include` clause replaced by that reply
+contract — exactly `guard` plus the semantic-owned fields, each keeping its
+authored placeholder or guidance, with every presentation-, effect-, or
+runtime-owned field named as runtime-supplied to omit — so the judge is never asked for a
+field it does not own; the artifact's description text stays unchanged.
+The shared engine shall export that rendering as `renderGovernedOutcomeContract`
+on `@sublang/playbook/xstate-runtime`, and a bespoke linked runtime shall
+render its judge prompt through it rather than restate the contract.
 The reconciler shall construct the complete actor output rather than accept a
 cross-authority object from the judge: every presentation-owned payload field
 shall receive the canonical `finalText.trim()` value; every effect-owned
@@ -1170,7 +1179,9 @@ Two default adjudication strategies, in selection order:
   to decide only from the supplied actor output and declared outcomes, and
   require exactly one JSON object with no prose. The judge prompt shall not
   interpret the player's output, paraphrase it, or alter the FSM's `result`
-  text — it carries the description verbatim.
+  text — it carries the description verbatim, except that a governed
+  schema-3 outcome's `Output shall include` clause is rendered as the
+  authority-derived reply contract of §Captain adjudication.
 - **Marker-parse** (delegated-player alternative): a deterministic parser that
   scans the player output for a terminal control line such as
   `FSM-RESULT: { "guard": "...", ... }`. Useful when player adapters can
@@ -2402,6 +2413,10 @@ original template. Replacement strings are literal: placeholder-looking text
 inside Boss/catalog/plan/result values and JavaScript replacement tokens such
 as `$&`, `$$`, dollar-backtick, and `$'` shall not be interpreted or
 substituted again.
+A quoted relay line `> <placeholder>` whose value is empty shall be omitted
+from the composed text rather than left as an empty quoted line, a multi-line
+value shall be quoted line by line so every continuation line keeps its `>`
+marker, and the composer shall insert no empty quoted line of its own.
 
 ## Host adaptation (informative, not normative)
 

package/slc/text2gears.md

@@ -145,6 +145,11 @@ The guard name shall match the ASCII identifier pattern
 The bullet order is authoritative, guard names are unique within the item, and
 the description shall name every required output property with its exact
 case-sensitive identifier.
+An output property name shall match the same ASCII identifier pattern as a
+guard name: a kebab-case Source placeholder such as `<coder-output>` names the
+property `coderOutput` through the canonical kebab-token-to-camel-field mapping
+of [link](link.md), never a quoted kebab-case key, because downstream artifacts
+and calling playbooks consume these properties by name.
 
 A produced value consumed later shall have a declared producer: where any
 later item's blockquote reads a value through a `<placeholder>`, the item
@@ -242,6 +247,12 @@ text2gears shall emit an item whose behavior uses
 complete JSON-safe input-text template for that call.
 The literal target id shall be a stable configured playbook id, not a slash
 command or module specifier.
+A nested-call item shall carry no `Results:` label: the child's terminal result
+is its outcome, so Source's continuation after child success, abort, or failure
+stays as prose after the blockquote for
+[gears2fsm](gears2fsm.md#nested-playbook-calls) to route through
+`invoke.onDone` and `invoke.onError`; a `Results:` block on a nested-call item
+is malformed.
 
 Example:
 
@@ -323,6 +334,7 @@ exact English form regardless of Source language.
 A Source may itself be the normative specification of a transformation — e.g., a compiler phase definition, as when a meta pipeline compiles this file.
 Such a Source declares no roles and prompts none; Captain performs the specified transformation on request.
 Where such a Source carries a `## Compiled execution` section, text2gears shall compile it from that section alone: the section is the Source's complete behavior — its acting item, prompt, and `Results:` contract — and the remaining definition text is relayed content, not behaviors to transcribe, so the composition below applies only to a Source without that section.
+That section's blockquote is complete as authored: text2gears shall emit it verbatim and shall append no relay line to it — the `<definition>` placeholder is its only runtime value, and the undelivered-value rule above does not add `<boss-intent>` or any other placeholder to it.
 Compose Captain-acting spec items for it: when a transformation request names the specification's source and target, Captain shall carry out the transformation as specified.
 Prompts shall carry the specification's normative requirements as instructions to Captain — deduplicated, one point per line — without inventing roles, triggers, or requirements the specification does not state.
 

package/src/xstate-playbook-runtime.d.ts

@@ -412,6 +412,21 @@ export declare function defaultComposeCaptainPrompt(input: PlaybookCaptainInput,
 export declare function defaultExtractRequiredFields(description: string): string[];
 /** Default delegated-player adjudicator prompt. */
 export declare function defaultBuildJudgePrompt(input: PlaybookPlayerInput, finalText: string): string;
+/**
+ * Judge-facing rendering of one governed outcome (DR-040 §1). The artifact's
+ * description is not altered: its meaning is carried through verbatim, while
+ * its `Output shall include` clause — authored for the complete actor output
+ * — is replaced by the reply contract `outcomeAuthority` gives the judge:
+ * exactly `guard` plus the outcome's semantic-owned fields, each keeping the
+ * placeholder or guidance the clause authors for it, and every
+ * presentation-, effect-, or runtime-owned field named as runtime-supplied
+ * so the judge omits it. Rendering the clause verbatim asked the judge for
+ * `question`, `planningResult`, or `evaluatedRevision`, which the reconciler
+ * rejects as a structural error, spending the single correction on a
+ * self-inflicted defect. Exported so a bespoke linked runtime (DECIDE's
+ * parallel machinery) renders the identical contract instead of restating it.
+ */
+export declare function renderGovernedOutcomeContract(guard: string, description: string, outcome: XStateGovernedOutcomeSpec | undefined): string[];
 export interface PlayerAdjudicationSpec {
     buildJudgePrompt?: (input: PlaybookPlayerInput, finalText: string) => string;
     extractRequiredFields?: (description: string) => string[];

package/src/xstate-playbook-runtime.js

@@ -568,6 +568,30 @@ export function defaultComposeCaptainPrompt(input, placeholderFields = {}) {
     blocks.push(body);
     return blocks.join('\n\n');
 }
+// A result description's output clause (slc/link.md §Captain adjudication):
+// everything after `Output shall include` / `输出应包含` names the outcome's
+// payload fields, each as a bare backticked name or the annotated
+// `name: <placeholder>` form. The text before the clause is the outcome's
+// meaning.
+const OUTPUT_CLAUSE_MARKERS = [
+    'Output shall include',
+    '输出应包含',
+];
+const PAYLOAD_FIELD_PATTERN = /`([A-Za-z_$][A-Za-z0-9_$]*)(?::\s*([^`]*))?`/g;
+// Separators between one field's authored segment and the next field token.
+const SEGMENT_SEPARATOR_SUFFIX = /(?:\s|[,;.，、；。]|\band\b)+$/;
+function splitOutputClause(description) {
+    for (const marker of OUTPUT_CLAUSE_MARKERS) {
+        const idx = description.indexOf(marker);
+        if (idx !== -1) {
+            return {
+                meaning: description.slice(0, idx).trim(),
+                clause: description.slice(idx + marker.length),
+            };
+        }
+    }
+    return { meaning: description.trim() };
+}
 /**
  * Default required-field extraction (slc/link.md §Captain adjudication).
  * Limited to the description's `Output shall include` / `输出应包含` clause;
@@ -575,21 +599,11 @@ export function defaultComposeCaptainPrompt(input, placeholderFields = {}) {
  * form.
  */
 export function defaultExtractRequiredFields(description) {
-    const markers = ['Output shall include', '输出应包含'];
-    let clauseStart = -1;
-    for (const marker of markers) {
-        const idx = description.indexOf(marker);
-        if (idx !== -1) {
-            clauseStart = idx + marker.length;
-            break;
-        }
-    }
-    if (clauseStart === -1)
+    const { clause } = splitOutputClause(description);
+    if (clause === undefined)
         return [];
-    const clause = description.slice(clauseStart);
     const fields = [];
-    const re = /`([A-Za-z_$][A-Za-z0-9_$]*)(?::[^`]*)?`/g;
-    for (const m of clause.matchAll(re))
+    for (const m of clause.matchAll(PAYLOAD_FIELD_PATTERN))
         fields.push(m[1]);
     return fields;
 }
@@ -615,6 +629,71 @@ export function defaultBuildJudgePrompt(input, finalText) {
     }
     return lines.join('\n');
 }
+/**
+ * Judge-facing rendering of one governed outcome (DR-040 §1). The artifact's
+ * description is not altered: its meaning is carried through verbatim, while
+ * its `Output shall include` clause — authored for the complete actor output
+ * — is replaced by the reply contract `outcomeAuthority` gives the judge:
+ * exactly `guard` plus the outcome's semantic-owned fields, each keeping the
+ * placeholder or guidance the clause authors for it, and every
+ * presentation-, effect-, or runtime-owned field named as runtime-supplied
+ * so the judge omits it. Rendering the clause verbatim asked the judge for
+ * `question`, `planningResult`, or `evaluatedRevision`, which the reconciler
+ * rejects as a structural error, spending the single correction on a
+ * self-inflicted defect. Exported so a bespoke linked runtime (DECIDE's
+ * parallel machinery) renders the identical contract instead of restating it.
+ */
+export function renderGovernedOutcomeContract(guard, description, outcome) {
+    const { meaning, clause } = splitOutputClause(description);
+    // Each field's authored segment runs from its token to the next token:
+    // the annotated `name: <placeholder>` form, or the bare name followed by
+    // its guidance (`` `irNumber` identifying the continued IR ``).
+    const authored = new Map();
+    if (clause !== undefined) {
+        const matches = [...clause.matchAll(PAYLOAD_FIELD_PATTERN)];
+        matches.forEach((m, i) => {
+            const field = m[1];
+            if (authored.has(field))
+                return;
+            const start = m.index ?? 0;
+            const end = matches[i + 1]?.index ?? clause.length;
+            const segment = clause
+                .slice(start, end)
+                .replace(SEGMENT_SEPARATOR_SUFFIX, '');
+            const placeholder = m[2]?.trim();
+            authored.set(field, {
+                segment,
+                ...(placeholder !== undefined && placeholder.length > 0
+                    ? { placeholder }
+                    : {}),
+            });
+        });
+    }
+    const replyMembers = [`"guard": ${JSON.stringify(guard)}`];
+    const semanticAsAuthored = [];
+    const runtimeSupplied = [];
+    for (const [field, authority] of Object.entries(outcome?.fields ?? {})) {
+        if (authority === 'semantic') {
+            const entry = authored.get(field);
+            replyMembers.push(`${JSON.stringify(field)}: ${entry?.placeholder ?? '<string>'}`);
+            semanticAsAuthored.push(entry?.segment ?? `\`${field}\``);
+        }
+        else {
+            runtimeSupplied.push(`\`${field}\` (${authority}-owned)`);
+        }
+    }
+    const lines = [
+        meaning.length === 0 ? `- \`${guard}\`` : `- \`${guard}\` — ${meaning}`,
+        `  Reply exactly: { ${replyMembers.join(', ')} }`,
+    ];
+    if (semanticAsAuthored.length > 0) {
+        lines.push(`  Semantic fields as authored: ${semanticAsAuthored.join('; ')}`);
+    }
+    if (runtimeSupplied.length > 0) {
+        lines.push(`  Runtime-supplied, do not include: ${runtimeSupplied.join(', ')}`);
+    }
+    return lines;
+}
 function buildGovernedJudgePrompt(input, finalText, outcomes, correction) {
     const lines = [
         'This is hidden control work. Do not call tools, inspect files, or seek external evidence.',
@@ -627,17 +706,12 @@ function buildGovernedJudgePrompt(input, finalText, outcomes, correction) {
         finalText,
         '```',
         '',
-        'Pick exactly one declared `guard`. Include every semantic-owned field for that guard and no other field.',
-        'Do not include presentation-, effect-, or runtime-owned fields; the runtime supplies those from their authoritative evidence.',
+        'Pick exactly one declared `guard` and reply with exactly that outcome\'s reply shape below: `guard` plus its semantic-owned fields and nothing else.',
+        'A field listed as runtime-supplied is owned by presentation, effect, or runtime evidence; the runtime fills it itself, and a reply that includes one is structurally invalid.',
         '',
     ];
     for (const [guard, description] of Object.entries(input.result)) {
-        const semanticFields = Object.entries(outcomes[guard]?.fields ?? {})
-            .filter(([, authority]) => authority === 'semantic')
-            .map(([field]) => field);
-        lines.push(`- \`${guard}\` — semantic fields: ${semanticFields.length === 0
-            ? '(none)'
-            : semanticFields.map((field) => `\`${field}\``).join(', ')}; ${description}`);
+        lines.push(...renderGovernedOutcomeContract(guard, description, outcomes[guard]));
     }
     if (correction !== undefined) {
         lines.push('', 'Your first reply was structurally invalid:', '', '```', correction.reply, '```', '', `Validation error: ${correction.error}`, 'Correct only that structure using the same player output and outcome schema.');
@@ -2080,9 +2154,24 @@ export function createXStatePlaybookRuntime(machine, spec) {
                 return undefined;
             }
         }
+        // DR-040 §4 parks only an envelope whose evidence proves a repository
+        // delta or cannot exclude one. A standalone boundary whose complete
+        // physical receipt is exactly `unchanged` excludes any effect, so missing
+        // or unresolved semantics over it are an ordinary failure — the FSM's
+        // failure state with its fenced retry — never a parked reconciliation:
+        // that state's only exits, reconcile and abandon, project no effect
+        // evidence from an `unchanged` receipt, so parking it deadlocks the
+        // engagement. A boundary inside a deferred chain is judged by the chain's
+        // cumulative receipt from its original baseline, not by its own step.
+        function boundaryExcludesEffect(boundary) {
+            return (boundary.logicalOperationId === undefined &&
+                boundary.physicalReceipt?.classification === 'unchanged');
+        }
         function boundaryNeedsSemanticReconciliation(candidate, ledger) {
             if (!runtimeBoundaryIsOwned(candidate))
                 return false;
+            if (boundaryExcludesEffect(candidate))
+                return false;
             if (governedOutcomesForBoundary(candidate) === undefined)
                 return true;
             const persisted = persistedBoundaryReconciliation(candidate, ledger);
@@ -3110,7 +3199,11 @@ export function createXStatePlaybookRuntime(machine, spec) {
             if (governedSettlement !== undefined) {
                 governedSettlementsByBoundaryId.delete(boundaryId);
                 governedPlayerSettlements.set(result, governedSettlement);
-                if (governedSettlement.status === 'unresolved') {
+                // An unresolved settlement over an `unchanged` standalone receipt
+                // still throws into the failure state through the player bridge; it
+                // just never becomes an effect-possible envelope.
+                if (governedSettlement.status === 'unresolved' &&
+                    !boundaryExcludesEffect(completed)) {
                     unresolvedSemanticBoundaryIds.add(boundaryId);
                 }
                 else {
@@ -4830,6 +4923,10 @@ export function createXStatePlaybookRuntime(machine, spec) {
                 delivery: deferredValue(),
             };
             activeDeferredContinuation = continuation;
+            // Emissions are buffered only until the host durably starts the
+            // continuation: an exit that starts no player (checkpoint mismatch,
+            // ineligible operation) publishes nothing, so the bound wait it
+            // preserves is never contradicted by a classification line.
             deferInspectionEmissions = true;
             let continuationStarted = false;
             let deliverySettled = false;
@@ -4858,6 +4955,14 @@ export function createXStatePlaybookRuntime(machine, spec) {
                         continuation.playerContinuation = selectedContinuation;
                         continuationStarted = true;
                         actor.send(event);
+                        // The host has durably started this boundary and the FSM has
+                        // moved: publish the buffered classification line and the
+                        // authored transition now, and let every later transition,
+                        // accepted outcome, and status emit inline. Holding them until
+                        // the operation settled put the cause after its effects — the
+                        // player call, the nested call a target state starts, and their
+                        // finishes were traced and sequenced first (PBRT-37).
+                        settleDeferredInspectionBuffer(true);
                         // The invoked player remains gated inside boundary.callPlayer.
                         // Return to the host only after the raw player call settles so it
                         // can capture and persist the receipt before any actor output or

package/src/xstate-playbook-runtime.ts

@@ -1304,6 +1304,36 @@ export function defaultComposeCaptainPrompt(
   return blocks.join('\n\n');
 }
 
+// A result description's output clause (slc/link.md §Captain adjudication):
+// everything after `Output shall include` / `输出应包含` names the outcome's
+// payload fields, each as a bare backticked name or the annotated
+// `name: <placeholder>` form. The text before the clause is the outcome's
+// meaning.
+const OUTPUT_CLAUSE_MARKERS: readonly string[] = [
+  'Output shall include',
+  '输出应包含',
+];
+const PAYLOAD_FIELD_PATTERN =
+  /`([A-Za-z_$][A-Za-z0-9_$]*)(?::\s*([^`]*))?`/g;
+// Separators between one field's authored segment and the next field token.
+const SEGMENT_SEPARATOR_SUFFIX = /(?:\s|[,;.，、；。]|\band\b)+$/;
+
+function splitOutputClause(description: string): {
+  readonly meaning: string;
+  readonly clause?: string;
+} {
+  for (const marker of OUTPUT_CLAUSE_MARKERS) {
+    const idx = description.indexOf(marker);
+    if (idx !== -1) {
+      return {
+        meaning: description.slice(0, idx).trim(),
+        clause: description.slice(idx + marker.length),
+      };
+    }
+  }
+  return { meaning: description.trim() };
+}
+
 /**
  * Default required-field extraction (slc/link.md §Captain adjudication).
  * Limited to the description's `Output shall include` / `输出应包含` clause;
@@ -1311,20 +1341,10 @@ export function defaultComposeCaptainPrompt(
  * form.
  */
 export function defaultExtractRequiredFields(description: string): string[] {
-  const markers = ['Output shall include', '输出应包含'];
-  let clauseStart = -1;
-  for (const marker of markers) {
-    const idx = description.indexOf(marker);
-    if (idx !== -1) {
-      clauseStart = idx + marker.length;
-      break;
-    }
-  }
-  if (clauseStart === -1) return [];
-  const clause = description.slice(clauseStart);
+  const { clause } = splitOutputClause(description);
+  if (clause === undefined) return [];
   const fields: string[] = [];
-  const re = /`([A-Za-z_$][A-Za-z0-9_$]*)(?::[^`]*)?`/g;
-  for (const m of clause.matchAll(re)) fields.push(m[1]);
+  for (const m of clause.matchAll(PAYLOAD_FIELD_PATTERN)) fields.push(m[1]);
   return fields;
 }
 
@@ -1358,6 +1378,83 @@ export function defaultBuildJudgePrompt(
   return lines.join('\n');
 }
 
+/**
+ * Judge-facing rendering of one governed outcome (DR-040 §1). The artifact's
+ * description is not altered: its meaning is carried through verbatim, while
+ * its `Output shall include` clause — authored for the complete actor output
+ * — is replaced by the reply contract `outcomeAuthority` gives the judge:
+ * exactly `guard` plus the outcome's semantic-owned fields, each keeping the
+ * placeholder or guidance the clause authors for it, and every
+ * presentation-, effect-, or runtime-owned field named as runtime-supplied
+ * so the judge omits it. Rendering the clause verbatim asked the judge for
+ * `question`, `planningResult`, or `evaluatedRevision`, which the reconciler
+ * rejects as a structural error, spending the single correction on a
+ * self-inflicted defect. Exported so a bespoke linked runtime (DECIDE's
+ * parallel machinery) renders the identical contract instead of restating it.
+ */
+export function renderGovernedOutcomeContract(
+  guard: string,
+  description: string,
+  outcome: XStateGovernedOutcomeSpec | undefined,
+): string[] {
+  const { meaning, clause } = splitOutputClause(description);
+  // Each field's authored segment runs from its token to the next token:
+  // the annotated `name: <placeholder>` form, or the bare name followed by
+  // its guidance (`` `irNumber` identifying the continued IR ``).
+  const authored = new Map<
+    string,
+    { readonly segment: string; readonly placeholder?: string }
+  >();
+  if (clause !== undefined) {
+    const matches = [...clause.matchAll(PAYLOAD_FIELD_PATTERN)];
+    matches.forEach((m, i) => {
+      const field = m[1];
+      if (authored.has(field)) return;
+      const start = m.index ?? 0;
+      const end = matches[i + 1]?.index ?? clause.length;
+      const segment = clause
+        .slice(start, end)
+        .replace(SEGMENT_SEPARATOR_SUFFIX, '');
+      const placeholder = m[2]?.trim();
+      authored.set(field, {
+        segment,
+        ...(placeholder !== undefined && placeholder.length > 0
+          ? { placeholder }
+          : {}),
+      });
+    });
+  }
+  const replyMembers = [`"guard": ${JSON.stringify(guard)}`];
+  const semanticAsAuthored: string[] = [];
+  const runtimeSupplied: string[] = [];
+  for (const [field, authority] of Object.entries(outcome?.fields ?? {})) {
+    if (authority === 'semantic') {
+      const entry = authored.get(field);
+      replyMembers.push(
+        `${JSON.stringify(field)}: ${entry?.placeholder ?? '<string>'}`,
+      );
+      semanticAsAuthored.push(entry?.segment ?? `\`${field}\``);
+    } else {
+      runtimeSupplied.push(`\`${field}\` (${authority}-owned)`);
+    }
+  }
+  const lines = [
+    meaning.length === 0 ? `- \`${guard}\`` : `- \`${guard}\` — ${meaning}`,
+    `  Reply exactly: { ${replyMembers.join(', ')} }`,
+  ];
+  if (semanticAsAuthored.length > 0) {
+    lines.push(
+      `  Semantic fields as authored: ${semanticAsAuthored.join('; ')}`,
+    );
+  }
+  if (runtimeSupplied.length > 0) {
+    lines.push(
+      `  Runtime-supplied, do not include: ${runtimeSupplied.join(', ')}`,
+    );
+  }
+  return lines;
+}
+
 function buildGovernedJudgePrompt(
   input: PlaybookPlayerInput,
   finalText: string,
@@ -1375,20 +1472,13 @@ function buildGovernedJudgePrompt(
     finalText,
     '```',
     '',
-    'Pick exactly one declared `guard`. Include every semantic-owned field for that guard and no other field.',
-    'Do not include presentation-, effect-, or runtime-owned fields; the runtime supplies those from their authoritative evidence.',
+    'Pick exactly one declared `guard` and reply with exactly that outcome\'s reply shape below: `guard` plus its semantic-owned fields and nothing else.',
+    'A field listed as runtime-supplied is owned by presentation, effect, or runtime evidence; the runtime fills it itself, and a reply that includes one is structurally invalid.',
     '',
   ];
   for (const [guard, description] of Object.entries(input.result)) {
-    const semanticFields = Object.entries(outcomes[guard]?.fields ?? {})
-      .filter(([, authority]) => authority === 'semantic')
-      .map(([field]) => field);
     lines.push(
-      `- \`${guard}\` — semantic fields: ${
-        semanticFields.length === 0
-          ? '(none)'
-          : semanticFields.map((field) => `\`${field}\``).join(', ')
-      }; ${description}`,
+      ...renderGovernedOutcomeContract(guard, description, outcomes[guard]),
     );
   }
   if (correction !== undefined) {
@@ -3480,11 +3570,28 @@ export function createXStatePlaybookRuntime<
       }
     }
 
+    // DR-040 §4 parks only an envelope whose evidence proves a repository
+    // delta or cannot exclude one. A standalone boundary whose complete
+    // physical receipt is exactly `unchanged` excludes any effect, so missing
+    // or unresolved semantics over it are an ordinary failure — the FSM's
+    // failure state with its fenced retry — never a parked reconciliation:
+    // that state's only exits, reconcile and abandon, project no effect
+    // evidence from an `unchanged` receipt, so parking it deadlocks the
+    // engagement. A boundary inside a deferred chain is judged by the chain's
+    // cumulative receipt from its original baseline, not by its own step.
+    function boundaryExcludesEffect(boundary: PlaybookEffectBoundary): boolean {
+      return (
+        boundary.logicalOperationId === undefined &&
+        boundary.physicalReceipt?.classification === 'unchanged'
+      );
+    }
+
     function boundaryNeedsSemanticReconciliation(
       candidate: PlaybookEffectBoundary,
       ledger: PlaybookEffectLedger,
     ): boolean {
       if (!runtimeBoundaryIsOwned(candidate)) return false;
+      if (boundaryExcludesEffect(candidate)) return false;
       if (governedOutcomesForBoundary(candidate) === undefined) return true;
       const persisted = persistedBoundaryReconciliation(candidate, ledger);
       if (persisted !== undefined) {
@@ -5009,7 +5116,13 @@ export function createXStatePlaybookRuntime<
       if (governedSettlement !== undefined) {
         governedSettlementsByBoundaryId.delete(boundaryId);
         governedPlayerSettlements.set(result, governedSettlement);
-        if (governedSettlement.status === 'unresolved') {
+        // An unresolved settlement over an `unchanged` standalone receipt
+        // still throws into the failure state through the player bridge; it
+        // just never becomes an effect-possible envelope.
+        if (
+          governedSettlement.status === 'unresolved' &&
+          !boundaryExcludesEffect(completed)
+        ) {
           unresolvedSemanticBoundaryIds.add(boundaryId);
         } else {
           unresolvedSemanticBoundaryIds.delete(boundaryId);
@@ -7145,6 +7258,10 @@ export function createXStatePlaybookRuntime<
         delivery: deferredValue<PlayerResult>(),
       };
       activeDeferredContinuation = continuation;
+      // Emissions are buffered only until the host durably starts the
+      // continuation: an exit that starts no player (checkpoint mismatch,
+      // ineligible operation) publishes nothing, so the bound wait it
+      // preserves is never contradicted by a classification line.
       deferInspectionEmissions = true;
       let continuationStarted = false;
       let deliverySettled = false;
@@ -7181,6 +7298,14 @@ export function createXStatePlaybookRuntime<
             continuation.playerContinuation = selectedContinuation;
             continuationStarted = true;
             actor!.send(event);
+            // The host has durably started this boundary and the FSM has
+            // moved: publish the buffered classification line and the
+            // authored transition now, and let every later transition,
+            // accepted outcome, and status emit inline. Holding them until
+            // the operation settled put the cause after its effects — the
+            // player call, the nested call a target state starts, and their
+            // finishes were traced and sequenced first (PBRT-37).
+            settleDeferredInspectionBuffer(true);
             // The invoked player remains gated inside boundary.callPlayer.
             // Return to the host only after the raw player call settles so it
             // can capture and persist the receipt before any actor output or