@sublang/playbook 8.0.0 → 10.0.0

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

@@ -16,24 +16,37 @@
 //   Output profile:     bespoke parallel runtime with the shared nested-call
 //                       bridge (slc/link.md §Output)
 
+import { randomUUID } from 'node:crypto';
+
 import PQueue from 'p-queue';
 import { createActor, fromPromise } from 'xstate';
 import type { InspectionEvent, SnapshotFrom } from 'xstate';
 
+import {
+  createAcceptedOutcomeConsumer,
+  type AcceptedOutcomeReceipt,
+} 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 type { NestedPlaybookBridge } from '../../../src/xstate-runtime.js';
+import type {
+  NestedPlaybookBridge,
+  PlaybookSemanticOutcomeSpec,
+} from '../../../src/xstate-runtime.js';
 
 import decideMachine, {
   type PlayerInput,
@@ -44,6 +57,8 @@ import decideMachine, {
   type PlaybookInput,
 } from './decide.fsm.js';
 
+import type { PlaybookHostConstructionCapabilities } from '../code.playbook/playbook-captain.js';
+
 import type {
   CaptainCallOptions,
   CaptainResult,
@@ -58,8 +73,14 @@ import type {
   PlaybookControlAction,
   PlaybookControlReceipt,
   PlaybookControlView,
+  PlaybookEffectBoundary,
+  PlaybookEffectBoundaryStart,
+  PlaybookEffectLedger,
+  PlaybookEffectLedgerCapability,
+  PlaybookPendingBossQuestion,
   PlaybookPendingCall,
   PlaybookPorts,
+  PlaybookRepositoryReceipt,
   PlaybookRunResult,
   PlaybookRuntime,
   PlaybookRuntimeFactory,
@@ -102,6 +123,14 @@ type RoleId = 'coder' | 'reviewer';
 
 export type PlaybookRuntimeOptions = DecideInput;
 
+export type DecidePlaybookHostCapabilities =
+  PlaybookHostConstructionCapabilities;
+
+export interface DecidePlaybookRuntimeConstruction {
+  readonly configuredOptions: PlaybookRuntimeOptions;
+  readonly hostCapabilities: DecidePlaybookHostCapabilities;
+}
+
 function snapshotDecideRuntimeOptions(value: unknown): PlaybookRuntimeOptions {
   const captured = snapshotJsonValue(value, 'DECIDE runtime options');
   if (!isPlainObject(captured)) {
@@ -114,20 +143,51 @@ function snapshotDecideRuntimeOptions(value: unknown): PlaybookRuntimeOptions {
   return Object.freeze({});
 }
 
-const STATE_DESCRIPTIONS: Readonly<Record<string, string>> = {
-  ready: 'Waiting for a topic to decide.',
-  askCoderProposal: 'Coder independently proposes a spec design.',
-  askReviewerProposal: 'Reviewer independently proposes a spec design.',
-  waitCoderProposalReply: 'Coder waits for Boss to answer a question.',
-  waitReviewerProposalReply: 'Reviewer waits for Boss to answer a question.',
-  commitCoderProposal: 'Coder writes and commits Coder’s independent proposal.',
-  awaitBossReply: 'Waiting for Boss to answer Coder’s question.',
-  reviewCommit: 'REVIEW examines the committed proposal.',
-  failed: 'DECIDE failed and is waiting for a new topic.',
-  reportedReviewFailure:
-    'DECIDE reports REVIEW’s failure and its last commit.',
-  done: 'DECIDE completed with an approved commit.',
-};
+interface AuthoredStateConfig {
+  readonly meta?: {
+    readonly playbook?: {
+      readonly stateId?: unknown;
+      readonly description?: unknown;
+    };
+  };
+  readonly states?: Readonly<Record<string, AuthoredStateConfig>>;
+}
+
+function authoredStateDescriptions(
+  states: Readonly<Record<string, AuthoredStateConfig>> | undefined,
+): Readonly<Record<string, string>> {
+  const descriptions: Record<string, string> = {};
+  const visit = (
+    children: Readonly<Record<string, AuthoredStateConfig>> | undefined,
+  ): void => {
+    for (const state of Object.values(children ?? {})) {
+      const stateId = state.meta?.playbook?.stateId;
+      const description = state.meta?.playbook?.description;
+      if (
+        typeof stateId === 'string' &&
+        typeof description === 'string' &&
+        description.trim().length > 0
+      ) {
+        const existing = descriptions[stateId];
+        if (existing !== undefined && existing !== description) {
+          throw new Error(
+            `DECIDE state ${stateId} declares conflicting descriptions`,
+          );
+        }
+        descriptions[stateId] = description;
+      }
+      visit(state.states);
+    }
+  };
+  visit(states);
+  return Object.freeze(descriptions);
+}
+
+const STATE_DESCRIPTIONS = authoredStateDescriptions(
+  decideMachine.config.states as
+    | Readonly<Record<string, AuthoredStateConfig>>
+    | undefined,
+);
 
 const ROLE_STATES = [
   { stateId: 'askCoderProposal', role: 'coder', sourceItem: 'DECIDE-1' },
@@ -143,6 +203,61 @@ const ROLE_STATE_IDS: ReadonlySet<string> = new Set(
   ROLE_STATES.map((state) => state.stateId),
 );
 
+const ACCEPTED_OUTCOME_DECLARATIONS: Readonly<
+  Record<string, ReadonlySet<string>>
+> = Object.freeze({
+  askCoderProposal: new Set(['proposed', 'needsBossReply']),
+  askReviewerProposal: new Set(['proposed', 'needsBossReply']),
+  commitCoderProposal: new Set(['committed', 'needsBossReply']),
+});
+
+const DECIDE_OUTCOME_AUTHORITY = Object.freeze({
+  governedPlayerStates: Object.freeze({
+    askCoderProposal: Object.freeze({
+      proposed: Object.freeze({
+        fields: Object.freeze({ coderProposal: 'presentation' as const }),
+        repositoryDisposition: 'unchanged' as const,
+      }),
+      needsBossReply: Object.freeze({
+        fields: Object.freeze({ question: 'presentation' as const }),
+        repositoryDisposition: 'unchanged' as const,
+      }),
+    }),
+    askReviewerProposal: Object.freeze({
+      proposed: Object.freeze({
+        fields: Object.freeze({ reviewerProposal: 'presentation' as const }),
+        repositoryDisposition: 'unchanged' as const,
+      }),
+      needsBossReply: Object.freeze({
+        fields: Object.freeze({ question: 'presentation' as const }),
+        repositoryDisposition: 'unchanged' as const,
+      }),
+    }),
+    commitCoderProposal: Object.freeze({
+      committed: Object.freeze({
+        fields: Object.freeze({
+          coderOutput: 'presentation' as const,
+          latestCommit: 'effect' as const,
+        }),
+        repositoryDisposition: 'one-descendant-commit' as const,
+      }),
+      needsBossReply: Object.freeze({
+        fields: Object.freeze({ question: 'presentation' as const }),
+        repositoryDisposition: 'deferred' as const,
+      }),
+    }),
+  }),
+}) satisfies {
+  readonly governedPlayerStates: Readonly<
+    Record<string, Readonly<Record<string, PlaybookSemanticOutcomeSpec>>>
+  >;
+};
+
+const PROPOSAL_STATE_BY_ROLE = Object.freeze({
+  coder: 'askCoderProposal',
+  reviewer: 'askReviewerProposal',
+} as const);
+
 const ROLE_IDS = ['coder', 'reviewer'] as const;
 const ROLE_ID_SET: ReadonlySet<string> = new Set(ROLE_IDS);
 
@@ -154,9 +269,16 @@ const BOSS_INTERRUPT_TARGETS = ['independentProposals'] as const;
 const BOSS_INTERRUPT_TARGET_IDS: ReadonlySet<string> = new Set(
   BOSS_INTERRUPT_TARGETS,
 );
+const UNFINISHED_FINAL_STATE_IDS: ReadonlySet<string> = new Set([
+  'reportedReviewFailure',
+]);
 
 const TELEMETRY_TOPIC = 'playbook.fsm.state';
 const TRACE_TOPIC = 'playbook.trace';
+const UNRESOLVED_EFFECT_RECONCILIATION_ACTION_ID =
+  'reconcile:unresolved-effect';
+const UNRESOLVED_EFFECT_ABANDONMENT_ACTION_ID =
+  'abandon:unresolved-effect';
 
 const CONTINUATION_PREAMBLE =
   'You previously paused this task to ask Boss a question; Boss has now replied. Continue the same task using the reply below.';
@@ -230,6 +352,44 @@ function requiredFieldsFor(description: string): string[] {
   return fields;
 }
 
+function governedOutcomesFor(
+  input: PlayerInput,
+): Readonly<Record<string, PlaybookSemanticOutcomeSpec>> {
+  const outcomes = (
+    DECIDE_OUTCOME_AUTHORITY.governedPlayerStates as Readonly<
+      Record<string, Readonly<Record<string, PlaybookSemanticOutcomeSpec>>>
+    >
+  )[input.stateId];
+  if (outcomes === undefined) {
+    throw new TypeError(
+      `DECIDE governed player state ${JSON.stringify(input.stateId)} has no outcome authority`,
+    );
+  }
+  const declaredGuards = Object.keys(outcomes).sort();
+  const authoredGuards = Object.keys(input.result).sort();
+  if (
+    declaredGuards.length !== authoredGuards.length ||
+    declaredGuards.some((guard, index) => guard !== authoredGuards[index])
+  ) {
+    throw new TypeError(
+      `DECIDE governed player state ${input.stateId} changed its authored outcome set`,
+    );
+  }
+  for (const guard of declaredGuards) {
+    const required = requiredFieldsFor(input.result[guard]!).sort();
+    const authoritative = Object.keys(outcomes[guard]!.fields).sort();
+    if (
+      required.length !== authoritative.length ||
+      required.some((field, index) => field !== authoritative[index])
+    ) {
+      throw new TypeError(
+        `DECIDE governed outcome ${input.stateId}.${guard} changed its payload fields`,
+      );
+    }
+  }
+  return outcomes;
+}
+
 // LLM judges routinely wrap JSON in prose/fences or damage its tail. Match
 // CODE's recovery contract: scan candidate starts in document order, prefer a
 // strict balanced value at each position, then repair trailing commas and
@@ -298,6 +458,14 @@ function stableJson(value: unknown, path: string): string {
   return JSON.stringify(sortJson(snapshotJsonValue(value, path)));
 }
 
+function deepFreeze<T>(value: T): T {
+  if (value !== null && typeof value === 'object' && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const member of Object.values(value)) deepFreeze(member);
+  }
+  return value;
+}
+
 function stripCodeFence(text: string): string {
   const fence = text.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```$/i);
   return fence ? fence[1].trim() : text;
@@ -461,7 +629,9 @@ function parseClassification(
 function buildAdjudicatorPrompt(
   input: PlayerInput,
   playerOutput: string,
+  correction?: { readonly reply: string; readonly error: string },
 ): string {
+  const outcomes = governedOutcomesFor(input);
   const lines: string[] = [];
   lines.push('You are the guard adjudicator for a playbook state machine.');
   lines.push(
@@ -483,72 +653,44 @@ function buildAdjudicatorPrompt(
     'Guards (choose exactly one; the descriptions are authoritative and must be applied as written):',
   );
   for (const [guard, description] of Object.entries(input.result)) {
-    lines.push(`- ${guard}: ${description}`);
-  }
-  const runtimeOwnedFields = new Set<string>();
-  for (const description of Object.values(input.result)) {
-    for (const field of requiredFieldsFor(description)) {
-      if (VERBATIM_PAYLOAD_FIELDS.has(field)) runtimeOwnedFields.add(field);
-    }
-  }
-  if (runtimeOwnedFields.size > 0) {
-    lines.push('');
+    const semanticFields = Object.entries(outcomes[guard]?.fields ?? {})
+      .filter(([, authority]) => authority === 'semantic')
+      .map(([field]) => field);
     lines.push(
-      `The runtime owns these verbatim fields; do not include them in your JSON: ${[...runtimeOwnedFields].join(', ')}.`,
+      `- ${guard}: semantic fields: ${
+        semanticFields.length === 0 ? '(none)' : semanticFields.join(', ')
+      }; ${description}`,
     );
   }
   lines.push('');
   lines.push(
-    'Reply with a single JSON object: { "guard": "<one of the guard names above>", ...any payload fields the chosen guard description requires }.',
+    '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.',
   );
+  if (correction !== undefined) {
+    lines.push('');
+    lines.push('Your first reply was structurally invalid:');
+    lines.push('"""');
+    lines.push(correction.reply);
+    lines.push('"""');
+    lines.push(`Validation error: ${correction.error}`);
+    lines.push(
+      'Correct only that structure using the same player output and outcome schema.',
+    );
+  }
   return lines.join('\n');
 }
 
-function parseAdjudication(
-  raw: string,
-  input: PlayerInput,
-  finalText: string,
-): PlayerOutput {
-  const obj = extractJson(raw);
-  if (!obj || typeof obj.guard !== 'string' || obj.guard.trim() === '') {
-    throw new Error('adjudicator returned empty or malformed JSON');
-  }
-
-  const guard = obj.guard;
-  if (!Object.prototype.hasOwnProperty.call(input.result, guard)) {
-    throw new Error(
-      `adjudicator returned undeclared guard "${guard}" for ${input.sourceItem}`,
+function parseGovernedSemanticCandidate(raw: string): unknown {
+  try {
+    return parseJudgeJson(raw);
+  } catch (error) {
+    throw new PlaybookSemanticCandidateStructureError(
+      error instanceof Error ? error.message : 'reply is not valid JSON',
     );
   }
-
-  const requiredFields = requiredFieldsFor(input.result[guard]);
-  const allowedFields = new Set(['guard', ...requiredFields]);
-  for (const key of Reflect.ownKeys(obj)) {
-    if (typeof key !== 'string' || !allowedFields.has(key)) {
-      throw new Error(
-        `adjudicator response for guard "${guard}" included undeclared field "${String(key)}"`,
-      );
-    }
-  }
-  const output: Record<string, unknown> = { guard };
-  for (const field of requiredFields) {
-    if (VERBATIM_PAYLOAD_FIELDS.has(field)) {
-      output[field] = finalText;
-      continue;
-    }
-    const value = obj[field];
-    if (
-      value === undefined ||
-      value === null ||
-      (typeof value === 'string' && value.trim() === '')
-    ) {
-      throw new Error(
-        `adjudicator response for guard "${guard}" missing required field "${field}"`,
-      );
-    }
-    output[field] = value;
-  }
-  return output as PlayerOutput;
 }
 
 function combineSignals(
@@ -580,10 +722,394 @@ function isEmptyFinalText(finalText: string | undefined): boolean {
   return finalText === undefined || finalText.trim().length === 0;
 }
 
+interface AutomaticReplayPolicy {
+  allowsEmptyOkCorrection(runtimeSessionId: string, callId: string): boolean;
+  allowsFailureStateRetry(): boolean;
+}
+
+interface Schema3AutomaticReplayEvidence {
+  readonly effectLedger: PlaybookEffectLedgerCapability;
+}
+
+interface DecideRepositoryOperationSettlement<T> {
+  readonly status: 'fulfilled';
+  readonly value: T;
+}
+
+interface DecideRepositoryOperationRejection {
+  readonly status: 'rejected';
+  readonly reason: unknown;
+}
+
+interface DecideRepositoryCompletion<T> {
+  readonly boundary: PlaybookEffectBoundary;
+  readonly operation:
+    | DecideRepositoryOperationSettlement<T>
+    | DecideRepositoryOperationRejection;
+  readonly receipt: PlaybookRepositoryReceipt;
+  readonly outcomeReceipt: PlaybookRepositoryReceipt;
+  readonly roleId?: RoleId;
+}
+
+interface DecideDeferredBinding {
+  readonly operationId: string;
+  readonly pendingQuestion: PlaybookPendingBossQuestion;
+  readonly playerContinuation: JsonValue;
+}
+
+interface DecideRepositoryCompletionEvidence {
+  readonly finalText?: string;
+  readonly semanticCandidate?: JsonValue;
+  readonly deferred?: DecideDeferredBinding;
+  readonly unresolved?: true;
+}
+
+interface DecideRepositoryExclusiveResult<T> {
+  readonly operation:
+    | DecideRepositoryOperationSettlement<T>
+    | DecideRepositoryOperationRejection;
+  readonly receipt: PlaybookRepositoryReceipt;
+  readonly effectLedger: PlaybookEffectLedger;
+  readonly deferredStatus?: 'bound' | 'unresolved';
+}
+
+interface DecideRepositoryCohortResult<T> {
+  readonly baseline: PlaybookRepositoryReceipt['baseline'];
+  readonly invocationId: string;
+  readonly operations: Readonly<
+    Record<
+      RoleId,
+      | DecideRepositoryOperationSettlement<T>
+      | DecideRepositoryOperationRejection
+    >
+  >;
+  readonly receipts: Readonly<Record<RoleId, PlaybookRepositoryReceipt>>;
+  readonly effectLedger: PlaybookEffectLedger;
+}
+
+interface DecideRepositoryDeferredContinuationResult<T>
+  extends DecideRepositoryExclusiveResult<T> {
+  readonly status: 'continued';
+  readonly baseline: PlaybookRepositoryReceipt['baseline'];
+  readonly logicalReceipt?: PlaybookRepositoryReceipt;
+}
+
+interface DecideRepositoryDeferredCheckpointMismatch {
+  readonly status: 'checkpoint-mismatch' | 'ineligible';
+  readonly effectLedger: PlaybookEffectLedger;
+}
+
+interface DecideRepositoryDeferredParked {
+  readonly status: 'parked';
+  readonly effectLedger: PlaybookEffectLedger;
+}
+
+interface DecideRepositoryDeferredRestoreResult {
+  readonly status: 'restored' | 'checkpoint-mismatch' | 'ineligible';
+  readonly effectLedger: PlaybookEffectLedger;
+}
+
+type DecideEffectBoundarySeed = Omit<
+  PlaybookEffectBoundaryStart,
+  'playbookId' | 'canonicalWorktree' | 'baseline' | 'cohortId'
+>;
+
+interface DecideRepositoryCapability {
+  runExclusive<T>(options: {
+    readonly signal: AbortSignal;
+    readonly effectBoundary: DecideEffectBoundarySeed;
+    readonly operation: (context: {
+      readonly baseline: PlaybookRepositoryReceipt['baseline'];
+      readonly identity: unknown;
+    }) => Promise<T>;
+    readonly completeEffectBoundary: (
+      completion: DecideRepositoryCompletion<T>,
+    ) =>
+      | DecideRepositoryCompletionEvidence
+      | Promise<DecideRepositoryCompletionEvidence>;
+  }): Promise<DecideRepositoryExclusiveResult<T>>;
+  runCohort<T>(options: {
+    readonly signal: AbortSignal;
+    readonly invocationId: string;
+    readonly roleIds: readonly [RoleId, RoleId];
+    readonly dispositionsByRole: Readonly<
+      Record<RoleId, readonly ['unchanged']>
+    >;
+    readonly effectBoundaries: Readonly<
+      Record<RoleId, DecideEffectBoundarySeed>
+    >;
+    readonly operations: Readonly<
+      Record<
+        RoleId,
+        (context: {
+          readonly baseline: PlaybookRepositoryReceipt['baseline'];
+          readonly identity: unknown;
+          readonly invocationId: string;
+          readonly roleId: RoleId;
+        }) => Promise<T>
+      >
+    >;
+    readonly completeEffectBoundary: (
+      completion: DecideRepositoryCompletion<T> & { readonly roleId: RoleId },
+    ) =>
+      | DecideRepositoryCompletionEvidence
+      | Promise<DecideRepositoryCompletionEvidence>;
+  }): Promise<DecideRepositoryCohortResult<T>>;
+  runDeferred<T>(options: {
+    readonly mode: 'continue';
+    readonly signal: AbortSignal;
+    readonly operationId: string;
+    readonly effectBoundary: DecideEffectBoundarySeed;
+    readonly operation: (context: {
+      readonly baseline: PlaybookRepositoryReceipt['baseline'];
+      readonly identity: unknown;
+      readonly playerContinuation: JsonValue;
+    }) => Promise<T>;
+    readonly completeEffectBoundary: (
+      completion: DecideRepositoryCompletion<T>,
+    ) =>
+      | DecideRepositoryCompletionEvidence
+      | Promise<DecideRepositoryCompletionEvidence>;
+  }): Promise<
+    | DecideRepositoryDeferredContinuationResult<T>
+    | DecideRepositoryDeferredCheckpointMismatch
+  >;
+  runDeferred(options: {
+    readonly mode: 'park' | 'restore';
+    readonly signal: AbortSignal;
+    readonly operationId: string;
+  }): Promise<
+    DecideRepositoryDeferredParked | DecideRepositoryDeferredRestoreResult
+  >;
+}
+
+interface Schema3DeferredEffectEvidence extends Schema3AutomaticReplayEvidence {
+  readonly authority: DecidePlaybookHostCapabilities['authority'];
+  readonly repository: DecideRepositoryCapability;
+}
+
+function schema3Construction(
+  value: unknown,
+): {
+  readonly configuredOptions: PlaybookRuntimeOptions;
+  readonly hostCapabilities: Schema3DeferredEffectEvidence;
+} {
+  if (!isPlainObject(value)) {
+    throw new TypeError('DECIDE schema-3 factory input must be a plain object');
+  }
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  const keys = Reflect.ownKeys(value);
+  if (
+    keys.length !== 2 ||
+    !keys.includes('configuredOptions') ||
+    !keys.includes('hostCapabilities') ||
+    keys.some((key) => {
+      const descriptor = descriptors[key as keyof typeof descriptors];
+      return (
+        descriptor?.get !== undefined ||
+        descriptor?.set !== undefined ||
+        descriptor?.enumerable !== true ||
+        !Object.prototype.hasOwnProperty.call(descriptor, 'value')
+      );
+    })
+  ) {
+    throw new TypeError(
+      'DECIDE schema-3 factory input must contain exactly configuredOptions and hostCapabilities data properties',
+    );
+  }
+  const configuredOptions = descriptors.configuredOptions!.value;
+  if (
+    configuredOptions !== null &&
+    typeof configuredOptions === 'object' &&
+    Object.prototype.hasOwnProperty.call(
+      configuredOptions,
+      'hostCapabilities',
+    )
+  ) {
+    throw new TypeError(
+      'DECIDE configured options must not contain hostCapabilities',
+    );
+  }
+  const hostCapabilities = descriptors.hostCapabilities!.value;
+  if (
+    hostCapabilities === null ||
+    typeof hostCapabilities !== 'object' ||
+    Array.isArray(hostCapabilities)
+  ) {
+    throw new TypeError(
+      'DECIDE schema-3 factory input hostCapabilities must be a live object',
+    );
+  }
+  const repositoryDescriptor = Object.getOwnPropertyDescriptor(
+    hostCapabilities,
+    'repository',
+  );
+  const authorityDescriptor = Object.getOwnPropertyDescriptor(
+    hostCapabilities,
+    'authority',
+  );
+  const effectLedgerDescriptor = Object.getOwnPropertyDescriptor(
+    hostCapabilities,
+    'effectLedger',
+  );
+  const repository = repositoryDescriptor?.value;
+  const authority = authorityDescriptor?.value;
+  const effectLedger = effectLedgerDescriptor?.value;
+  if (
+    authorityDescriptor === undefined ||
+    authorityDescriptor.get !== undefined ||
+    authorityDescriptor.set !== undefined ||
+    !Object.prototype.hasOwnProperty.call(authorityDescriptor, 'value') ||
+    !isPlainObject(authority) ||
+    authority.artifactSchema !== 3 ||
+    authority.playbookId !== 'decide' ||
+    typeof authority.sessionId !== 'string' ||
+    authority.sessionId.length === 0 ||
+    !Array.isArray(authority.requiredRoleIds) ||
+    stableJson(
+      [...authority.requiredRoleIds].sort(),
+      'DECIDE host authority required roles',
+    ) !== stableJson([...ROLE_IDS].sort(), 'DECIDE required roles') ||
+    !Array.isArray(authority.concurrentRoleSets) ||
+    authority.concurrentRoleSets.length !== 1 ||
+    !Array.isArray(authority.concurrentRoleSets[0]) ||
+    stableJson(
+      [...authority.concurrentRoleSets[0]].sort(),
+      'DECIDE host authority concurrent roles',
+    ) !== stableJson([...ROLE_IDS].sort(), 'DECIDE concurrent roles')
+  ) {
+    throw new TypeError(
+      'DECIDE schema-3 factory input hostCapabilities.authority must identify one schema-3 playbook session',
+    );
+  }
+  if (
+    repositoryDescriptor === undefined ||
+    repositoryDescriptor.get !== undefined ||
+    repositoryDescriptor.set !== undefined ||
+    !Object.prototype.hasOwnProperty.call(repositoryDescriptor, 'value') ||
+    !isPlainObject(repository) ||
+    typeof repository.runExclusive !== 'function' ||
+    typeof repository.runCohort !== 'function' ||
+    typeof repository.runDeferred !== 'function'
+  ) {
+    throw new TypeError(
+      'DECIDE schema-3 factory input hostCapabilities.repository must expose runExclusive, runCohort, and runDeferred functions',
+    );
+  }
+  if (
+    effectLedgerDescriptor === undefined ||
+    effectLedgerDescriptor.get !== undefined ||
+    effectLedgerDescriptor.set !== undefined ||
+    !Object.prototype.hasOwnProperty.call(effectLedgerDescriptor, 'value') ||
+    !isPlainObject(effectLedger) ||
+    typeof effectLedger.snapshot !== 'function' ||
+    typeof effectLedger.writeAhead !== 'function'
+  ) {
+    throw new TypeError(
+      'DECIDE schema-3 factory input hostCapabilities.effectLedger must expose snapshot and writeAhead functions',
+    );
+  }
+  return {
+    configuredOptions: configuredOptions as PlaybookRuntimeOptions,
+    hostCapabilities: {
+      authority:
+        authority as unknown as DecidePlaybookHostCapabilities['authority'],
+      repository: repository as unknown as DecideRepositoryCapability,
+      effectLedger: effectLedger as unknown as PlaybookEffectLedgerCapability,
+    },
+  };
+}
+
+interface DeferredValue<T> {
+  readonly promise: Promise<T>;
+  resolve(value: T): void;
+  reject(reason: unknown): void;
+}
+
+function deferredValue<T>(): DeferredValue<T> {
+  let resolve!: (value: T) => void;
+  let reject!: (reason: unknown) => void;
+  const promise = new Promise<T>((onResolve, onReject) => {
+    resolve = onResolve;
+    reject = onReject;
+  });
+  return { promise, resolve, reject };
+}
+
+function hasCompleteUnchangedReceipt(
+  boundary: PlaybookEffectBoundary,
+): boolean {
+  return boundary.physicalReceipt?.classification === 'unchanged';
+}
+
+// A corrective call is bound to the exact physical boundary it would repeat.
+// A failed-state restart replays the whole entry event. Cooperative host
+// attempts are serialized in ledger order, so the latest durable boundary
+// identifies the causal host attempt even when a nested or sibling runtime
+// wrote it; every boundary in that attempt must have a complete unchanged
+// receipt.
+// The durable ledger remains the authority in both cases; no process-local
+// player result or presentation text can make a replay safe.
+function createAutomaticReplayPolicy(
+  evidence: Schema3AutomaticReplayEvidence,
+): AutomaticReplayPolicy {
+  const readLedger = (): PlaybookEffectLedger =>
+    assertPlaybookEffectLedger(
+      evidence.effectLedger.snapshot(),
+      'DECIDE automatic-replay effect ledger',
+    );
+
+  return Object.freeze({
+    allowsEmptyOkCorrection(runtimeSessionId: string, callId: string) {
+      const matching = readLedger().boundaries.filter(
+        (boundary) =>
+          boundary.runtimeSessionId === runtimeSessionId &&
+          boundary.callId === callId,
+      );
+      return (
+        matching.length === 1 && hasCompleteUnchangedReceipt(matching[0]!)
+      );
+    },
+
+    allowsFailureStateRetry() {
+      const ledger = readLedger();
+      const latest = ledger.boundaries.at(-1);
+      if (latest === undefined) return false;
+      const attempt = ledger.boundaries.filter(
+        (boundary) => boundary.attemptId === latest.attemptId,
+      );
+      return (
+        attempt.length > 0 && attempt.every(hasCompleteUnchangedReceipt)
+      );
+    },
+  });
+}
+
 function isAbortFailure(error: unknown, signal: AbortSignal): boolean {
   return signal.aborted && Object.is(error, signal.reason);
 }
 
+interface AbortReasonClassifier {
+  isAbortReason(error: unknown): boolean;
+}
+
+function abortReasonClassifier(
+  ...sources: readonly (AbortSignal | AbortReasonClassifier | undefined)[]
+): AbortReasonClassifier {
+  const captured = sources.filter(
+    (source): source is AbortSignal | AbortReasonClassifier =>
+      source !== undefined,
+  );
+  return Object.freeze({
+    isAbortReason: (error: unknown): boolean =>
+      captured.some((source) =>
+        source instanceof AbortSignal
+          ? isAbortFailure(error, source)
+          : source.isAbortReason(error),
+      ),
+  });
+}
+
 function pendingQuestionsFromContext(
   context: Record<string, unknown>,
 ): PendingBossQuestion[] {
@@ -635,6 +1161,33 @@ const STATUS_STATE_IDS: ReadonlySet<string> = new Set([
   'failed',
 ]);
 
+// PBRT-45: a question is pending only while its authored reply-wait state
+// is active. The context retains an answered question through the resumed
+// player call so the Q+A continuation prompt can quote it, and each branch
+// keeps its own entry through the parallel region — so an unfiltered
+// projection would report the answered question as still awaiting during
+// the resume, and both branch questions after only one remains pending.
+const RESUME_WAIT_STATE_IDS: Readonly<Record<string, string>> = {
+  ...Object.fromEntries(
+    Object.entries(WAIT_STATE_RESUME_IDS).map(([waitStateId, resumeStateId]) => [
+      resumeStateId,
+      waitStateId,
+    ]),
+  ),
+  commitCoderProposal: 'awaitBossReply',
+};
+
+function pendingQuestionsForState(
+  state: PlaybookState,
+  context: Record<string, unknown>,
+): PendingBossQuestion[] {
+  return pendingQuestionsFromContext(context).filter((pending) =>
+    state.activeStateIds.includes(
+      RESUME_WAIT_STATE_IDS[pending.resumeStateId] ?? '',
+    ),
+  );
+}
+
 function questionForWaitState(
   stateId: string,
   pendingQuestions: readonly PendingBossQuestion[],
@@ -687,8 +1240,12 @@ function telemetryPayload(
   state: PlaybookState,
   event: unknown,
   context: Record<string, unknown>,
+  hiddenQuestionId?: string,
 ): JsonValue {
-  const pendingBossQuestions = pendingQuestionsFromContext(context);
+  const pendingBossQuestions = pendingQuestionsForState(
+    state,
+    context,
+  ).filter(({ questionId }) => questionId !== hiddenQuestionId);
   const prior = previousState ?? state;
   const payload = {
     from: prior.value,
@@ -705,10 +1262,56 @@ function telemetryPayload(
   return payload;
 }
 
-export const createPlaybookRuntime: PlaybookRuntimeFactory<
-  PlaybookRuntimeOptions
-> = (options) => {
+type DecidePlaybookRuntime = PlaybookRuntime & {
+  _getNestedBridge(): NestedPlaybookBridge<PlaybookInput>;
+};
+
+type DeferredContinuationEnvelope = {
+  readonly roleId: RoleId;
+  readonly playerId?: string;
+  readonly callId: string;
+  readonly result: PlayerResult;
+};
+
+interface ActiveDeferredContinuation {
+  readonly operationId: string;
+  readonly effectBoundary: DecideEffectBoundarySeed;
+  readonly result: DeferredValue<PlayerResult>;
+  readonly acknowledged: DeferredValue<PlayerResult>;
+  playerContinuation?: string | false;
+  input?: PlayerInput;
+  playerId?: string;
+}
+
+interface PendingProposalCohortMember {
+  readonly input: PlayerInput;
+  readonly signal: AbortSignal;
+  readonly callId: string;
+  readonly effectBoundary: DecideEffectBoundarySeed;
+  readonly result: DeferredValue<DeferredContinuationEnvelope>;
+  envelope?: DeferredContinuationEnvelope;
+}
+
+function createDecidePlaybookRuntime(
+  options: PlaybookRuntimeOptions,
+  deferredEffects: Schema3DeferredEffectEvidence,
+): DecidePlaybookRuntime {
+  const automaticReplayPolicy = createAutomaticReplayPolicy(deferredEffects);
   const fsmInput = snapshotDecideRuntimeOptions(options);
+  const readEffectLedger = (): PlaybookEffectLedger =>
+    assertPlaybookEffectLedger(
+      deferredEffects.effectLedger.snapshot(),
+      'DECIDE current host effect ledger',
+    );
+  let effectLedgerMirror = readEffectLedger();
+  const acceptedOutcomeConsumer = createAcceptedOutcomeConsumer(
+    (source, acceptedOutcome) =>
+      Object.prototype.hasOwnProperty.call(
+        ACCEPTED_OUTCOME_DECLARATIONS,
+        source,
+      ) &&
+      ACCEPTED_OUTCOME_DECLARATIONS[source]?.has(acceptedOutcome) === true,
+  );
 
   type SessionIdentity = Readonly<PlaybookSession>;
 
@@ -716,6 +1319,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   let sessionIdentity: SessionIdentity | undefined;
   let actor: ReturnType<typeof createActor> | undefined;
   let currentSignal: AbortSignal | undefined;
+  let currentAborts: AbortReasonClassifier | undefined;
+  const actorSettlementAborts: AbortReasonClassifier[] = [];
+  let actorSettlementErrorAborts: AbortReasonClassifier | undefined;
   let currentTurnId: number | undefined;
   let previousState: PlaybookState | undefined;
   let suppressInspectionEmissions = false;
@@ -725,6 +1331,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   let judgeCallSequence = 0;
   let playerCallSequence = 0;
   let playbookCallSequence = 0;
+  let applyCallSequence = 0;
   let lifecycleStarted = false;
   let initInFlight: Promise<void> | undefined;
   let disposed = false;
@@ -738,6 +1345,35 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   const activeEmissionCalls = new Set<Promise<void>>();
   const emissionQueue = new PQueue({ concurrency: 1 });
   const judgeQueue = new PQueue({ concurrency: 1 });
+  // A proposal cohort completes both semantic callbacks concurrently at the
+  // repository seam. Serialize each whole adjudication/correction transaction
+  // so their durable correction-budget compare-and-swaps cannot race.
+  const semanticCompletionQueue = new PQueue({ concurrency: 1 });
+  const governedOutputsByBoundaryId = new Map<string, PlayerOutput>();
+  const governedFailuresByBoundaryId = new Map<string, Error>();
+  const governedEvidenceByBoundaryId = new Map<
+    string,
+    { readonly finalText: string; readonly semanticCandidate?: JsonValue }
+  >();
+  const governedReceiptsByBoundaryId = new Map<
+    string,
+    {
+      readonly physicalReceipt: PlaybookRepositoryReceipt;
+      readonly outcomeReceipt: PlaybookRepositoryReceipt;
+    }
+  >();
+  const governedPlayerOutputs = new WeakMap<object, PlayerOutput>();
+  const unresolvedSemanticBoundaryIds = new Set<string>();
+  const appliedControlReceipts = new Map<string, PlaybookControlReceipt>();
+  const pendingProposalCohort = new Map<
+    RoleId,
+    PendingProposalCohortMember
+  >();
+  let activeProposalCohort: Promise<void> | undefined;
+  let completedProposalCohortTurnId: number | undefined;
+  let deferredOperationId: string | undefined;
+  let hiddenDeferredOperationId: string | undefined;
+  let activeDeferredContinuation: ActiveDeferredContinuation | undefined;
 
   const collectFailure = (failures: unknown[], error: unknown): void => {
     if (error instanceof AggregateError) {
@@ -754,26 +1390,35 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   ): void => {
     if (!isAbortFailure(error, signal)) controlPlaneError ??= error;
   };
-  const latchInspectionError = (error: unknown): void => {
-    if (currentSignal !== undefined) {
-      latchControlPlaneError(error, currentSignal);
-    } else {
-      collectFailure(emissionFailures, error);
-    }
+  const latchInspectionError = (
+    error: unknown,
+    aborts: AbortReasonClassifier | undefined = currentAborts,
+  ): void => {
+    if (aborts?.isAbortReason(error)) return;
+    if (currentSignal !== undefined) controlPlaneError ??= error;
+    else collectFailure(emissionFailures, error);
   };
-  const enqueue = (fn: () => Promise<void>): Promise<void> => {
+  const enqueue = (
+    fn: () => Promise<void>,
+    aborts: AbortReasonClassifier | undefined = currentAborts,
+  ): Promise<void> => {
+    const enqueueAborts = aborts;
     const queued = emissionQueue.add(fn);
     activeEmissionCalls.add(queued);
     void queued.then(
       () => activeEmissionCalls.delete(queued),
       (error: unknown) => {
         activeEmissionCalls.delete(queued);
-        collectFailure(emissionFailures, error);
+        if (!enqueueAborts?.isAbortReason(error)) {
+          collectFailure(emissionFailures, error);
+        }
       },
     );
     return queued;
   };
-  const flush = async (): Promise<void> => {
+  const flush = async (
+    _aborts: AbortReasonClassifier | undefined = currentAborts,
+  ): Promise<void> => {
     while (true) {
       const active = [...activeEmissionCalls];
       if (active.length > 0) await Promise.allSettled(active);
@@ -789,8 +1434,15 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     if (emissionFailures.length === 0) return;
     const failures = emissionFailures;
     emissionFailures = [];
-    if (failures.length === 1) throw failures[0];
-    throw new AggregateError(failures, 'decide runtime emissions failed');
+    const failure =
+      failures.length === 1
+        ? failures[0]
+        : new AggregateError(failures, 'decide runtime emissions failed');
+    // Enqueue ownership already classified every stored failure as distinct.
+    // Preserve that classification if an unrelated public boundary drains
+    // it with a signal whose reason happens to be the same object.
+    if (currentSignal !== undefined) controlPlaneError ??= failure;
+    throw failure;
   };
   const drainBoundaryCallsAndEmissions = async (): Promise<void> => {
     while (true) {
@@ -824,6 +1476,11 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
 
   const bindSession = (nextSession: PlaybookSession): SessionIdentity => {
     const bound = snapshotPlaybookSession(nextSession);
+    if (bound.playbookId !== deferredEffects.authority.playbookId) {
+      throw new TypeError(
+        'DECIDE runtime playbook identity must match its bound schema-3 host authority',
+      );
+    }
     if (bound.roleBindings === undefined) return bound;
     const actual = Object.keys(bound.roleBindings).sort();
     const expected = [...ROLE_IDS].sort();
@@ -1004,68 +1661,379 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       pendingCall,
     });
   };
-  const stateIdentity = (state: PlaybookState): { stateId?: string } => {
-    return state.stateId === undefined ? {} : { stateId: state.stateId };
-  };
-  const enqueueTracedEmission = (
-    type: PlaybookTraceType,
-    payload: unknown,
-    meta: { turnId?: number; callId?: string } = {},
-    describedEmission?: (runtimePorts: PlaybookPorts) => Promise<void>,
-  ): Promise<void> => {
-    const runtimePorts = requirePorts();
-    const identity = requireSessionIdentity();
-    const jsonPayload = snapshotJsonValue(payload, `trace ${type} payload`);
-    const trace: PlaybookTraceEvent = Object.freeze({
-      schemaVersion: 3,
-      sessionId: identity.sessionId,
-      playbookId: identity.playbookId,
-      rootSessionId: identity.rootSessionId,
-      ...(identity.parentSessionId !== undefined
-        ? { parentSessionId: identity.parentSessionId }
-        : {}),
-      ...(identity.parentCallId !== undefined
-        ? { parentCallId: identity.parentCallId }
-        : {}),
-      depth: identity.depth,
-      sequence: ++traceSequence,
-      timestamp: Date.now(),
-      type,
-      ...(meta.turnId !== undefined ? { turnId: meta.turnId } : {}),
-      ...(meta.callId !== undefined ? { callId: meta.callId } : {}),
-      payload: jsonPayload,
-    });
-    return enqueue(async () => {
-      await runtimePorts.emitTelemetry({ topic: TRACE_TOPIC, payload: trace });
-      await describedEmission?.(runtimePorts);
-    });
-  };
-  const emitTrace = (
-    type: PlaybookTraceType,
-    payload: unknown,
-    meta: { turnId?: number; callId?: string } = {},
-  ): Promise<void> => enqueueTracedEmission(type, payload, meta);
-  const emitBoundaryStatus = async (
-    message: string,
+  const visiblePendingQuestionsForState = (
     state: PlaybookState,
-  ): Promise<void> => {
-    const bossRelevantStateIds = state.activeStateIds.filter((stateId) =>
-      STATUS_STATE_IDS.has(stateId),
+    context: Record<string, unknown>,
+  ): PendingBossQuestion[] =>
+    pendingQuestionsForState(state, context).filter(
+      ({ questionId }) =>
+        questionId !== 'commitCoderProposal' ||
+        hiddenDeferredOperationId === undefined,
     );
-    await enqueueTracedEmission(
-      'status.emitted',
-      {
-        ...(bossRelevantStateIds.length === 1
-          ? { stateId: bossRelevantStateIds[0] }
-          : {}),
-        message,
-        state,
-      },
-      { turnId: currentTurnId },
-      (runtimePorts) => runtimePorts.emitStatus(message),
+  const openDeferredOperation = (
+    ledger: PlaybookEffectLedger = effectLedgerMirror,
+  ) => {
+    if (sessionIdentity === undefined) return undefined;
+    const open = ledger.logicalOperations.filter(
+      (operation) =>
+        operation.playbookId === sessionIdentity!.playbookId &&
+        operation.runtimeSessionId === sessionIdentity!.sessionId &&
+        operation.logicalReceipt === undefined,
     );
+    if (open.length > 1) {
+      throw new TypeError(
+        'DECIDE runtime has multiple open deferred logical operations',
+      );
+    }
+    return open[0];
   };
-
+  const runtimeBoundaryIsOwned = (
+    boundary: PlaybookEffectBoundary,
+  ): boolean =>
+    sessionIdentity !== undefined &&
+    boundary.playbookId === sessionIdentity.playbookId &&
+    boundary.runtimeSessionId === sessionIdentity.sessionId;
+  const governedOutcomesForBoundary = (
+    boundary: PlaybookEffectBoundary,
+  ): Readonly<Record<string, PlaybookSemanticOutcomeSpec>> | undefined => {
+    const outcomes = (
+      DECIDE_OUTCOME_AUTHORITY.governedPlayerStates as Readonly<
+        Record<string, Readonly<Record<string, PlaybookSemanticOutcomeSpec>>>
+      >
+    )[boundary.sourceStateId];
+    if (
+      outcomes === undefined ||
+      !isPlainObject(boundary.sourceOutcomeSchema)
+    ) {
+      return undefined;
+    }
+    const authoredGuards = Object.keys(boundary.sourceOutcomeSchema).sort();
+    const governedGuards = Object.keys(outcomes).sort();
+    if (
+      authoredGuards.length !== governedGuards.length ||
+      authoredGuards.some((guard, index) => guard !== governedGuards[index])
+    ) {
+      return undefined;
+    }
+    for (const guard of governedGuards) {
+      const description = boundary.sourceOutcomeSchema[guard];
+      if (typeof description !== 'string') return undefined;
+      const authoredFields = [
+        ...new Set(requiredFieldsFor(description)),
+      ].sort();
+      const governedFields = Object.keys(outcomes[guard]!.fields).sort();
+      if (
+        authoredFields.length !== governedFields.length ||
+        authoredFields.some(
+          (field, index) => field !== governedFields[index],
+        )
+      ) {
+        return undefined;
+      }
+    }
+    const dispositions = [
+      ...new Set(
+        Object.values(outcomes).map(
+          ({ repositoryDisposition }) => repositoryDisposition,
+        ),
+      ),
+    ];
+    const actualDispositions = new Set(boundary.dispositions);
+    return actualDispositions.size === boundary.dispositions.length &&
+      actualDispositions.size === dispositions.length &&
+      dispositions.every((disposition) => actualDispositions.has(disposition))
+      ? outcomes
+      : undefined;
+  };
+  const persistedBoundaryReconciliation = (
+    boundary: PlaybookEffectBoundary,
+    ledger: PlaybookEffectLedger,
+  ) => {
+    const outcomes = governedOutcomesForBoundary(boundary);
+    if (outcomes === undefined || boundary.semanticCandidate === undefined) {
+      return undefined;
+    }
+    let receipt = boundary.physicalReceipt;
+    let awaitingLogicalReceipt = false;
+    let historicalDeferred = false;
+    const logicalOperation =
+      boundary.logicalOperationId === undefined
+        ? undefined
+        : ledger.logicalOperations.find(
+            ({ operationId }) =>
+              operationId === boundary.logicalOperationId,
+          );
+    if (
+      boundary.logicalOperationId !== undefined &&
+      logicalOperation === undefined
+    ) {
+      return undefined;
+    }
+    if (logicalOperation !== undefined) {
+      if (logicalOperation.boundaryIds.at(-1) !== boundary.boundaryId) {
+        historicalDeferred = true;
+      } else if (logicalOperation.logicalReceipt !== undefined) {
+        receipt = logicalOperation.logicalReceipt;
+      } else if (
+        logicalOperation.pendingQuestion === undefined ||
+        logicalOperation.checkpoint === undefined ||
+        !Object.prototype.hasOwnProperty.call(
+          logicalOperation,
+          'playerContinuation',
+        )
+      ) {
+        return undefined;
+      } else {
+        awaitingLogicalReceipt = true;
+      }
+    }
+    try {
+      const reconciliation = reconcilePlaybookSemanticEvidence({
+        outcomes,
+        semanticCandidate: boundary.semanticCandidate,
+        finalText: boundary.finalText,
+        receipt,
+      });
+      if (awaitingLogicalReceipt && reconciliation.status !== 'deferred') {
+        return undefined;
+      }
+      return { reconciliation, historicalDeferred };
+    } catch {
+      return undefined;
+    }
+  };
+  const boundaryNeedsSemanticReconciliation = (
+    boundary: PlaybookEffectBoundary,
+    ledger: PlaybookEffectLedger,
+  ): boolean => {
+    if (!runtimeBoundaryIsOwned(boundary)) return false;
+    if (governedOutcomesForBoundary(boundary) === undefined) return true;
+    const persisted = persistedBoundaryReconciliation(boundary, ledger);
+    if (persisted !== undefined) {
+      if (persisted.reconciliation.status === 'unresolved') return true;
+      if (persisted.historicalDeferred) {
+        return persisted.reconciliation.status !== 'deferred';
+      }
+      if (
+        persisted.reconciliation.status === 'deferred' &&
+        boundary.logicalOperationId === undefined
+      ) {
+        return true;
+      }
+      return false;
+    }
+    if (boundary.physicalReceipt === undefined) return true;
+    if (
+      typeof boundary.finalText === 'string' &&
+      boundary.finalText.trim().length > 0
+    ) {
+      return true;
+    }
+    return boundary.physicalReceipt.classification !== 'unchanged';
+  };
+  const refreshUnresolvedSemanticReconciliation = (
+    ledger: PlaybookEffectLedger = effectLedgerMirror,
+  ): void => {
+    unresolvedSemanticBoundaryIds.clear();
+    for (const boundary of ledger.boundaries) {
+      if (boundaryNeedsSemanticReconciliation(boundary, ledger)) {
+        unresolvedSemanticBoundaryIds.add(boundary.boundaryId);
+      }
+    }
+  };
+  const synchronizeDeferredProjection = (
+    ledger: PlaybookEffectLedger = effectLedgerMirror,
+  ): void => {
+    if (deferredEffects === undefined) return;
+    effectLedgerMirror = ledger;
+    refreshUnresolvedSemanticReconciliation(ledger);
+    const operation = openDeferredOperation(ledger);
+    if (operation === undefined) {
+      deferredOperationId = undefined;
+      hiddenDeferredOperationId = undefined;
+      return;
+    }
+    deferredOperationId = operation.operationId;
+    hiddenDeferredOperationId =
+      operation.logicalReceipt === undefined &&
+      (operation.checkpointRestorationEligible ||
+        operation.pendingQuestion === undefined)
+        ? operation.operationId
+        : undefined;
+  };
+  const hasUnresolvedReconciliation = (): boolean =>
+    hiddenDeferredOperationId !== undefined ||
+    unresolvedSemanticBoundaryIds.size > 0;
+  const refreshReconciliationProjection = (): void => {
+    synchronizeDeferredProjection(readEffectLedger());
+  };
+  const unresolvedEffectEnvelopeIdentities = (): readonly (
+    | { readonly kind: 'boundary'; readonly boundaryId: string }
+    | { readonly kind: 'logical-operation'; readonly operationId: string }
+  )[] => {
+    if (sessionIdentity === undefined) return [];
+    refreshReconciliationProjection();
+    if (!hasUnresolvedReconciliation()) return [];
+    const boundaryIds = new Set(unresolvedSemanticBoundaryIds);
+    const operationIds = new Set<string>();
+    if (hiddenDeferredOperationId !== undefined) {
+      operationIds.add(hiddenDeferredOperationId);
+    }
+    for (const boundaryId of [...boundaryIds]) {
+      const boundary = effectLedgerMirror.boundaries.find(
+        (candidate) => candidate.boundaryId === boundaryId,
+      );
+      const operation =
+        boundary?.logicalOperationId === undefined
+          ? undefined
+          : effectLedgerMirror.logicalOperations.find(
+              ({ operationId }) =>
+                operationId === boundary.logicalOperationId,
+            );
+      if (operation === undefined) continue;
+      operationIds.add(operation.operationId);
+      for (const memberId of operation.boundaryIds) {
+        boundaryIds.delete(memberId);
+      }
+    }
+    const ordered = [
+      ...[...boundaryIds].map((boundaryId) => ({
+        order:
+          effectLedgerMirror.boundaries.find(
+            (candidate) => candidate.boundaryId === boundaryId,
+          )?.sequence ?? Number.MAX_SAFE_INTEGER,
+        value: { kind: 'boundary' as const, boundaryId },
+      })),
+      ...[...operationIds].map((operationId) => {
+        const operation = effectLedgerMirror.logicalOperations.find(
+          (candidate) => candidate.operationId === operationId,
+        );
+        return {
+          order:
+            effectLedgerMirror.boundaries.find(
+              ({ boundaryId }) =>
+                boundaryId === operation?.boundaryIds[0],
+            )?.sequence ?? Number.MAX_SAFE_INTEGER,
+          value: { kind: 'logical-operation' as const, operationId },
+        };
+      }),
+    ].sort((left, right) => left.order - right.order);
+    return deepFreeze(
+      snapshotJsonValue(
+        ordered.map(({ value }) => value),
+        'DECIDE unresolved effect envelope identities',
+      ) as unknown as (
+        | { readonly kind: 'boundary'; readonly boundaryId: string }
+        | { readonly kind: 'logical-operation'; readonly operationId: string }
+      )[],
+    );
+  };
+  const stateIdentity = (state: PlaybookState): { stateId?: string } => {
+    return state.stateId === undefined ? {} : { stateId: state.stateId };
+  };
+  const enqueueTracedEmission = (
+    type: PlaybookTraceType,
+    payload: unknown,
+    meta: { turnId?: number; callId?: string } = {},
+    describedEmission?: (runtimePorts: PlaybookPorts) => Promise<void>,
+    aborts?: AbortReasonClassifier,
+  ): Promise<void> => {
+    const trace = createTraceEvent(type, payload, meta);
+    return enqueue(
+      async () => {
+        const runtimePorts = requirePorts();
+        await runtimePorts.emitTelemetry({ topic: TRACE_TOPIC, payload: trace });
+        await describedEmission?.(runtimePorts);
+      },
+      aborts,
+    );
+  };
+  const createTraceEvent = (
+    type: PlaybookTraceType,
+    payload: unknown,
+    meta: { turnId?: number; callId?: string } = {},
+  ): PlaybookTraceEvent => {
+    const identity = requireSessionIdentity();
+    const jsonPayload = snapshotJsonValue(payload, `trace ${type} payload`);
+    return Object.freeze({
+      schemaVersion: 4,
+      sessionId: identity.sessionId,
+      playbookId: identity.playbookId,
+      rootSessionId: identity.rootSessionId,
+      ...(identity.parentSessionId !== undefined
+        ? { parentSessionId: identity.parentSessionId }
+        : {}),
+      ...(identity.parentCallId !== undefined
+        ? { parentCallId: identity.parentCallId }
+        : {}),
+      depth: identity.depth,
+      sequence: ++traceSequence,
+      timestamp: Date.now(),
+      type,
+      ...(meta.turnId !== undefined ? { turnId: meta.turnId } : {}),
+      ...(meta.callId !== undefined ? { callId: meta.callId } : {}),
+      payload: jsonPayload,
+    });
+  };
+  const emitTrace = (
+    type: PlaybookTraceType,
+    payload: unknown,
+    meta: { turnId?: number; callId?: string } = {},
+    aborts?: AbortReasonClassifier,
+  ): Promise<void> => enqueueTracedEmission(type, payload, meta, undefined, aborts);
+  const enqueueAcceptedOutcomeEmission = (
+    acceptedOutcome: AcceptedOutcomeReceipt,
+    state: PlaybookState,
+    aborts?: AbortReasonClassifier,
+  ): Promise<void> => {
+    const message = `→ ${acceptedOutcome.acceptedOutcome}`;
+    const acceptedTrace = createTraceEvent(
+      'outcome.accepted',
+      acceptedOutcome,
+      { turnId: currentTurnId },
+    );
+    const statusTrace = createTraceEvent(
+      'status.emitted',
+      { stateId: acceptedOutcome.target, message, state },
+      { turnId: currentTurnId },
+    );
+    return enqueue(
+      async () => {
+        const runtimePorts = requirePorts();
+        await runtimePorts.emitTelemetry({
+          topic: TRACE_TOPIC,
+          payload: acceptedTrace,
+        });
+        await runtimePorts.emitTelemetry({
+          topic: TRACE_TOPIC,
+          payload: statusTrace,
+        });
+        await runtimePorts.emitStatus(message);
+      },
+      aborts,
+    );
+  };
+  const emitBoundaryStatus = async (
+    message: string,
+    state: PlaybookState,
+  ): Promise<void> => {
+    const bossRelevantStateIds = state.activeStateIds.filter((stateId) =>
+      STATUS_STATE_IDS.has(stateId),
+    );
+    await enqueueTracedEmission(
+      'status.emitted',
+      {
+        ...(bossRelevantStateIds.length === 1
+          ? { stateId: bossRelevantStateIds[0] }
+          : {}),
+        message,
+        state,
+      },
+      { turnId: currentTurnId },
+      (runtimePorts) => runtimePorts.emitStatus(message),
+    );
+  };
+
   const emitCallStarted = async (
     startedType: 'player.call.started' | 'judge.call.started',
     finishedType: 'player.call.finished' | 'judge.call.finished',
@@ -1073,8 +2041,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     meta: { turnId?: number; callId?: string },
     signal: AbortSignal,
   ): Promise<void> => {
+    const aborts = abortReasonClassifier(signal);
     try {
-      await emitTrace(startedType, identity, meta);
+      await emitTrace(startedType, identity, meta, aborts);
     } catch (error) {
       latchControlPlaneError(error, signal);
       try {
@@ -1082,13 +2051,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           finishedType,
           {
             ...identity,
-            status: 'error',
+            // A started-trace sink rejection causally identical to the
+            // boundary reason is the abort's own evidence: the pair
+            // finishes 'aborted', not 'error' (DR-036 §4).
+            status: isAbortFailure(error, signal) ? 'aborted' : 'error',
             error: normalizeErrorFull(error) ?? {
               name: 'Error',
               message: String(error),
             },
           },
           meta,
+          aborts,
         );
       } catch {
         // Preserve the start failure after one best-effort finish attempt.
@@ -1103,6 +2076,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     purpose: 'boss-input-classification' | 'player-output-adjudication',
     callStateId: string | undefined,
   ): Promise<string> => {
+    const aborts = abortReasonClassifier(signal);
     const identity = {
       purpose,
       ...(callStateId !== undefined ? { stateId: callStateId } : {}),
@@ -1138,13 +2112,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           'judge.call.finished',
           {
             ...identity,
-            status: signal.aborted ? 'aborted' : 'error',
+            // Only the exact abort reason is cancellation; a distinct
+            // failure under an aborted signal stays an error
+            // (slc/link.md §Abort).
+            status: isAbortFailure(error, signal) ? 'aborted' : 'error',
             error: normalizeErrorFull(error) ?? {
               name: 'Error',
               message: String(error),
             },
           },
           { turnId: currentTurnId, callId },
+          aborts,
         );
         throw error;
       }
@@ -1153,6 +2131,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         'judge.call.finished',
         { ...identity, status: 'ok', reply: finalText },
         { turnId: currentTurnId, callId },
+        aborts,
       );
       return finalText;
     });
@@ -1173,11 +2152,12 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   const runPlayerCall = async (
     input: PlayerInput,
     signal: AbortSignal,
-  ): Promise<{
-    roleId: RoleId;
-    playerId?: string;
-    result: PlayerResult;
-  }> => {
+    continuation?: {
+      readonly resume?: string | false;
+      readonly callId: string;
+    },
+  ): Promise<DeferredContinuationEnvelope> => {
+    const aborts = abortReasonClassifier(signal);
     if (!ROLE_ID_SET.has(input.role)) {
       throw new TypeError(
         `DECIDE player input role must name a declared local role`,
@@ -1190,12 +2170,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     let resume: PlayerCallOptions['resume'];
     try {
       signal.throwIfAborted();
-      resume = selectPlayerResume(roleId, playerId);
+      resume =
+        continuation !== undefined &&
+        Object.prototype.hasOwnProperty.call(continuation, 'resume')
+          ? continuation.resume!
+          : selectPlayerResume(roleId, playerId);
     } catch (error) {
       latchControlPlaneError(error, signal);
       throw error;
     }
-    const callId = `player-${++playerCallSequence}`;
+    const callId =
+      continuation?.callId ?? `player-${++playerCallSequence}`;
     const identity = {
       stateId: input.stateId,
       sourceItem: input.sourceItem,
@@ -1208,13 +2193,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         'player.call.finished',
         {
           ...identity,
-          status: signal.aborted ? 'aborted' : 'error',
+          // Only the exact abort reason is cancellation; a distinct
+          // failure under an aborted signal stays an error
+          // (slc/link.md §Abort).
+          status: isAbortFailure(error, signal) ? 'aborted' : 'error',
           error: normalizeErrorFull(error) ?? {
             name: 'Error',
             message: String(error),
           },
         },
         { turnId: currentTurnId, callId },
+        aborts,
       );
     if (inFlightPlayerKeys.has(playerKey)) {
       const error = new Error(
@@ -1310,10 +2299,12 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             : {}),
         },
         { turnId: currentTurnId, callId },
+        aborts,
       );
       return {
         roleId,
         ...(playerId === undefined ? {} : { playerId }),
+        callId,
         result,
       };
     } finally {
@@ -1321,153 +2312,1060 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     }
   };
 
-  const callPlayer = (
+  const governedBoundarySeed = (
     input: PlayerInput,
-    signal: AbortSignal,
-  ): Promise<{
-    roleId: RoleId;
-    playerId?: string;
-    result: PlayerResult;
-  }> => {
-    return trackBoundaryCall(runPlayerCall(input, signal));
+    callId: string,
+  ): DecideEffectBoundarySeed => {
+    const outcomes = governedOutcomesFor(input);
+    if (
+      currentTurnId === undefined ||
+      !Number.isSafeInteger(currentTurnId) ||
+      currentTurnId <= 0
+    ) {
+      throw new Error(
+        'DECIDE governed player call requires an active positive turn id',
+      );
+    }
+    return {
+      boundaryId: randomUUID(),
+      runtimeSessionId: requireSessionIdentity().sessionId,
+      turnId: currentTurnId,
+      callId,
+      roleId: input.role,
+      sourceStateId: input.stateId,
+      sourceOutcomeSchema: snapshotJsonValue(
+        input.result,
+        'DECIDE governed player source outcome schema',
+      ),
+      dispositions: [
+        ...new Set(
+          Object.values(outcomes).map(
+            ({ repositoryDisposition }) => repositoryDisposition,
+          ),
+        ),
+      ],
+      correctionBudget: { limit: 1, spent: false },
+    };
   };
 
-  const player = fromPromise<PlayerOutput, PlayerInput>(
-    async ({ input, signal }) => {
-      const combined = combineSignals(signal, currentSignal);
-      // XState starts invoked actors while publishing the entering snapshot.
-      // Yield through the runtime emission queue before crossing the player
-      // boundary so state trace/status always precede its call-start trace.
-      try {
-        await flush();
-      } catch (error) {
-        latchControlPlaneError(error, combined);
-        throw error;
-      }
-      combined.throwIfAborted();
-
-      let { roleId, playerId, result } = await callPlayer(input, combined);
-      if (result.status === 'ok' && isEmptyFinalText(result.finalText)) {
-        // DR-028: an `ok` result whose finalText is missing, empty, or
-        // whitespace-only earns exactly one corrective re-ask — the same
-        // composed call repeated, traced by runPlayerCall as its own
-        // player-call pair, with the resume selection re-read from the
-        // token map the first result left (PBRT-38). An abort that lands
-        // between the two calls ends the turn without the re-ask (aborts
-        // are never retried), and a rejecting finish emission rejects
-        // `callPlayer` itself, so it never reaches this branch (PBRT-47).
-        combined.throwIfAborted();
-        ({ roleId, playerId, result } = await callPlayer(input, combined));
-      }
-      if (result.status !== 'ok') {
-        throw new Error(
-          `${roleLabel(roleId)}${
-            playerId === undefined ? '' : ` (${playerId})`
-          } returned status "${result.status}"${
-            result.error ? `: ${result.error}` : ''
-          }`,
-        );
-      }
-      const finalText = result.finalText ?? '';
-      if (isEmptyFinalText(finalText)) {
-        throw new Error(
-          `${roleLabel(roleId)}${
-            playerId === undefined ? '' : ` (${playerId})`
-          } returned status "ok" with no finalText`,
-        );
-      }
-      combined.throwIfAborted();
-
-      try {
-        const prompt = buildAdjudicatorPrompt(input, finalText);
-        return parseAdjudication(
-          await callJudge(
-            prompt,
-            combined,
-            'player-output-adjudication',
-            input.stateId,
-          ),
-          input,
-          finalText,
-        );
-      } catch (error) {
-        latchControlPlaneError(error, combined);
-        throw error;
-      }
-    },
-  );
+  const unresolvedGovernedEvidence = (
+    boundaryId: string,
+    reason: string,
+    error?: unknown,
+  ): void => {
+    governedFailuresByBoundaryId.set(
+      boundaryId,
+      error instanceof Error
+        ? error
+        : new Error(`DECIDE governed outcome remains unresolved: ${reason}`),
+    );
+  };
 
-  nestedBridge = createNestedPlaybookBridge<PlaybookInput>({
-    nextCallId: () => `playbook-${++playbookCallSequence}`,
-    getBoundarySignal: () => currentSignal,
-    callPlaybook: (request, signal) =>
-      trackBoundaryCall(
-        Promise.resolve(requirePorts().callPlaybook(request, signal)),
-      ),
-    emitStarted: async (event) => {
-      playbookCallTurnIds.set(event.callId, currentTurnId);
-      await emitTrace(
-        'playbook.call.started',
-        {
-          stateId: event.stateId,
-          playbookId: event.playbookId,
-          text: event.text,
-        },
+  const spendSemanticCorrectionBudget = async (
+    boundary: PlaybookEffectBoundary,
+    receipt: PlaybookRepositoryReceipt,
+    finalText: string,
+    semanticCandidate: JsonValue | undefined,
+  ): Promise<boolean> => {
+    const ledger = readEffectLedger();
+    const current = ledger.boundaries.find(
+      ({ boundaryId }) => boundaryId === boundary.boundaryId,
+    );
+    if (
+      current === undefined ||
+      current.correctionBudget.limit !== 1 ||
+      current.correctionBudget.spent
+    ) {
+      return false;
+    }
+    if (current.finalText !== undefined && current.finalText !== finalText) {
+      throw new TypeError(
+        'DECIDE correction budget conflicts with retained finalText',
+      );
+    }
+    if (
+      current.physicalReceipt !== undefined &&
+      stableJson(current.physicalReceipt, 'DECIDE retained receipt') !==
+        stableJson(receipt, 'DECIDE correction receipt')
+    ) {
+      throw new TypeError(
+        'DECIDE correction budget conflicts with retained repository receipt',
+      );
+    }
+    if (
+      semanticCandidate !== undefined &&
+      current.semanticCandidate !== undefined &&
+      stableJson(current.semanticCandidate, 'DECIDE retained candidate') !==
+        stableJson(semanticCandidate, 'DECIDE correction candidate')
+    ) {
+      throw new TypeError(
+        'DECIDE correction budget conflicts with retained semantic candidate',
+      );
+    }
+    const next: PlaybookEffectBoundary = {
+      ...current,
+      ...(receipt.after === undefined ? {} : { after: receipt.after }),
+      physicalReceipt: receipt,
+      finalText,
+      ...(semanticCandidate === undefined ? {} : { semanticCandidate }),
+      correctionBudget: { limit: 1, spent: true },
+    };
+    const cohortMembers =
+      current.cohortId === undefined
+        ? [current]
+        : ledger.boundaries.filter(
+            ({ cohortId }) => cohortId === current.cohortId,
+          );
+    if (cohortMembers.length === 0) {
+      throw new TypeError(
+        'DECIDE correction boundary lost its repository cohort',
+      );
+    }
+    const replacements = cohortMembers.map((member) => ({
+      expected: member,
+      next:
+        member.boundaryId === current.boundaryId
+          ? next
+          : {
+              ...member,
+              ...(receipt.after === undefined
+                ? {}
+                : { after: receipt.after }),
+              physicalReceipt: receipt,
+            },
+    })) as [
+      {
+        readonly expected: PlaybookEffectBoundary;
+        readonly next: PlaybookEffectBoundary;
+      },
+      ...{
+        readonly expected: PlaybookEffectBoundary;
+        readonly next: PlaybookEffectBoundary;
+      }[],
+    ];
+    const acknowledged = assertPlaybookEffectLedger(
+      await deferredEffects.effectLedger.writeAhead([
         {
-          ...(currentTurnId === undefined ? {} : { turnId: currentTurnId }),
-          callId: event.callId,
+          kind: 'replace-boundaries',
+          // A cohort's shared receipt must become visible for every member in
+          // one ledger revision. Publishing only this member's correction
+          // spend would transiently create an invalid half-complete cohort.
+          replacements,
         },
+      ]),
+      'DECIDE semantic correction budget acknowledgement',
+    );
+    synchronizeDeferredProjection(acknowledged);
+    const spent = acknowledged.boundaries.find(
+      ({ boundaryId }) => boundaryId === boundary.boundaryId,
+    );
+    if (
+      spent === undefined ||
+      stableJson(spent, 'DECIDE acknowledged correction boundary') !==
+        stableJson(next, 'DECIDE expected correction boundary')
+    ) {
+      throw new TypeError(
+        'DECIDE semantic correction budget spend was not acknowledged exactly',
       );
-    },
-    emitFinished: async (event) => {
-      const turnId = playbookCallTurnIds.get(event.callId);
-      try {
-        await emitTrace(
-          'playbook.call.finished',
-          {
-            stateId: event.stateId,
-            playbookId: event.playbookId,
-            text: event.text,
-            result: event.result,
-          },
-          {
-            ...(turnId === undefined ? {} : { turnId }),
-            callId: event.callId,
-          },
-        );
-      } finally {
-        playbookCallTurnIds.delete(event.callId);
-      }
-    },
-    drain: flush,
-    bindResumeSignal: (signal) => {
-      currentSignal = signal;
-    },
-    onControlPlaneError: (error) => {
-      const signal = currentSignal;
-      if (!signal || !isAbortFailure(error, signal)) {
-        controlPlaneError ??= error;
-      }
-    },
-    onBackgroundError: (error) => {
-      collectFailure(emissionFailures, error);
-    },
-  });
+    }
+    return true;
+  };
 
-  const providedMachine = decideMachine.provide({
-    actors: { player, playbook: nestedBridge.actorLogic },
+  const completionEvidenceFor = (
+    input: PlayerInput,
+    roleId: RoleId,
+    playerId: string | undefined,
+    signal: AbortSignal,
+    operationId?: string,
+  ) =>
+    async (
+      completion: DecideRepositoryCompletion<PlayerResult>,
+    ): Promise<DecideRepositoryCompletionEvidence> => {
+      const queued = await semanticCompletionQueue.add(async () => {
+        const { boundary, operation } = completion;
+        const outcomes = governedOutcomesFor(input);
+        const expectedDispositions = [
+          ...new Set(
+            Object.values(outcomes).map(
+              ({ repositoryDisposition }) => repositoryDisposition,
+            ),
+          ),
+        ];
+        const session = requireSessionIdentity();
+        if (
+          boundary.playbookId !== session.playbookId ||
+          boundary.runtimeSessionId !== session.sessionId ||
+          boundary.turnId !== currentTurnId ||
+          boundary.roleId !== roleId ||
+          (completion.roleId !== undefined && completion.roleId !== roleId) ||
+          boundary.sourceStateId !== input.stateId ||
+          stableJson(
+            boundary.dispositions,
+            'DECIDE boundary dispositions',
+          ) !==
+            stableJson(
+              expectedDispositions,
+              'DECIDE authority dispositions',
+            ) ||
+          stableJson(
+            boundary.sourceOutcomeSchema,
+            'DECIDE boundary source schema',
+          ) !==
+            stableJson(input.result, 'DECIDE authored source schema')
+        ) {
+          throw new TypeError(
+            'DECIDE governed semantic reconciliation source schema changed',
+          );
+        }
+        governedReceiptsByBoundaryId.set(boundary.boundaryId, {
+          physicalReceipt: completion.receipt,
+          outcomeReceipt: completion.outcomeReceipt,
+        });
+        if (
+          operation.status !== 'fulfilled' ||
+          operation.value.status !== 'ok' ||
+          isEmptyFinalText(operation.value.finalText)
+        ) {
+          const incomplete =
+            operation.status === 'fulfilled' &&
+            operation.value.status === 'ok' &&
+            operation.value.finalText !== undefined
+              ? { finalText: operation.value.finalText }
+              : {};
+          if (
+            operation.status === 'fulfilled' &&
+            operation.value.status === 'ok' &&
+            operation.value.finalText !== undefined
+          ) {
+            governedEvidenceByBoundaryId.set(boundary.boundaryId, {
+              finalText: operation.value.finalText,
+            });
+          }
+          return operationId === undefined
+            ? incomplete
+            : { ...incomplete, unresolved: true as const };
+        }
+        const finalText = operation.value.finalText!;
+        let raw: string;
+        try {
+          raw = await callJudge(
+            buildAdjudicatorPrompt(input, finalText),
+            signal,
+            'player-output-adjudication',
+            input.stateId,
+          );
+        } catch (error) {
+          unresolvedGovernedEvidence(
+            boundary.boundaryId,
+            'judge transport failed',
+            error,
+          );
+          governedEvidenceByBoundaryId.set(boundary.boundaryId, { finalText });
+          return { finalText, unresolved: true as const };
+        }
+
+        let candidate: unknown;
+        let retainedCandidate: JsonValue | undefined;
+        let reconciliation:
+          | ReturnType<typeof reconcilePlaybookSemanticEvidence>
+          | undefined;
+        let structuralError:
+          | PlaybookSemanticCandidateStructureError
+          | undefined;
+        const retainCandidate = (value: unknown): void => {
+          try {
+            retainedCandidate = snapshotJsonValue(
+              value,
+              'DECIDE recoverable governed semantic candidate',
+            );
+          } catch {
+            // A non-detachable reply still retains presentation and receipt.
+          }
+        };
+        try {
+          candidate = parseGovernedSemanticCandidate(raw);
+          retainCandidate(candidate);
+          reconciliation = reconcilePlaybookSemanticEvidence({
+            outcomes,
+            semanticCandidate: candidate,
+            finalText,
+            receipt: completion.outcomeReceipt,
+          });
+        } catch (error) {
+          if (!(error instanceof PlaybookSemanticCandidateStructureError)) {
+            throw error;
+          }
+          structuralError = error;
+        }
+
+        if (structuralError !== undefined) {
+          const spent = await spendSemanticCorrectionBudget(
+            boundary,
+            completion.receipt,
+            finalText,
+            retainedCandidate,
+          );
+          if (!spent || signal.aborted) {
+            unresolvedGovernedEvidence(
+              boundary.boundaryId,
+              'semantic correction budget is unavailable',
+              signal.aborted ? signal.reason : undefined,
+            );
+            governedEvidenceByBoundaryId.set(boundary.boundaryId, {
+              finalText,
+              ...(retainedCandidate === undefined
+                ? {}
+                : { semanticCandidate: retainedCandidate }),
+            });
+            return {
+              finalText,
+              ...(retainedCandidate === undefined
+                ? {}
+                : { semanticCandidate: retainedCandidate }),
+              unresolved: true as const,
+            };
+          }
+          let correctiveRaw: string;
+          try {
+            correctiveRaw = await callJudge(
+              buildAdjudicatorPrompt(input, finalText, {
+                reply: raw,
+                error: structuralError.message,
+              }),
+              signal,
+              'player-output-adjudication',
+              input.stateId,
+            );
+          } catch (error) {
+            unresolvedGovernedEvidence(
+              boundary.boundaryId,
+              'corrective judge failed',
+              error,
+            );
+            governedEvidenceByBoundaryId.set(boundary.boundaryId, {
+              finalText,
+              ...(retainedCandidate === undefined
+                ? {}
+                : { semanticCandidate: retainedCandidate }),
+            });
+            return {
+              finalText,
+              ...(retainedCandidate === undefined
+                ? {}
+                : { semanticCandidate: retainedCandidate }),
+              unresolved: true as const,
+            };
+          }
+          try {
+            candidate = parseGovernedSemanticCandidate(correctiveRaw);
+            retainCandidate(candidate);
+            reconciliation = reconcilePlaybookSemanticEvidence({
+              outcomes,
+              semanticCandidate: candidate,
+              finalText,
+              receipt: completion.outcomeReceipt,
+            });
+          } catch (error) {
+            if (!(error instanceof PlaybookSemanticCandidateStructureError)) {
+              throw error;
+            }
+            unresolvedGovernedEvidence(
+              boundary.boundaryId,
+              'corrective semantic candidate is invalid',
+            );
+            governedEvidenceByBoundaryId.set(boundary.boundaryId, {
+              finalText,
+              ...(retainedCandidate === undefined
+                ? {}
+                : { semanticCandidate: retainedCandidate }),
+            });
+            return {
+              finalText,
+              ...(retainedCandidate === undefined
+                ? {}
+                : { semanticCandidate: retainedCandidate }),
+              unresolved: true as const,
+            };
+          }
+        }
+
+        if (reconciliation === undefined) {
+          throw new Error(
+            'DECIDE semantic reconciliation produced no decision',
+          );
+        }
+        const semanticCandidate = snapshotJsonValue(
+          reconciliation.evidence.semanticCandidate,
+          'DECIDE governed semantic candidate',
+        );
+        governedEvidenceByBoundaryId.set(boundary.boundaryId, {
+          finalText,
+          semanticCandidate,
+        });
+        if (reconciliation.status === 'unresolved') {
+          unresolvedGovernedEvidence(
+            boundary.boundaryId,
+            reconciliation.reason,
+          );
+          return { finalText, semanticCandidate, unresolved: true as const };
+        }
+
+        const output = reconciliation.output as unknown as PlayerOutput;
+        governedOutputsByBoundaryId.set(boundary.boundaryId, output);
+        if (reconciliation.status !== 'deferred') {
+          return { finalText, semanticCandidate };
+        }
+        if (
+          output.guard !== 'needsBossReply' ||
+          typeof output.question !== 'string' ||
+          output.question.trim() === ''
+        ) {
+          throw new TypeError(
+            'DECIDE deferred outcome must carry one exact Boss question',
+          );
+        }
+        const pendingQuestion: PlaybookPendingBossQuestion = {
+          questionId: input.stateId,
+          asker: { kind: 'role', roleId },
+          question: output.question,
+          sourceItem: input.sourceItem,
+        };
+        return {
+          finalText,
+          semanticCandidate,
+          deferred: {
+            operationId: operationId ?? randomUUID(),
+            pendingQuestion,
+            playerContinuation: snapshotJsonValue(
+              selectPlayerResume(roleId, playerId),
+              'DECIDE deferred player continuation',
+            ),
+          },
+        };
+      });
+      if (queued === undefined) {
+        throw new Error('DECIDE semantic completion produced no evidence');
+      }
+      return queued;
+    };
+
+  const acknowledgeGovernedPlayerResult = (
+    value: DecideRepositoryExclusiveResult<PlayerResult>,
+    boundaryId: string,
+  ): PlayerResult => {
+    const ledger = assertPlaybookEffectLedger(
+      value.effectLedger,
+      'DECIDE repository settlement effect ledger',
+    );
+    const completed = ledger.boundaries.find(
+      (candidate) => candidate.boundaryId === boundaryId,
+    );
+    if (
+      completed === undefined ||
+      completed.physicalReceipt === undefined ||
+      stableJson(completed.physicalReceipt, 'DECIDE completed receipt') !==
+        stableJson(value.receipt, 'DECIDE acknowledged receipt')
+    ) {
+      throw new TypeError(
+        'DECIDE repository settlement did not acknowledge its completed boundary',
+      );
+    }
+    const expectedEvidence = governedEvidenceByBoundaryId.get(boundaryId);
+    const expectedReceipts = governedReceiptsByBoundaryId.get(boundaryId);
+    if (
+      expectedReceipts !== undefined &&
+      stableJson(
+        completed.physicalReceipt,
+        'DECIDE completed physical receipt',
+      ) !==
+        stableJson(
+          expectedReceipts.physicalReceipt,
+          'DECIDE reconciled physical receipt',
+        )
+    ) {
+      throw new TypeError(
+        'DECIDE repository settlement changed the physical receipt used during reconciliation',
+      );
+    }
+    if (
+      expectedEvidence !== undefined &&
+      (completed.finalText !== expectedEvidence.finalText ||
+        (expectedEvidence.semanticCandidate === undefined
+          ? completed.semanticCandidate !== undefined
+          : completed.semanticCandidate === undefined ||
+            stableJson(
+              completed.semanticCandidate,
+              'DECIDE completed semantic candidate',
+            ) !==
+              stableJson(
+                expectedEvidence.semanticCandidate,
+                'DECIDE expected semantic candidate',
+              )))
+    ) {
+      throw new TypeError(
+        'DECIDE repository settlement did not acknowledge its exact governed evidence',
+      );
+    }
+    governedEvidenceByBoundaryId.delete(boundaryId);
+    governedReceiptsByBoundaryId.delete(boundaryId);
+    synchronizeDeferredProjection(ledger);
+    if (value.operation.status === 'rejected') {
+      throw value.operation.reason;
+    }
+    const result = validatePlayerResult(value.operation.value);
+    const output = governedOutputsByBoundaryId.get(boundaryId);
+    const failure = governedFailuresByBoundaryId.get(boundaryId);
+    if (expectedReceipts !== undefined) {
+      const continued =
+        'status' in value && value.status === 'continued'
+          ? (value as DecideRepositoryDeferredContinuationResult<PlayerResult>)
+          : undefined;
+      const acknowledgedOutcomeReceipt =
+        continued === undefined ? value.receipt : continued.logicalReceipt;
+      if (
+        acknowledgedOutcomeReceipt !== undefined &&
+        stableJson(
+          acknowledgedOutcomeReceipt,
+          'DECIDE acknowledged outcome receipt',
+        ) !==
+          stableJson(
+            expectedReceipts.outcomeReceipt,
+            'DECIDE reconciled outcome receipt',
+          )
+      ) {
+        throw new TypeError(
+          'DECIDE repository settlement changed the outcome receipt used during reconciliation',
+        );
+      }
+      if (
+        continued !== undefined &&
+        output !== undefined &&
+        output.guard !== 'needsBossReply' &&
+        acknowledgedOutcomeReceipt === undefined
+      ) {
+        throw new TypeError(
+          'DECIDE completed deferred continuation omitted its reconciled logical receipt',
+        );
+      }
+    }
+    governedOutputsByBoundaryId.delete(boundaryId);
+    governedFailuresByBoundaryId.delete(boundaryId);
+    const linkedOperationId = completed.logicalOperationId;
+    if (value.deferredStatus === 'unresolved') {
+      if (linkedOperationId === undefined) {
+        throw new TypeError(
+          'DECIDE unresolved deferred settlement omitted its logical operation',
+        );
+      }
+      deferredOperationId = linkedOperationId;
+      hiddenDeferredOperationId = linkedOperationId;
+    } else if (value.deferredStatus === 'bound') {
+      if (linkedOperationId === undefined) {
+        throw new TypeError(
+          'DECIDE bound deferred settlement omitted its logical operation',
+        );
+      }
+      deferredOperationId = linkedOperationId;
+      hiddenDeferredOperationId = undefined;
+    } else if (
+      'status' in value &&
+      value.status === 'continued' &&
+      (value as { readonly logicalReceipt?: PlaybookRepositoryReceipt })
+        .logicalReceipt === undefined &&
+      linkedOperationId !== undefined
+    ) {
+      deferredOperationId = linkedOperationId;
+      hiddenDeferredOperationId = linkedOperationId;
+    } else if (linkedOperationId !== undefined) {
+      deferredOperationId = undefined;
+      hiddenDeferredOperationId = undefined;
+    }
+    if (failure !== undefined) throw failure;
+    if (value.deferredStatus === 'unresolved') {
+      throw new Error(
+        'DECIDE deferred repository settlement remains unresolved',
+      );
+    }
+    if (output !== undefined) {
+      governedPlayerOutputs.set(result, output);
+    } else if (
+      result.status === 'ok' &&
+      !isEmptyFinalText(result.finalText)
+    ) {
+      throw new Error(
+        'DECIDE governed player result has no reconciled semantic output',
+      );
+    }
+    return result;
+  };
+
+  const shouldRunProposalCohort = (input: PlayerInput): boolean => {
+    if (
+      input.stateId !== PROPOSAL_STATE_BY_ROLE[input.role] ||
+      completedProposalCohortTurnId === currentTurnId
+    ) {
+      return false;
+    }
+    const state = currentState();
+    return Object.values(PROPOSAL_STATE_BY_ROLE).every((stateId) =>
+      state.activeStateIds.includes(stateId),
+    );
+  };
+
+  const settleProposalCohort = async (): Promise<void> => {
+    const members = Object.fromEntries(
+      ROLE_IDS.map((roleId) => [roleId, pendingProposalCohort.get(roleId)]),
+    ) as Record<RoleId, PendingProposalCohortMember | undefined>;
+    const turnId = currentTurnId;
+    const cohortSignal = currentSignal;
+    const cohortOperations = new AbortController();
+    const completionOrder: RoleId[] = [];
+    try {
+      if (
+        turnId === undefined ||
+        cohortSignal === undefined ||
+        members.coder === undefined ||
+        members.reviewer === undefined
+      ) {
+        throw new Error(
+          'DECIDE proposal cohort started without both governed members',
+        );
+      }
+      for (const roleId of ROLE_IDS) members[roleId]!.signal.throwIfAborted();
+      const operations = Object.fromEntries(
+        ROLE_IDS.map((roleId) => [
+          roleId,
+          async () => {
+            const member = members[roleId]!;
+            try {
+              const operationSignal = combineSignals(
+                member.signal,
+                cohortOperations.signal,
+              );
+              const envelope = await runPlayerCall(
+                member.input,
+                operationSignal,
+                { callId: member.callId },
+              );
+              member.envelope = envelope;
+              if (
+                envelope.result.status !== 'ok' &&
+                !cohortOperations.signal.aborted
+              ) {
+                cohortOperations.abort(
+                  new Error(
+                    `DECIDE proposal cohort ${roleId} returned status ${JSON.stringify(envelope.result.status)}`,
+                  ),
+                );
+              }
+              return envelope.result;
+            } catch (error) {
+              if (!cohortOperations.signal.aborted) {
+                cohortOperations.abort(error);
+              }
+              throw error;
+            } finally {
+              completionOrder.push(roleId);
+            }
+          },
+        ]),
+      ) as unknown as Readonly<
+        Record<RoleId, () => Promise<PlayerResult>>
+      >;
+      const invocationId = randomUUID();
+      const settled = await deferredEffects.repository.runCohort({
+        signal: cohortSignal,
+        invocationId,
+        roleIds: ROLE_IDS,
+        dispositionsByRole: {
+          coder: ['unchanged'],
+          reviewer: ['unchanged'],
+        },
+        effectBoundaries: {
+          coder: members.coder.effectBoundary,
+          reviewer: members.reviewer.effectBoundary,
+        },
+        operations,
+        completeEffectBoundary: (completion) => {
+          const member = members[completion.roleId];
+          if (member === undefined) {
+            throw new TypeError(
+              `DECIDE proposal cohort completed unknown role ${String(completion.roleId)}`,
+            );
+          }
+          return completionEvidenceFor(
+            member.input,
+            completion.roleId,
+            resolvedPlayerId(completion.roleId),
+            member.signal,
+          )(completion);
+        },
+      });
+      if (settled.invocationId !== invocationId) {
+        throw new TypeError(
+          'DECIDE repository cohort changed its invocation identity',
+        );
+      }
+      const releaseOrder = [
+        ...completionOrder,
+        ...ROLE_IDS.filter((roleId) => !completionOrder.includes(roleId)),
+      ];
+      const acknowledgedResults = new Map<RoleId, PlayerResult>();
+      const acknowledgementFailures: unknown[] = [];
+      for (const roleId of releaseOrder) {
+        const member = members[roleId]!;
+        try {
+          const result = acknowledgeGovernedPlayerResult(
+            {
+              operation: settled.operations[roleId],
+              receipt: settled.receipts[roleId],
+              effectLedger: settled.effectLedger,
+            },
+            member.effectBoundary.boundaryId,
+          );
+          if (member.envelope === undefined) {
+            throw new TypeError(
+              `DECIDE repository cohort omitted its ${roleId} invocation`,
+            );
+          }
+          acknowledgedResults.set(roleId, result);
+        } catch (error) {
+          acknowledgementFailures.push(error);
+        }
+      }
+      if (acknowledgementFailures.length > 0) {
+        for (const result of acknowledgedResults.values()) {
+          governedPlayerOutputs.delete(result);
+        }
+        throw acknowledgementFailures.length === 1
+          ? acknowledgementFailures[0]
+          : new AggregateError(
+              acknowledgementFailures,
+              'DECIDE proposal cohort reconciliation failed',
+            );
+      }
+      for (const roleId of releaseOrder) {
+        const member = members[roleId]!;
+        const result = acknowledgedResults.get(roleId);
+        if (member.envelope === undefined || result === undefined) {
+          throw new Error(
+            `DECIDE proposal cohort lost its ${roleId} acknowledgement`,
+          );
+        }
+        member.result.resolve({ ...member.envelope, result });
+      }
+    } catch (error) {
+      for (const member of Object.values(members)) member?.result.reject(error);
+    } finally {
+      completedProposalCohortTurnId = turnId;
+      pendingProposalCohort.clear();
+      activeProposalCohort = undefined;
+    }
+  };
+
+  const queueProposalCohortMember = (
+    input: PlayerInput,
+    signal: AbortSignal,
+  ): Promise<DeferredContinuationEnvelope> => {
+    if (pendingProposalCohort.has(input.role)) {
+      throw new Error(
+        `DECIDE proposal cohort already registered role ${input.role}`,
+      );
+    }
+    const callId = `player-${++playerCallSequence}`;
+    const member: PendingProposalCohortMember = {
+      input,
+      signal,
+      callId,
+      effectBoundary: governedBoundarySeed(input, callId),
+      result: deferredValue<DeferredContinuationEnvelope>(),
+    };
+    pendingProposalCohort.set(input.role, member);
+    if (pendingProposalCohort.size === ROLE_IDS.length) {
+      if (activeProposalCohort !== undefined) {
+        throw new Error('DECIDE proposal cohort was started more than once');
+      }
+      activeProposalCohort = settleProposalCohort();
+    }
+    return member.result.promise;
+  };
+
+  const callPlayer = (
+    input: PlayerInput,
+    signal: AbortSignal,
+  ): Promise<DeferredContinuationEnvelope> => {
+    const invocation = async (): Promise<DeferredContinuationEnvelope> => {
+      const active = activeDeferredContinuation;
+      if (active === undefined && hasUnresolvedReconciliation()) {
+        throw new Error(
+          'DECIDE governed semantic reconciliation remains unresolved',
+        );
+      }
+      if (active !== undefined) {
+        if (
+          active.effectBoundary.runtimeSessionId !==
+            requireSessionIdentity().sessionId ||
+          active.effectBoundary.turnId !== currentTurnId ||
+          active.effectBoundary.roleId !== input.role ||
+          active.effectBoundary.sourceStateId !== input.stateId ||
+          active.playerContinuation === undefined
+        ) {
+          throw new TypeError(
+            'DECIDE deferred continuation did not invoke its bound player boundary',
+          );
+        }
+        active.input = input;
+        active.playerId = resolvedPlayerId(input.role);
+        try {
+          const envelope = await runPlayerCall(input, signal, {
+            callId: active.effectBoundary.callId,
+            resume: active.playerContinuation,
+          });
+          active.result.resolve(envelope.result);
+          const acknowledgedResult = await active.acknowledged.promise;
+          return { ...envelope, result: acknowledgedResult };
+        } catch (error) {
+          active.result.reject(error);
+          try {
+            await active.acknowledged.promise;
+          } catch (acknowledgementError) {
+            throw acknowledgementError;
+          }
+          throw error;
+        }
+      }
+
+      if (shouldRunProposalCohort(input)) {
+        return queueProposalCohortMember(input, signal);
+      }
+
+      const callId = `player-${++playerCallSequence}`;
+      const effectBoundary = governedBoundarySeed(input, callId);
+      let envelope: DeferredContinuationEnvelope | undefined;
+      const settled = await deferredEffects.repository.runExclusive({
+        signal,
+        effectBoundary,
+        operation: async () => {
+          envelope = await runPlayerCall(input, signal, { callId });
+          return envelope.result;
+        },
+        completeEffectBoundary: completionEvidenceFor(
+          input,
+          input.role,
+          resolvedPlayerId(input.role),
+          signal,
+        ),
+      });
+      const result = acknowledgeGovernedPlayerResult(
+        settled,
+        effectBoundary.boundaryId,
+      );
+      if (envelope === undefined) {
+        throw new TypeError(
+          'DECIDE repository settlement omitted its player invocation',
+        );
+      }
+      return { ...envelope, result };
+    };
+    return trackBoundaryCall(invocation());
+  };
+
+  const player = fromPromise<PlayerOutput, PlayerInput>(
+    async ({ input, signal }) => {
+      const combined = combineSignals(signal, currentSignal);
+      const settlementAborts = abortReasonClassifier(combined);
+      try {
+        // XState starts invoked actors while publishing the entering snapshot.
+        // Yield through the runtime emission queue before crossing the player
+        // boundary so state trace/status always precede its call-start trace.
+        combined.throwIfAborted();
+        try {
+          await flush(settlementAborts);
+        } catch (error) {
+          latchControlPlaneError(error, combined);
+          throw error;
+        }
+        combined.throwIfAborted();
+
+        let { roleId, playerId, callId, result } = await callPlayer(
+          input,
+          combined,
+        );
+        if (
+          result.status === 'ok' &&
+          isEmptyFinalText(result.finalText) &&
+          automaticReplayPolicy.allowsEmptyOkCorrection(
+            requireSessionIdentity().sessionId,
+            callId,
+          )
+        ) {
+          // DR-028: an `ok` result whose finalText is missing, empty, or
+          // whitespace-only earns exactly one corrective re-ask — the same
+          // composed call repeated, traced by runPlayerCall as its own
+          // player-call pair, with the resume selection re-read from the
+          // token map the first result left (PBRT-38). An abort that lands
+          // between the two calls ends the turn without the re-ask (aborts
+          // are never retried), and a rejecting finish emission rejects
+          // `callPlayer` itself, so it never reaches this branch (PBRT-47).
+          combined.throwIfAborted();
+          ({ roleId, playerId, callId, result } = await callPlayer(
+            input,
+            combined,
+          ));
+        }
+        if (result.status !== 'ok') {
+          throw new Error(
+            `${roleLabel(roleId)}${
+              playerId === undefined ? '' : ` (${playerId})`
+            } returned status "${result.status}"${
+              result.error ? `: ${result.error}` : ''
+            }`,
+          );
+        }
+        const finalText = result.finalText ?? '';
+        if (isEmptyFinalText(finalText)) {
+          throw new Error(
+            `${roleLabel(roleId)}${
+              playerId === undefined ? '' : ` (${playerId})`
+            } returned status "ok" with no finalText`,
+          );
+        }
+        combined.throwIfAborted();
+
+        const governedOutput = governedPlayerOutputs.get(result);
+        if (governedOutput !== undefined) {
+          governedPlayerOutputs.delete(result);
+          return governedOutput;
+        }
+        throw new Error(
+          'DECIDE governed player result was not reconciled against repository evidence',
+        );
+      } finally {
+        actorSettlementAborts.push(settlementAborts);
+      }
+    },
+  );
+
+  nestedBridge = createNestedPlaybookBridge<PlaybookInput>({
+    nextCallId: () => `playbook-${++playbookCallSequence}`,
+    getBoundarySignal: () => currentSignal,
+    callPlaybook: (request, signal) =>
+      trackBoundaryCall(
+        Promise.resolve(requirePorts().callPlaybook(request, signal)),
+      ),
+    emitStarted: async (event, aborts) => {
+      playbookCallTurnIds.set(event.callId, currentTurnId);
+      await emitTrace(
+        'playbook.call.started',
+        {
+          stateId: event.stateId,
+          playbookId: event.playbookId,
+          text: event.text,
+        },
+        {
+          ...(currentTurnId === undefined ? {} : { turnId: currentTurnId }),
+          callId: event.callId,
+        },
+        aborts,
+      );
+    },
+    emitFinished: async (event, aborts) => {
+      const turnId = playbookCallTurnIds.get(event.callId);
+      try {
+        await emitTrace(
+          'playbook.call.finished',
+          {
+            stateId: event.stateId,
+            playbookId: event.playbookId,
+            text: event.text,
+            result: event.result,
+          },
+          {
+            ...(turnId === undefined ? {} : { turnId }),
+            callId: event.callId,
+          },
+          aborts,
+        );
+      } finally {
+        playbookCallTurnIds.delete(event.callId);
+      }
+    },
+    drain: flush,
+    bindResumeSignal: (signal, aborts) => {
+      currentSignal = signal;
+      currentAborts = aborts ?? abortReasonClassifier(signal);
+    },
+    bindActorSettlement: (aborts) => {
+      actorSettlementAborts.push(aborts);
+    },
+    onControlPlaneError: (error, aborts) => {
+      if (
+        !aborts?.isAbortReason(error) &&
+        !currentAborts?.isAbortReason(error)
+      ) {
+        controlPlaneError ??= error;
+      }
+    },
+    onBackgroundError: (error, aborts) => {
+      if (!aborts?.isAbortReason(error)) {
+        collectFailure(emissionFailures, error);
+      }
+    },
   });
 
+  const providedMachine = decideMachine.provide({
+    actors: { player, playbook: nestedBridge.actorLogic },
+  });
+
+  const consumeActorSettlementAborts = (
+    forSnapshot = false,
+  ): AbortReasonClassifier | undefined => {
+    const aborts = actorSettlementAborts.shift() ?? actorSettlementErrorAborts;
+    actorSettlementErrorAborts = undefined;
+    if (forSnapshot && aborts !== undefined) {
+      actorSettlementErrorAborts = aborts;
+      queueMicrotask(() => {
+        if (actorSettlementErrorAborts === aborts) {
+          actorSettlementErrorAborts = undefined;
+        }
+      });
+    }
+    return aborts;
+  };
+
   const inspect = (event: InspectionEvent): void => {
-    if (event.type !== '@xstate.snapshot') return;
     if (actor === undefined || event.actorRef !== actor) return;
     if (suppressInspectionEmissions) return;
+    if (event.type === '@xstate.action') {
+      try {
+        acceptedOutcomeConsumer.capture(event.action);
+      } catch (error) {
+        latchInspectionError(error);
+      }
+      return;
+    }
+    if (event.type !== '@xstate.snapshot') return;
+    const settlementAborts = consumeActorSettlementAborts(true);
     try {
       const snapshot = event.snapshot as SnapshotFrom<typeof decideMachine>;
       const state = normalizePlaybookSnapshot(snapshot);
       const prior = previousState ?? state;
+      let acceptedOutcomes: readonly AcceptedOutcomeReceipt[] = [];
+      try {
+        acceptedOutcomes = acceptedOutcomeConsumer.confirm(previousState, state);
+      } catch (error) {
+        latchInspectionError(error);
+      }
       const context = snapshot.context as unknown as Record<string, unknown>;
-      const fsmPayload = telemetryPayload(prior, state, event.event, context);
+      const fsmPayload = telemetryPayload(
+        prior,
+        state,
+        event.event,
+        context,
+        hiddenDeferredOperationId === undefined
+          ? undefined
+          : 'commitCoderProposal',
+      );
       const describedFsmPayload = snapshotJsonValue(
         fsmPayload,
         'described FSM telemetry',
@@ -1482,11 +3380,12 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             topic: TELEMETRY_TOPIC,
             payload: describedFsmPayload,
           }),
+        settlementAborts,
       ).catch(() => undefined);
 
       const priorIds = new Set(previousState?.activeStateIds ?? []);
       previousState = state;
-      const pendingQuestions = pendingQuestionsFromContext(context);
+      const pendingQuestions = visiblePendingQuestionsForState(state, context);
       const bossRelevantStateIds = state.activeStateIds.filter((stateId) =>
         STATUS_STATE_IDS.has(stateId),
       );
@@ -1507,9 +3406,18 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           tracePayload,
           { turnId: currentTurnId },
           (emissionPorts) => emissionPorts.emitStatus(message, data),
+          settlementAborts,
         ).catch(() => undefined);
       };
 
+      for (const acceptedOutcome of acceptedOutcomes) {
+        void enqueueAcceptedOutcomeEmission(
+          acceptedOutcome,
+          state,
+          settlementAborts,
+        ).catch(() => undefined);
+      }
+
       for (const activeStateId of state.activeStateIds) {
         if (
           priorIds.has(activeStateId) ||
@@ -1552,89 +3460,740 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         );
       }
     } catch (error) {
-      latchInspectionError(error);
+      acceptedOutcomeConsumer.reset();
+      latchInspectionError(error, settlementAborts);
+    }
+  };
+
+  const createRuntimeActor = (machineSnapshot?: JsonValue): void => {
+    previousState = undefined;
+    acceptedOutcomeConsumer.reset();
+    // DR-014 §1: a restore rehydrates the persisted machine snapshot;
+    // XState derives context/value from it and ignores `input` then.
+    actor = createActor(providedMachine, {
+      input: fsmInput,
+      ...(machineSnapshot === undefined
+        ? {}
+        : {
+            snapshot: machineSnapshot as unknown as SnapshotFrom<
+              typeof decideMachine
+            >,
+          }),
+      inspect,
+    });
+    // A synchronous FSM action throw errors the actor without any pending
+    // boundary await to observe it; unobserved, XState would surface it via
+    // reportUnhandledError as an uncaughtException. Observe it here: latch
+    // it as a control error while a turn signal is active (unless it is
+    // the abort reason itself), otherwise collect it with the emission
+    // failures (slc/link.md §Abort).
+    actor.subscribe({
+      error: (error) =>
+        latchInspectionError(error, consumeActorSettlementAborts()),
+    });
+  };
+
+  // PBRT-6: the single seam that stops this runtime's actor. Stopping a
+  // still-running actor fires one more `@xstate.snapshot` for the *unchanged*
+  // state value with `status: 'stopped'`; `inspect` cannot tell that disposal
+  // artifact from a state entry, so unsuppressed it re-emits the parked
+  // state's telemetry and a phantom self-loop transition. Suppression is a
+  // property of stopping, not a rule each caller must remember — every stop
+  // goes through here so no later site can reintroduce the omission.
+  const stopActor = (): void => {
+    if (!actor) return;
+    suppressInspectionEmissions = true;
+    acceptedOutcomeConsumer.reset();
+    actor.stop();
+  };
+
+  const startActor = (): void => {
+    createRuntimeActor();
+    // A fresh actor's emissions are real state entries again.
+    suppressInspectionEmissions = false;
+    actor?.start();
+  };
+
+  const driveToQuiescence = async (): Promise<void> => {
+    const live = actor;
+    if (!live) throw new Error('decide runtime: actor is not initialized');
+    await waitForPlaybookQuiescence(live, { pendingCalls: nestedBridge });
+  };
+
+  const classify = async (
+    text: string,
+    signal: AbortSignal,
+  ): Promise<DecideEvent | { type: 'NO_ACTION' } | null> => {
+    const live = actor;
+    if (!live) throw new Error('decide runtime: actor is not initialized');
+    refreshReconciliationProjection();
+    if (hasUnresolvedReconciliation()) return null;
+    const snapshot = live.getSnapshot() as SnapshotFrom<typeof decideMachine>;
+    const context = snapshot.context as unknown as Record<string, unknown>;
+    const state = normalizePlaybookSnapshot(snapshot, {
+      pendingCall: nestedBridge.getPendingCall(),
+    });
+    const pendingQuestions = visiblePendingQuestionsForState(state, context);
+    const failed = state.activeStateIds.includes('failed');
+    if (
+      pendingQuestions.length === 0 &&
+      (snapshot.status === 'done' ||
+        state.activeStateIds.includes('ready') ||
+        (failed &&
+          automaticReplayPolicy.allowsFailureStateRetry()))
+    ) {
+      return { type: 'START_DECIDE', callerTopic: text };
+    }
+    if (pendingQuestions.length === 0) return null;
+    const prompt = buildClassifierPrompt(text, {
+      state,
+      pendingQuestions,
+    });
+    const raw = await callJudge(
+      prompt,
+      signal,
+      'boss-input-classification',
+      state.stateId,
+    );
+    return parseClassification(
+      raw,
+      text,
+      pendingQuestions.map(({ questionId }) => questionId),
+    );
+  };
+
+  const deferredBoundarySeed = (
+    operationId: string,
+    callId: string,
+  ): DecideEffectBoundarySeed => {
+    const operation = effectLedgerMirror.logicalOperations.find(
+      (candidate) => candidate.operationId === operationId,
+    );
+    const latestBoundaryId = operation?.boundaryIds.at(-1);
+    const priorBoundary = effectLedgerMirror.boundaries.find(
+      (candidate) => candidate.boundaryId === latestBoundaryId,
+    );
+    if (operation === undefined || priorBoundary === undefined) {
+      throw new TypeError(
+        'DECIDE deferred logical operation has no linked physical boundary',
+      );
+    }
+    if (
+      currentTurnId === undefined ||
+      !Number.isSafeInteger(currentTurnId) ||
+      currentTurnId <= 0
+    ) {
+      throw new Error(
+        'DECIDE deferred continuation requires an active positive turn id',
+      );
+    }
+    return {
+      boundaryId: randomUUID(),
+      runtimeSessionId: requireSessionIdentity().sessionId,
+      turnId: currentTurnId,
+      callId,
+      roleId: priorBoundary.roleId,
+      sourceStateId: priorBoundary.sourceStateId,
+      sourceOutcomeSchema: snapshotJsonValue(
+        priorBoundary.sourceOutcomeSchema,
+        'DECIDE deferred source outcome schema',
+      ),
+      dispositions: [...priorBoundary.dispositions],
+      correctionBudget: { limit: 1, spent: false },
+    };
+  };
+
+  type PreparedDeferredContinuation =
+    | { readonly proceed: false }
+    | { readonly proceed: true; readonly acknowledgement: Promise<void> };
+
+  const prepareDeferredContinuation = async (
+    signal: AbortSignal,
+    resumeEvent: Extract<DecideEvent, { readonly type: 'BOSS_REPLY' }>,
+  ): Promise<PreparedDeferredContinuation> => {
+    if (deferredEffects === undefined || deferredOperationId === undefined) {
+      throw new TypeError(
+        'DECIDE deferred Boss reply has no host-bound logical operation',
+      );
+    }
+    const operationId = deferredOperationId;
+    const callId = `player-${++playerCallSequence}`;
+    const effectBoundary = deferredBoundarySeed(operationId, callId);
+    const active: ActiveDeferredContinuation = {
+      operationId,
+      effectBoundary,
+      result: deferredValue<PlayerResult>(),
+      acknowledged: deferredValue<PlayerResult>(),
+    };
+    type Readiness =
+      | { readonly status: 'ready' }
+      | {
+          readonly status: 'settled';
+          readonly value:
+            | DecideRepositoryDeferredContinuationResult<PlayerResult>
+            | DecideRepositoryDeferredCheckpointMismatch;
+        }
+      | { readonly status: 'rejected'; readonly reason: unknown };
+    const readiness = deferredValue<Readiness>();
+    const repositoryCall = deferredEffects.repository.runDeferred({
+      mode: 'continue',
+      signal,
+      operationId,
+      effectBoundary,
+      operation: async ({ playerContinuation }) => {
+        if (
+          playerContinuation !== false &&
+          (typeof playerContinuation !== 'string' ||
+            playerContinuation.trim() === '')
+        ) {
+          throw new TypeError(
+            'DECIDE bound deferred player continuation is invalid',
+          );
+        }
+        active.playerContinuation = playerContinuation;
+        readiness.resolve({ status: 'ready' });
+        return active.result.promise;
+      },
+      completeEffectBoundary: async (completion) => {
+        if (active.input === undefined) {
+          throw new TypeError(
+            'DECIDE deferred continuation omitted its authored player input',
+          );
+        }
+        return completionEvidenceFor(
+          active.input,
+          active.input.role,
+          active.playerId,
+          signal,
+          operationId,
+        )(completion);
+      },
+    });
+    void repositoryCall.then(
+      (value) => readiness.resolve({ status: 'settled', value }),
+      (reason: unknown) => readiness.resolve({ status: 'rejected', reason }),
+    );
+    const prepared = await readiness.promise;
+    if (prepared.status === 'rejected') throw prepared.reason;
+    if (prepared.status === 'settled') {
+      synchronizeDeferredProjection(
+        assertPlaybookEffectLedger(
+          prepared.value.effectLedger,
+          'DECIDE deferred checkpoint-mismatch effect ledger',
+        ),
+      );
+      hiddenDeferredOperationId = operationId;
+      return { proceed: false };
+    }
+
+    activeDeferredContinuation = active;
+    const acknowledgement = repositoryCall.then(
+      (value) => {
+        if (value.status !== 'continued') {
+          throw new TypeError(
+            'DECIDE deferred repository changed status after starting its operation',
+          );
+        }
+        const result = acknowledgeGovernedPlayerResult(
+          value,
+          effectBoundary.boundaryId,
+        );
+        if (hiddenDeferredOperationId === undefined) {
+          suppressInspectionEmissions = false;
+          const live = actor;
+          if (live === undefined) {
+            throw new Error(
+              'DECIDE deferred acknowledgement lost its runtime actor',
+            );
+          }
+          // Entry into the governed continuation was hidden until its durable
+          // effect acknowledgement. Publish that exact current root snapshot
+          // before releasing the actor output, so an accepted-outcome marker
+          // is confirmed against commitCoderProposal rather than the earlier
+          // awaitBossReply snapshot.
+          inspect({
+            type: '@xstate.snapshot',
+            actorRef: live,
+            event: resumeEvent,
+            snapshot: live.getSnapshot(),
+          } as unknown as InspectionEvent);
+        }
+        active.acknowledged.resolve(result);
+      },
+      (error: unknown) => {
+        active.acknowledged.reject(error);
+        throw error;
+      },
+    ).catch((error: unknown) => {
+      active.acknowledged.reject(error);
+      throw error;
+    });
+    return { proceed: true, acknowledgement };
+  };
+
+  const parkDeferredContinuation = async (
+    signal: AbortSignal,
+  ): Promise<void> => {
+    if (deferredEffects === undefined || deferredOperationId === undefined) {
+      return;
+    }
+    const operationId = deferredOperationId;
+    const parked = await deferredEffects.repository.runDeferred({
+      mode: 'park',
+      signal,
+      operationId,
+    });
+    synchronizeDeferredProjection(
+      assertPlaybookEffectLedger(
+        parked.effectLedger,
+        'DECIDE deferred park effect ledger',
+      ),
+    );
+    hiddenDeferredOperationId = operationId;
+  };
+
+  const restoreDeferredReconciliation = async (
+    operationId: string,
+    signal: AbortSignal,
+    publishQuestion: boolean,
+  ): Promise<'restored' | 'checkpoint-mismatch' | 'ineligible'> => {
+    const restored = await deferredEffects.repository.runDeferred({
+      mode: 'restore',
+      signal,
+      operationId,
+    });
+    synchronizeDeferredProjection(
+      assertPlaybookEffectLedger(
+        restored.effectLedger,
+        'DECIDE deferred restoration effect ledger',
+      ),
+    );
+    if (restored.status === 'parked') {
+      throw new TypeError(
+        'DECIDE deferred restoration returned an invalid parked status',
+      );
+    }
+    if (restored.status !== 'restored') {
+      if (hiddenDeferredOperationId !== operationId) {
+        throw new TypeError(
+          'DECIDE unresolved deferred restoration lost its operation identity',
+        );
+      }
+      return restored.status;
+    }
+    if (hiddenDeferredOperationId !== undefined) {
+      throw new TypeError(
+        'DECIDE restored deferred operation remained unresolved',
+      );
+    }
+    if (openDeferredOperation()?.operationId !== operationId) {
+      throw new TypeError(
+        'DECIDE restored deferred operation is not the current bound wait',
+      );
+    }
+    const live = actor;
+    if (live === undefined) {
+      throw new Error('decide runtime: init(session) must be called first');
+    }
+    const state = currentState();
+    const context = (
+      live.getSnapshot() as SnapshotFrom<typeof decideMachine>
+    ).context as unknown as Record<string, unknown>;
+    const pending = questionForWaitState(
+      'awaitBossReply',
+      visiblePendingQuestionsForState(state, context),
+    );
+    const operation = openDeferredOperation();
+    const projectedPending =
+      pending === undefined
+        ? undefined
+        : {
+            questionId: pending.questionId,
+            asker: pending.asker,
+            question: pending.question,
+            sourceItem: pending.sourceItem,
+          };
+    if (
+      pending === undefined ||
+      operation?.pendingQuestion === undefined ||
+      stableJson(
+        projectedPending,
+        'DECIDE restored FSM pending question',
+      ) !==
+        stableJson(
+          operation.pendingQuestion,
+          'DECIDE restored deferred pending question',
+        )
+    ) {
+      throw new TypeError(
+        'DECIDE restored deferred wait does not equal its FSM question',
+      );
+    }
+    if (publishQuestion) {
+      await emitBoundaryStatus(
+        `${pending.asker.roleId} asks: ${pending.question}`,
+        state,
+      );
+      await emitBoundaryStatus(
+        `◆ awaiting Boss reply · ${pending.resumeStateId} · ${pending.asker.roleId} · ${pending.sourceItem}`,
+        state,
+      );
+      await flush();
     }
+    return 'restored';
   };
 
-  const createRuntimeActor = (machineSnapshot?: JsonValue): void => {
-    previousState = undefined;
-    // DR-014 §1: a restore rehydrates the persisted machine snapshot;
-    // XState derives context/value from it and ignores `input` then.
-    actor = createActor(providedMachine, {
-      input: fsmInput,
-      ...(machineSnapshot === undefined
-        ? {}
-        : {
-            snapshot: machineSnapshot as unknown as SnapshotFrom<
-              typeof decideMachine
-            >,
-          }),
-      inspect,
-    });
+  type UnresolvedControlCandidate = {
+    readonly action: PlaybookControlAction;
+    readonly kind: 'reconcile' | 'abandon';
+    readonly deferredRestoreOperationId?: string;
   };
+  type UnresolvedControlCandidates = readonly UnresolvedControlCandidate[];
 
-  // PBRT-6: the single seam that stops this runtime's actor. Stopping a
-  // still-running actor fires one more `@xstate.snapshot` for the *unchanged*
-  // state value with `status: 'stopped'`; `inspect` cannot tell that disposal
-  // artifact from a state entry, so unsuppressed it re-emits the parked
-  // state's telemetry and a phantom self-loop transition. Suppression is a
-  // property of stopping, not a rule each caller must remember — every stop
-  // goes through here so no later site can reintroduce the omission.
-  const stopActor = (): void => {
-    if (!actor) return;
-    suppressInspectionEmissions = true;
-    actor.stop();
+  const unresolvedControlCandidates = (): UnresolvedControlCandidates => {
+    if (!hasUnresolvedReconciliation()) return [];
+    const operation =
+      hiddenDeferredOperationId === undefined
+        ? undefined
+        : effectLedgerMirror.logicalOperations.find(
+            ({ operationId }) =>
+              operationId === hiddenDeferredOperationId,
+          );
+    return [
+      {
+        action: {
+          id: UNRESOLVED_EFFECT_RECONCILIATION_ACTION_ID,
+          label: 'Retry unresolved effect reconciliation',
+        },
+        kind: 'reconcile',
+        ...(operation?.checkpointRestorationEligible === true
+          ? { deferredRestoreOperationId: operation.operationId }
+          : {}),
+      },
+      {
+        action: {
+          id: UNRESOLVED_EFFECT_ABANDONMENT_ACTION_ID,
+          label: 'Abandon unresolved workflow attempt',
+        },
+        kind: 'abandon',
+      },
+    ];
   };
 
-  const startActor = (): void => {
-    createRuntimeActor();
-    // A fresh actor's emissions are real state entries again.
-    suppressInspectionEmissions = false;
-    actor?.start();
+  const deriveControlCandidates = (): UnresolvedControlCandidates => {
+    const state = currentState();
+    if (
+      state.status !== 'active' ||
+      !state.quiescent ||
+      nestedBridge.getPendingCall() !== undefined
+    ) {
+      return [];
+    }
+    return unresolvedControlCandidates();
   };
 
-  const driveToQuiescence = async (): Promise<void> => {
+  const describeControlView = (): PlaybookControlView => {
+    if (disposed || disposalPromise !== undefined) {
+      throw new Error('decide runtime: runtime is disposing or disposed');
+    }
     const live = actor;
-    if (!live) throw new Error('decide runtime: actor is not initialized');
-    await waitForPlaybookQuiescence(live, { pendingCalls: nestedBridge });
+    if (live === undefined || sessionIdentity === undefined) {
+      throw new Error(
+        'decide runtime: init(session) must be called before describe',
+      );
+    }
+    if (currentSignal !== undefined || currentTurnId !== undefined) {
+      throw new Error('decide runtime: another runtime turn is active');
+    }
+    refreshReconciliationProjection();
+    const state = currentState();
+    const context = (
+      live.getSnapshot() as SnapshotFrom<typeof decideMachine>
+    ).context as unknown as Record<string, unknown>;
+    const unresolved = hasUnresolvedReconciliation();
+    const pendingQuestions = unresolved
+      ? []
+      : visiblePendingQuestionsForState(state, context).map((pending) =>
+          Object.freeze({
+            questionId: pending.questionId,
+            asker: pending.asker,
+            question: pending.question,
+            sourceItem: pending.sourceItem,
+          }),
+        );
+    const actions = deriveControlCandidates().map(({ action }) => ({
+      ...action,
+    }));
+    const lastError = normalizeErrorFull(context.lastError);
+    const stateDescription =
+      unresolved || state.stateId === undefined
+        ? undefined
+        : STATE_DESCRIPTIONS[state.stateId];
+    return deepFreeze(
+      snapshotJsonValue(
+        {
+          state,
+          ...(stateDescription === undefined ? {} : { stateDescription }),
+          pendingQuestions,
+          ...(lastError === undefined ? {} : { lastError }),
+          actions,
+        },
+        'DECIDE control view',
+      ) as unknown as PlaybookControlView,
+    );
   };
 
-  const classify = async (
-    text: string,
-    signal: AbortSignal,
-  ): Promise<DecideEvent | { type: 'NO_ACTION' } | null> => {
-    const live = actor;
-    if (!live) throw new Error('decide runtime: actor is not initialized');
-    const snapshot = live.getSnapshot() as SnapshotFrom<typeof decideMachine>;
-    const context = snapshot.context as unknown as Record<string, unknown>;
-    const state = normalizePlaybookSnapshot(snapshot, {
-      pendingCall: nestedBridge.getPendingCall(),
-    });
-    const pendingQuestions = pendingQuestionsFromContext(context);
-    if (
-      pendingQuestions.length === 0 &&
-      (snapshot.status === 'done' ||
-        state.activeStateIds.includes('ready') ||
-        state.activeStateIds.includes('failed'))
-    ) {
-      return { type: 'START_DECIDE', callerTopic: text };
+  const normalizedControlError = (error: unknown): NormalizedError =>
+    normalizeErrorFull(error) ?? {
+      name: error instanceof Error ? error.name : 'Error',
+      message: error instanceof Error ? error.message : String(error),
+    };
+
+  const frozenControlReceipt = (
+    receipt: PlaybookControlReceipt,
+  ): PlaybookControlReceipt =>
+    deepFreeze(
+      snapshotJsonValue(
+        receipt,
+        'DECIDE apply receipt',
+      ) as unknown as PlaybookControlReceipt,
+    );
+
+  const applyControlAction = async (input: {
+    actionId: string;
+    key: string;
+    signal: AbortSignal;
+  }): Promise<PlaybookControlReceipt> => {
+    if (input === null || typeof input !== 'object') {
+      throw new TypeError('decide runtime: apply input must be an object');
     }
-    if (pendingQuestions.length === 0) return null;
-    const prompt = buildClassifierPrompt(text, {
-      state,
-      pendingQuestions,
+    const { actionId, key, signal } = input;
+    if (typeof actionId !== 'string' || actionId.length === 0) {
+      throw new TypeError(
+        'decide runtime: apply actionId must be a non-empty string',
+      );
+    }
+    if (typeof key !== 'string' || key.length === 0) {
+      throw new TypeError(
+        'decide runtime: apply key must be a non-empty string',
+      );
+    }
+    if (!(signal instanceof AbortSignal)) {
+      throw new TypeError(
+        'decide runtime: apply signal must be an AbortSignal',
+      );
+    }
+    if (disposed || disposalPromise !== undefined) {
+      throw new Error('decide runtime: runtime is disposing or disposed');
+    }
+    if (actor === undefined || sessionIdentity === undefined) {
+      throw new Error(
+        'decide runtime: init(session) must be called before apply',
+      );
+    }
+    if (currentSignal !== undefined || currentTurnId !== undefined) {
+      throw new Error('decide runtime: another runtime turn is active');
+    }
+    const recorded = appliedControlReceipts.get(key);
+    if (recorded !== undefined) return recorded;
+    signal.throwIfAborted();
+    refreshReconciliationProjection();
+
+    const turnId = ++turnSequence;
+    const callId = `apply-${++applyCallSequence}`;
+    currentTurnId = turnId;
+    currentSignal = signal;
+    currentAborts = abortReasonClassifier(signal);
+    controlPlaneError = undefined;
+    let accepted = false;
+    let receipt: PlaybookControlReceipt | undefined;
+    let operationError: unknown;
+    let settlementError: unknown;
+    let lateDeliveryError: unknown;
+    const position = { turnId, callId };
+    const preAcceptanceFinish = (
+      reason: string,
+    ): Record<string, unknown> => ({
+      actionId,
+      key,
+      disposition: 'rejected',
+      reason,
     });
-    const raw = await callJudge(
-      prompt,
-      signal,
-      'boss-input-classification',
-      state.stateId,
-    );
-    return parseClassification(
-      raw,
-      text,
-      pendingQuestions.map(({ questionId }) => questionId),
-    );
+    try {
+      try {
+        try {
+          await emitTrace(
+            'apply.started',
+            {
+              actionId,
+              key,
+              ...stateIdentity(currentState()),
+            },
+            position,
+            currentAborts,
+          );
+        } catch (error) {
+          latchControlPlaneError(error, signal);
+          try {
+            await emitTrace(
+              'apply.finished',
+              {
+                ...preAcceptanceFinish('apply.started trace sink rejected'),
+                status: isAbortFailure(error, signal) ? 'aborted' : 'error',
+                error: normalizedControlError(error),
+              },
+              position,
+              currentAborts,
+            );
+          } catch {
+            // Preserve the start failure after one best-effort finish attempt.
+          }
+          throw error;
+        }
+        await flush();
+        if (signal.aborted) {
+          try {
+            await emitTrace(
+              'apply.finished',
+              {
+                ...preAcceptanceFinish('aborted before acceptance'),
+                status: 'aborted',
+                error: normalizedControlError(signal.reason),
+              },
+              position,
+              currentAborts,
+            );
+          } catch (error) {
+            // A rejecting abort-finish sink outranks the abort at settlement.
+            settlementError ??= error;
+          }
+        }
+        signal.throwIfAborted();
+        const candidate = deriveControlCandidates().find(
+          ({ action }) => action.id === actionId,
+        );
+        if (candidate === undefined) {
+          receipt = frozenControlReceipt({
+            disposition: 'rejected',
+            reason: `action ${JSON.stringify(actionId)} is not currently advertised`,
+          });
+        } else {
+          // Acceptance is the line after which this boundary always records
+          // and returns a receipt: the requested effect may now exist.
+          accepted = true;
+          try {
+            let run: PlaybookRunResult;
+            if (candidate.kind === 'abandon') {
+              signal.throwIfAborted();
+              run = {
+                outcome: 'unresolved-effect',
+                state: currentState(),
+              };
+            } else {
+              if (candidate.deferredRestoreOperationId !== undefined) {
+                await restoreDeferredReconciliation(
+                  candidate.deferredRestoreOperationId,
+                  signal,
+                  true,
+                );
+              } else {
+                // The host owns receipt reconstruction. Reconciliation only
+                // re-reads its authoritative ledger; it never calls a player
+                // or judge to manufacture missing semantic evidence.
+                refreshReconciliationProjection();
+              }
+              signal.throwIfAborted();
+              run = {
+                outcome: hasUnresolvedReconciliation()
+                  ? 'no-action'
+                  : 'quiescent',
+                state: currentState(),
+              };
+            }
+            if (controlPlaneError !== undefined) throw controlPlaneError;
+            receipt = frozenControlReceipt({
+              disposition: 'executed',
+              run,
+            });
+          } catch (error) {
+            receipt = frozenControlReceipt({
+              disposition: 'failed',
+              error: normalizedControlError(error),
+            });
+          }
+          appliedControlReceipts.set(key, receipt);
+        }
+      } catch (error) {
+        operationError = error;
+      }
+
+      try {
+        await flush();
+      } catch (error) {
+        settlementError = error;
+      }
+      settlementError ??= controlPlaneError;
+      if (accepted && settlementError !== undefined) {
+        receipt = frozenControlReceipt({
+          disposition: 'failed',
+          error: normalizedControlError(settlementError),
+        });
+        appliedControlReceipts.set(key, receipt);
+        settlementError = undefined;
+      }
+
+      if (receipt !== undefined) {
+        const finishFailures: unknown[] = [];
+        try {
+          await emitTrace(
+            'apply.finished',
+            { actionId, key, ...receipt },
+            position,
+            currentAborts,
+          );
+        } catch (error) {
+          if (!accepted || !isAbortFailure(error, signal)) {
+            collectFailure(finishFailures, error);
+          }
+        }
+        try {
+          await flush();
+        } catch (error) {
+          if (!accepted || !isAbortFailure(error, signal)) {
+            collectFailure(finishFailures, error);
+          }
+        }
+        if (finishFailures.length > 0) {
+          const failure =
+            finishFailures.length === 1
+              ? finishFailures[0]
+              : new AggregateError(
+                  finishFailures,
+                  'DECIDE apply settlement emissions failed',
+                );
+          if (accepted) lateDeliveryError = failure;
+          else settlementError = failure;
+        }
+      }
+    } finally {
+      currentSignal = undefined;
+      currentAborts = undefined;
+      currentTurnId = undefined;
+      controlPlaneError = undefined;
+      if (accepted && receipt !== undefined) {
+        appliedControlReceipts.set(key, receipt);
+      }
+    }
+    if (lateDeliveryError !== undefined) {
+      collectFailure(emissionFailures, lateDeliveryError);
+    }
+    if (accepted && receipt !== undefined) return receipt;
+    const failure = settlementError ?? operationError;
+    if (failure !== undefined) throw failure;
+    if (receipt === undefined) {
+      throw new Error('decide runtime: apply produced no receipt');
+    }
+    return receipt;
   };
 
   const resultForSnapshot = (signal?: AbortSignal): PlaybookRunResult => {
@@ -1644,34 +4203,58 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     const pendingCall = nestedBridge.getPendingCall();
     const state = normalizePlaybookSnapshot(snapshot, { pendingCall });
     const context = snapshot.context as unknown as Record<string, unknown>;
-    if (signal?.aborted) {
-      return {
-        outcome: 'aborted',
-        state,
-        ...(signal.reason === undefined
-          ? {}
-          : {
-              error: normalizeErrorFull(signal.reason) ?? {
-                name: 'AbortError',
-                message: String(signal.reason),
-              },
-            }),
-      };
+    const abortedResult = (abortSignal: AbortSignal): PlaybookRunResult => ({
+      outcome: 'aborted',
+      state,
+      ...(abortSignal.reason === undefined
+        ? {}
+        : {
+            error: normalizeErrorFull(abortSignal.reason) ?? {
+              name: 'AbortError',
+              message: String(abortSignal.reason),
+            },
+          }),
+    });
+    if (snapshot.status === 'error') {
+      // An errored actor outranks a coincident abort unless the actor's
+      // error is the abort reason itself (slc/link.md §Abort).
+      const actorError = (snapshot as { error?: unknown }).error;
+      if (
+        actorError !== undefined &&
+        signal !== undefined &&
+        isAbortFailure(actorError, signal)
+      ) {
+        return abortedResult(signal);
+      }
+      throw (
+        actorError ?? new Error('decide runtime actor entered error status')
+      );
     }
+    // Terminal completion outranks a coincident abort (DR-036 §3): reporting
+    // 'aborted' over a completed machine would hide a terminal state that the
+    // next turn silently restarts, duplicating the workflow's side effects.
     if (snapshot.status === 'done') {
       const output = (snapshot as { output?: unknown }).output;
       if (output !== undefined) assertJsonSafe(output, 'terminal output');
+      const stateDescription = state.activeStateIds.includes('done')
+        ? STATE_DESCRIPTIONS.done
+        : state.activeStateIds.includes('reportedReviewFailure')
+          ? STATE_DESCRIPTIONS.reportedReviewFailure
+          : undefined;
+      if (stateDescription === undefined) {
+        throw new Error(
+          'decide runtime: completed actor has no authored final-state description',
+        );
+      }
       return {
         outcome: 'terminal',
         state,
+        stateDescription,
         ...(output === undefined ? {} : { output }),
       };
     }
-    if (snapshot.status === 'error') {
-      throw (
-        (snapshot as { error?: unknown }).error ??
-        new Error('decide runtime actor entered error status')
-      );
+    if (signal?.aborted) {
+      return abortedResult(signal);
     }
     if (state.activeStateIds.includes('failed')) {
       const error = normalizeErrorFull(context.lastError);
@@ -1739,8 +4322,12 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     activeEmissionCalls.clear();
     emissionQueue.clear();
     judgeQueue.clear();
+    semanticCompletionQueue.clear();
     actor = undefined;
     currentSignal = undefined;
+    currentAborts = undefined;
+    actorSettlementAborts.length = 0;
+    actorSettlementErrorAborts = undefined;
     currentTurnId = undefined;
     ports = undefined;
     sessionIdentity = undefined;
@@ -1753,7 +4340,20 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     judgeCallSequence = 0;
     playerCallSequence = 0;
     playbookCallSequence = 0;
+    applyCallSequence = 0;
     playbookCallTurnIds.clear();
+    governedOutputsByBoundaryId.clear();
+    governedFailuresByBoundaryId.clear();
+    governedEvidenceByBoundaryId.clear();
+    governedReceiptsByBoundaryId.clear();
+    pendingProposalCohort.clear();
+    activeProposalCohort = undefined;
+    completedProposalCohortTurnId = undefined;
+    deferredOperationId = undefined;
+    hiddenDeferredOperationId = undefined;
+    unresolvedSemanticBoundaryIds.clear();
+    appliedControlReceipts.clear();
+    activeDeferredContinuation = undefined;
     lifecycleStarted = false;
   };
 
@@ -1779,6 +4379,10 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       ports = identity.ports;
       sessionIdentity = identity;
       try {
+        if (deferredEffects !== undefined) {
+          effectLedgerMirror = readEffectLedger();
+          synchronizeDeferredProjection(effectLedgerMirror);
+        }
         suppressInspectionEmissions = false;
         createRuntimeActor();
         const state = currentState();
@@ -1797,6 +4401,10 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       }
     },
 
+    describe: describeControlView,
+    unresolvedEffectEnvelopes: unresolvedEffectEnvelopeIdentities,
+    apply: applyControlAction,
+
     // DR-014 §1 / DR-031 §5 / PBRT-45: JSON-safe capture of a parked
     // session, including one already-started suspended REVIEW call.
     // Defined only at a safe capture point — initialized, not disposing
@@ -1853,8 +4461,12 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       const context = (
         actor.getSnapshot() as SnapshotFrom<typeof decideMachine>
       ).context as unknown as Record<string, unknown>;
+      if (deferredEffects !== undefined) {
+        synchronizeDeferredProjection(readEffectLedger());
+      }
+      const unresolved = hasUnresolvedReconciliation();
       return {
-        schemaVersion: 3,
+        schemaVersion: 4,
         playbookId: sessionIdentity.playbookId,
         machine,
         roleResumeTokens: snapshotRoleResumeTokens(),
@@ -1866,14 +4478,15 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           playbookCall: playbookCallSequence,
         },
         state,
-        pendingBossQuestions: pendingQuestionsFromContext(context).map(
-          (pending) => ({
-            questionId: pending.questionId,
-            asker: pending.asker,
-            question: pending.question,
-            sourceItem: pending.sourceItem,
-          }),
-        ),
+        pendingBossQuestions: unresolved
+          ? []
+          : visiblePendingQuestionsForState(state, context).map((pending) => ({
+              questionId: pending.questionId,
+              asker: pending.asker,
+              question: pending.question,
+              sourceItem: pending.sourceItem,
+            })),
+        effectLedger: effectLedgerMirror,
         ...(suspendedCall === undefined ? {} : { suspendedCall }),
       };
     },
@@ -1903,6 +4516,28 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         identity.playbookId,
         { allowSuspendedCall: true },
       );
+      if (deferredEffects === undefined) {
+        if (
+          boundSnapshot.effectLedger.revision !== 0 ||
+          boundSnapshot.effectLedger.boundaries.length !== 0 ||
+          boundSnapshot.effectLedger.logicalOperations.length !== 0
+        ) {
+          throw new TypeError(
+            'decide runtime snapshot effectLedger must be the canonical empty ledger',
+          );
+        }
+      } else {
+        const current = readEffectLedger();
+        if (
+          stableJson(current, 'DECIDE current effect ledger') !==
+          stableJson(boundSnapshot.effectLedger, 'DECIDE snapshot effect ledger')
+        ) {
+          throw new TypeError(
+            'decide runtime snapshot effectLedger must equal the current host mirror',
+          );
+        }
+        effectLedgerMirror = current;
+      }
       const suspendedCall = boundSnapshot.suspendedCall;
       let finishInitialization!: () => void;
       const initialization = new Promise<void>((resolve) => {
@@ -1921,6 +4556,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         judgeCallSequence = boundSnapshot.sequences.judgeCall;
         playerCallSequence = boundSnapshot.sequences.playerCall;
         playbookCallSequence = boundSnapshot.sequences.playbookCall;
+        applyCallSequence = boundSnapshot.sequences.trace;
         if (identity.playerSessions) {
           priorExternalRoleTokens = snapshotRoleResumeTokens();
         }
@@ -1929,6 +4565,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         if (suspendedCall !== undefined) {
           playbookCallTurnIds.set(suspendedCall.callId, suspendedCall.turnId);
         }
+        synchronizeDeferredProjection(effectLedgerMirror);
         suppressInspectionEmissions = true;
         createRuntimeActor(boundSnapshot.machine);
         actor?.start();
@@ -1993,12 +4630,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       const turnId = ++turnSequence;
       currentTurnId = turnId;
       currentSignal = turn.signal;
+      currentAborts = abortReasonClassifier(turn.signal);
       controlPlaneError = undefined;
       let result: PlaybookRunResult = resultForSnapshot(turn.signal);
       let settlement: unknown = result;
       const failures: unknown[] = [];
       try {
         await emitTrace('boss.input.received', { text: turn.text }, { turnId });
+        // A boundary entered aborted records the attempted input, then refuses
+        // delivery before deterministic mapping or the classifier can perform
+        // any host-visible work (DR-036 §5).
+        turn.signal.throwIfAborted();
         if (turn.text.trim().length === 0) {
           const state = currentState();
           result = { outcome: 'no-action', state };
@@ -2006,23 +4648,91 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           const event = await classify(turn.text, turn.signal);
           if (!event) {
             const state = currentState();
-            await emitBoundaryStatus('No playbook action classified.', state);
+            if (!hasUnresolvedReconciliation()) {
+              await emitBoundaryStatus('No playbook action classified.', state);
+            }
             result = { outcome: 'no-action', state };
           } else if (event.type === 'NO_ACTION') {
             result = { outcome: 'no-action', state: currentState() };
           } else {
-            await emitBoundaryStatus(event.type, currentState());
-            if (actor.getSnapshot().status === 'done') {
-              stopActor();
-              startActor();
-            }
+            const before = currentState();
+            const boundCommitWait =
+              deferredEffects !== undefined &&
+              deferredOperationId !== undefined &&
+              before.activeStateIds.includes('awaitBossReply');
+            if (boundCommitWait && event.type === 'BOSS_INTERRUPT') {
+              await parkDeferredContinuation(turn.signal);
+              result = { outcome: 'no-action', state: currentState() };
+            } else {
+              const prepared =
+                boundCommitWait &&
+                event.type === 'BOSS_REPLY' &&
+                event.questionId === 'commitCoderProposal'
+                  ? await prepareDeferredContinuation(turn.signal, event)
+                  : undefined;
+              if (prepared?.proceed === false) {
+                result = { outcome: 'no-action', state: currentState() };
+              } else {
+                await emitBoundaryStatus(event.type, before);
+                if (actor.getSnapshot().status === 'done') {
+                  stopActor();
+                  startActor();
+                }
 
-            actor.send(event);
-            await driveToQuiescence();
-            await drainBoundaryCallsAndEmissions();
+                const deferredMachineCheckpoint =
+                  prepared?.proceed === true
+                    ? detachPersistedMachineSnapshot(
+                        actor.getPersistedSnapshot(),
+                      )
+                    : undefined;
+                if (deferredMachineCheckpoint !== undefined) {
+                  suppressInspectionEmissions = true;
+                }
 
-            if (controlPlaneError !== undefined) throw controlPlaneError;
-            result = resultForSnapshot(turn.signal);
+                try {
+                  actor.send(event);
+                  await driveToQuiescence();
+                  await drainBoundaryCallsAndEmissions();
+                  await prepared?.acknowledgement;
+                  if (
+                    deferredMachineCheckpoint !== undefined &&
+                    hiddenDeferredOperationId !== undefined
+                  ) {
+                    stopActor();
+                    createRuntimeActor(deferredMachineCheckpoint);
+                    actor.start();
+                    previousState = before;
+                    suppressInspectionEmissions = false;
+                  }
+                } catch (error) {
+                  activeDeferredContinuation?.result.reject(error);
+                  if (deferredEffects !== undefined) {
+                    try {
+                      synchronizeDeferredProjection(readEffectLedger());
+                      hiddenDeferredOperationId ??= deferredOperationId;
+                    } catch {
+                      hiddenDeferredOperationId ??= deferredOperationId;
+                    }
+                  }
+                  if (deferredMachineCheckpoint !== undefined) {
+                    try {
+                      stopActor();
+                      createRuntimeActor(deferredMachineCheckpoint);
+                      actor.start();
+                      previousState = before;
+                    } finally {
+                      suppressInspectionEmissions = false;
+                    }
+                  }
+                  throw error;
+                } finally {
+                  activeDeferredContinuation = undefined;
+                }
+
+                if (controlPlaneError !== undefined) throw controlPlaneError;
+                result = resultForSnapshot(turn.signal);
+              }
+            }
           }
         }
         settlement = {
@@ -2031,15 +4741,18 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         };
       } catch (error) {
         const primaryError = controlPlaneError;
+        // Only a rejection that is the exact abort reason settles as the
+        // cancellation; a distinct failure observed while the signal is
+        // aborted remains a control error (slc/link.md §Abort).
         if (primaryError !== undefined) {
           collectFailure(failures, primaryError);
-        } else if (!turn.signal.aborted) {
+        } else if (!isAbortFailure(error, turn.signal)) {
           collectFailure(failures, error);
         }
         const state = currentState();
         const effectiveError = primaryError ?? error;
         result =
-          turn.signal.aborted && primaryError === undefined
+          isAbortFailure(error, turn.signal) && primaryError === undefined
             ? resultForSnapshot(turn.signal)
             : {
                 outcome: 'failed',
@@ -2060,13 +4773,13 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       } catch (error) {
         const primaryError = controlPlaneError;
         const effectiveError = primaryError ?? error;
-        collectFailure(failures, effectiveError);
+        // A drain rejection that is the exact abort reason evidences the
+        // cancellation, not a control-plane failure (slc/link.md §Abort).
+        const drainAborted = isAbortFailure(effectiveError, turn.signal);
+        if (!drainAborted) collectFailure(failures, effectiveError);
         const state = currentState();
         result = {
-          outcome:
-            turn.signal.aborted && primaryError === undefined
-              ? 'aborted'
-              : 'failed',
+          outcome: drainAborted ? 'aborted' : 'failed',
           state,
           error: normalizeErrorFull(effectiveError) ?? {
             name: 'Error',
@@ -2075,18 +4788,28 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         };
         settlement = { ...result, ...stateIdentity(state) };
       }
-      currentSignal = undefined;
       try {
         await emitTrace('boss.input.settled', settlement, { turnId });
       } catch (error) {
-        collectFailure(failures, error);
+        // A settlement-trace rejection that is the exact abort reason also
+        // evidences the cancellation (slc/link.md §Abort).
+        if (!isAbortFailure(error, turn.signal)) {
+          collectFailure(failures, error);
+        }
       }
       try {
         await flush();
       } catch (error) {
-        collectFailure(failures, error);
+        // A late flush rejection that is the exact abort reason likewise
+        // evidences the cancellation; the settled result already labels
+        // the turn aborted then (slc/link.md §Abort).
+        if (!isAbortFailure(error, turn.signal)) {
+          collectFailure(failures, error);
+        }
       } finally {
         const primaryError = controlPlaneError;
+        currentSignal = undefined;
+        currentAborts = undefined;
         currentTurnId = undefined;
         controlPlaneError = undefined;
         if (primaryError !== undefined) throw primaryError;
@@ -2120,8 +4843,13 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       if (currentSignal !== undefined) {
         throw new Error('decide runtime: another runtime turn is active');
       }
+      refreshReconciliationProjection();
+      if (hasUnresolvedReconciliation()) {
+        return { outcome: 'no-action', state: currentState() };
+      }
       currentTurnId = playbookCallTurnIds.get(callId);
       currentSignal = signal;
+      currentAborts = abortReasonClassifier(signal);
       controlPlaneError = undefined;
       let runResult: PlaybookRunResult | undefined;
       let operationError: unknown;
@@ -2148,13 +4876,56 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       } catch (error) {
         drainError = error;
       }
-      const failure = controlPlaneError ?? drainError ?? operationError;
+      const aborts = currentAborts ?? abortReasonClassifier(signal);
+      // The control latch has already classified its failure as distinct
+      // under the operation that owned it. Only still-unclassified drain and
+      // operation candidates may be cancellation evidence for this resume.
+      const controlFailure = controlPlaneError;
+      const drainAbort =
+        controlFailure === undefined &&
+        drainError !== undefined &&
+        aborts.isAbortReason(drainError);
+      const operationAbort =
+        controlFailure === undefined &&
+        operationError !== undefined &&
+        aborts.isAbortReason(operationError);
+      const abortEvidence =
+        (drainAbort ? drainError : undefined) ??
+        (operationAbort ? operationError : undefined);
+      const failure =
+        controlFailure ??
+        (drainAbort ? undefined : drainError) ??
+        (operationAbort ? undefined : operationError);
       currentSignal = undefined;
+      currentAborts = undefined;
       currentTurnId = undefined;
       controlPlaneError = undefined;
       if (failure !== undefined) throw failure;
+      if (
+        abortEvidence !== undefined &&
+        runResult?.outcome !== 'terminal' &&
+        runResult?.outcome !== 'suspended'
+      ) {
+        const state = currentState();
+        runResult = {
+          outcome: 'aborted',
+          state,
+          error: normalizeErrorFull(abortEvidence) ?? {
+            name: 'AbortError',
+            message: String(abortEvidence),
+          },
+        };
+      }
       if (runResult === undefined) {
-        throw new Error('decide runtime: playbook resume produced no result');
+        if (signal.aborted) {
+          // Every candidate was the abort's own evidence: settle on the
+          // machine's state under the aborted boundary signal (DR-036 §4).
+          runResult = resultForSnapshot(signal);
+        } else {
+          throw new Error(
+            'decide runtime: playbook resume produced no result',
+          );
+        }
       }
       return runResult;
     },
@@ -2208,13 +4979,30 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           activeEmissionCalls.clear();
           emissionQueue.clear();
           judgeQueue.clear();
+          semanticCompletionQueue.clear();
           actor = undefined;
           currentSignal = undefined;
+          currentAborts = undefined;
+          actorSettlementAborts.length = 0;
+          actorSettlementErrorAborts = undefined;
           currentTurnId = undefined;
           ports = undefined;
           sessionIdentity = undefined;
           previousState = undefined;
           controlPlaneError = undefined;
+          governedOutputsByBoundaryId.clear();
+          governedFailuresByBoundaryId.clear();
+          governedEvidenceByBoundaryId.clear();
+          governedReceiptsByBoundaryId.clear();
+          pendingProposalCohort.clear();
+          activeProposalCohort = undefined;
+          completedProposalCohortTurnId = undefined;
+          deferredOperationId = undefined;
+          hiddenDeferredOperationId = undefined;
+          unresolvedSemanticBoundaryIds.clear();
+          appliedControlReceipts.clear();
+          applyCallSequence = 0;
+          activeDeferredContinuation = undefined;
           disposed = true;
         }
         if (failures.length === 1) throw failures[0];
@@ -2224,7 +5012,23 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       })();
       return disposalPromise;
     },
+
+    // @internal — test-only parity with the shared factory's bridge escape
+    // hatch. This is hidden by the PlaybookRuntime return type.
+    _getNestedBridge() {
+      return nestedBridge;
+    },
   };
+}
+
+export const createPlaybookRuntime: PlaybookRuntimeFactory<
+  DecidePlaybookRuntimeConstruction
+> = (factoryInput) => {
+  const construction = schema3Construction(factoryInput);
+  return createDecidePlaybookRuntime(
+    construction.configuredOptions,
+    construction.hostCapabilities,
+  );
 };
 
 export const _internal = {
@@ -2234,9 +5038,9 @@ export const _internal = {
   buildClassifierPrompt,
   parseClassification,
   buildAdjudicatorPrompt,
-  parseAdjudication,
   combineSignals,
   pendingQuestionsFromContext,
+  pendingQuestionsForState,
   normalizeErrorCompact,
   normalizeErrorFull,
   STATE_DESCRIPTIONS,
@@ -2244,6 +5048,7 @@ export const _internal = {
   ROLE_STATE_IDS,
   VERBATIM_PAYLOAD_FIELDS,
   BOSS_INTERRUPT_TARGETS,
+  UNFINISHED_FINAL_STATE_IDS,
   CONTINUATION_PREAMBLE,
   TELEMETRY_TOPIC,
 };