@sublang/playbook 4.0.0 → 6.0.0

package/reference/sdlc/{discuss.playbook/discuss.playbook.ts → decide.playbook/decide.playbook.ts}

@@ -1,24 +1,20 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
 //
-// PlaybookRuntime for the discuss playbook, linked from the FSM artifact by
+// PlaybookRuntime for the decide playbook, linked from the FSM artifact by
 // the slc FSM-to-runtime link phase.
 //
 // Linker inputs:
-//   FSM artifact:       ./discuss.fsm.ts
-//   Link target:        @sublang/playbook/src/runtime.ts
-//   Player binding:     Host -> host, Participant -> participant,
-//                       Committer -> committer
+//   FSM artifact:       ./decide.fsm.ts
+//   Link target:        @sublang/playbook/runtime
+//   Player binding:     Coder -> coder, Reviewer -> reviewer
 //                       (default binding: lowercased player name)
-//   Composite players:  Committer = Host | Participant. DISCUSS-14 and
-//                       DISCUSS-15 keep PlayerInput.player = 'Committer';
-//                       callPlayer resolution uses options.committer when
-//                       supplied, otherwise falls back to Host, the first
-//                       listed alias alternative.
 //   Adjudication:       LLM-judge per state (default)
 //   Boss-event mapping: free-text judge classification (default)
 //   Abort strategy:     natural rejection; every player-invoking state's
 //                       onError routes to the quiescent failed state.
+//   Output profile:     bespoke parallel runtime with the shared nested-call
+//                       bridge (slc/link.md §Output)
 
 import PQueue from 'p-queue';
 import { createActor, fromPromise } from 'xstate';
@@ -28,6 +24,7 @@ import {
   assertJsonSafe,
   assertPlaybookRuntimeSnapshot,
   combineAbortSignals,
+  createNestedPlaybookBridge,
   detachPersistedMachineSnapshot,
   normalizeError,
   normalizePlaybookSnapshot,
@@ -36,14 +33,16 @@ import {
   validatePlayerResult,
   waitForPlaybookQuiescence,
 } from '../../../src/xstate-runtime.js';
+import type { NestedPlaybookBridge } from '../../../src/xstate-runtime.js';
 
-import discussMachine, {
+import decideMachine, {
   type PlayerInput,
   type PlayerOutput,
-  type DiscussEvent,
-  type DiscussInput,
+  type DecideEvent,
+  type DecideInput,
   type PendingBossQuestion,
-} from './discuss.fsm.js';
+  type PlaybookInput,
+} from './decide.fsm.js';
 
 import type {
   CaptainCallOptions,
@@ -52,9 +51,13 @@ import type {
   NormalizedError,
   PlayerCallOptions,
   PlayerResult,
+  PlayerSessionStore,
   PlaybookCallRequest,
   PlaybookCallResult,
   PlaybookCallStart,
+  PlaybookControlAction,
+  PlaybookControlReceipt,
+  PlaybookControlView,
   PlaybookPendingCall,
   PlaybookPorts,
   PlaybookRunResult,
@@ -75,9 +78,13 @@ export type {
   NormalizedError,
   PlayerCallOptions,
   PlayerResult,
+  PlayerSessionStore,
   PlaybookCallRequest,
   PlaybookCallResult,
   PlaybookCallStart,
+  PlaybookControlAction,
+  PlaybookControlReceipt,
+  PlaybookControlView,
   PlaybookPendingCall,
   PlaybookPorts,
   PlaybookRunResult,
@@ -91,68 +98,53 @@ export type {
   PlaybookTraceType,
 };
 
-type PlayerName = 'Host' | 'Participant' | 'Committer';
-type ReviewScope = 'specItems' | 'decisionRecords' | 'mixed';
+type PlayerName = 'Coder' | 'Reviewer';
 
-export interface PlaybookRuntimeOptions extends DiscussInput {
+export interface PlaybookRuntimeOptions extends DecideInput {
   playerBinding?: Partial<Record<PlayerName, string>>;
 }
 
 const DEFAULT_PLAYER_BINDING: Readonly<Record<PlayerName, string>> = {
-  Host: 'host',
-  Participant: 'participant',
-  Committer: 'committer',
+  Coder: 'coder',
+  Reviewer: 'reviewer',
 };
 
-const ALIAS_RESOLUTION: Readonly<Record<string, string>> = {
-  'DISCUSS-14':
-    'Committer = Host | Participant; uses input.committerPlayer when supplied, otherwise Host.',
-  'DISCUSS-15':
-    'Committer = Host | Participant; uses input.committerPlayer when supplied, otherwise Host.',
-};
-
-function snapshotDiscussRuntimeOptions(value: unknown): PlaybookRuntimeOptions {
-  const captured = snapshotJsonValue(value, 'DISCUSS runtime options');
+function snapshotDecideRuntimeOptions(value: unknown): PlaybookRuntimeOptions {
+  const captured = snapshotJsonValue(value, 'DECIDE runtime options');
   if (!isPlainObject(captured)) {
-    throw new TypeError('DISCUSS runtime options must be an object');
+    throw new TypeError('DECIDE runtime options must be an object');
   }
-  const allowed = new Set([
-    'host',
-    'participant',
-    'committer',
-    'playerBinding',
-  ]);
+  const allowed = new Set(['coderLlm', 'playerBinding']);
   for (const key of Object.keys(captured)) {
     if (!allowed.has(key)) {
-      throw new TypeError(`DISCUSS runtime options.${key} is not declared`);
+      throw new TypeError(`DECIDE runtime options.${key} is not declared`);
     }
   }
-  for (const key of ['host', 'participant', 'committer'] as const) {
-    if (key in captured && typeof captured[key] !== 'string') {
-      throw new TypeError(`DISCUSS runtime options.${key} must be a string`);
-    }
+  if (
+    typeof captured.coderLlm !== 'string' ||
+    captured.coderLlm.trim().length === 0
+  ) {
+    throw new TypeError(
+      'DECIDE runtime options.coderLlm must be a non-empty string',
+    );
   }
   if ('playerBinding' in captured) {
     const playerBinding = captured.playerBinding;
     if (!isPlainObject(playerBinding)) {
       throw new TypeError(
-        'DISCUSS runtime options.playerBinding must be an object',
+        'DECIDE runtime options.playerBinding must be an object',
       );
     }
-    const playerNames = new Set<PlayerName>([
-      'Host',
-      'Participant',
-      'Committer',
-    ]);
+    const playerNames = new Set<PlayerName>(['Coder', 'Reviewer']);
     for (const [player, playerId] of Object.entries(playerBinding)) {
       if (!playerNames.has(player as PlayerName)) {
         throw new TypeError(
-          `DISCUSS runtime options.playerBinding.${player} is not declared`,
+          `DECIDE runtime options.playerBinding.${player} is not declared`,
         );
       }
       if (typeof playerId !== 'string' || playerId.trim().length === 0) {
         throw new TypeError(
-          `DISCUSS runtime options.playerBinding.${player} must be a non-empty string`,
+          `DECIDE runtime options.playerBinding.${player} must be a non-empty string`,
         );
       }
     }
@@ -161,140 +153,40 @@ function snapshotDiscussRuntimeOptions(value: unknown): PlaybookRuntimeOptions {
 }
 
 const STATE_DESCRIPTIONS: Readonly<Record<string, string>> = {
-  ready: 'Idle hub awaiting a Boss discussion or review directive.',
-  askHostInitial:
-    'Host proposes whether the Boss topic should become spec items or DRs.',
-  askParticipantInitial:
-    'Participant independently proposes whether the Boss topic should become spec items or DRs.',
-  hostInitialRound:
-    'Host reconciles the Participant proposal during initial discussion.',
-  participantInitialRound:
-    'Participant reconciles the Host proposal during initial discussion.',
-  hostWritesAgreement:
-    'Host writes the agreed spec items or DRs and updates the spec map.',
-  commitInitialChanges:
-    'Committer commits the changes produced at the end of initial discussion.',
-  reviewSpecInitialCommit:
-    'Participant reviews newly committed spec-item changes.',
-  reviewSpecHostChanges:
-    'Participant reviews Host changes to spec items after findings.',
-  reviewDrInitialCommit:
-    'Participant reviews newly committed decision-record changes.',
-  reviewDrHostChanges:
-    'Participant reviews Host changes to decision records after findings.',
-  reviewMixedInitialCommit:
-    'Participant reviews newly committed mixed spec-item and DR changes.',
-  reviewMixedHostChanges:
-    'Participant reviews Host changes to mixed spec items and DRs after findings.',
-  hostAddressesFindings:
-    'Host accepts or challenges review findings and stages repo changes.',
-  participantAddressesRebuttals:
-    'Participant accepts or challenges Host rebuttals.',
-  commitReviewedChanges:
-    'Committer commits reviewed changes once Participant raises no findings.',
-  awaitBossReply: 'Waiting for Boss to answer a player question.',
-  failed: 'The discussion workflow failed and is waiting for Boss recovery.',
-  done: 'The discussion workflow completed with a reviewed commit.',
+  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.',
 };
 
-const CAPTAIN_STATES = [
-  { stateId: 'askHostInitial', player: 'Host', sourceItem: 'DISCUSS-1' },
-  {
-    stateId: 'askParticipantInitial',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-2',
-  },
-  { stateId: 'hostInitialRound', player: 'Host', sourceItem: 'DISCUSS-3' },
+const PLAYER_STATES = [
+  { stateId: 'askCoderProposal', player: 'Coder', sourceItem: 'DECIDE-1' },
   {
-    stateId: 'participantInitialRound',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-4',
-  },
-  { stateId: 'hostWritesAgreement', player: 'Host', sourceItem: 'DISCUSS-5' },
-  {
-    stateId: 'commitInitialChanges',
-    player: 'Committer',
-    sourceItem: 'DISCUSS-14',
-  },
-  {
-    stateId: 'reviewSpecInitialCommit',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-6',
-  },
-  {
-    stateId: 'reviewSpecHostChanges',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-7',
-  },
-  {
-    stateId: 'reviewDrInitialCommit',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-8',
-  },
-  {
-    stateId: 'reviewDrHostChanges',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-9',
-  },
-  {
-    stateId: 'reviewMixedInitialCommit',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-10',
-  },
-  {
-    stateId: 'reviewMixedHostChanges',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-11',
-  },
-  {
-    stateId: 'hostAddressesFindings',
-    player: 'Host',
-    sourceItem: 'DISCUSS-12',
-  },
-  {
-    stateId: 'participantAddressesRebuttals',
-    player: 'Participant',
-    sourceItem: 'DISCUSS-13',
-  },
-  {
-    stateId: 'commitReviewedChanges',
-    player: 'Committer',
-    sourceItem: 'DISCUSS-15',
+    stateId: 'askReviewerProposal',
+    player: 'Reviewer',
+    sourceItem: 'DECIDE-2',
   },
+  { stateId: 'commitCoderProposal', player: 'Coder', sourceItem: 'DECIDE-3' },
 ] as const;
 
-const CAPTAIN_STATE_IDS: ReadonlySet<string> = new Set(
-  CAPTAIN_STATES.map((state) => state.stateId),
+const PLAYER_STATE_IDS: ReadonlySet<string> = new Set(
+  PLAYER_STATES.map((state) => state.stateId),
 );
 
-const BOSS_INTERRUPT_TARGETS = [
-  'ready',
-  'initialProposalRound',
-  'reconciliationRound',
-  'hostWritesAgreement',
-  'commitInitialChanges',
-  'reviewSpecInitialCommit',
-  'reviewSpecHostChanges',
-  'reviewDrInitialCommit',
-  'reviewDrHostChanges',
-  'reviewMixedInitialCommit',
-  'reviewMixedHostChanges',
-  'hostAddressesFindings',
-  'participantAddressesRebuttals',
-  'commitReviewedChanges',
-  'failed',
-] as const;
+const BOSS_INTERRUPT_TARGETS = ['independentProposals'] as const;
 
 const BOSS_INTERRUPT_TARGET_IDS: ReadonlySet<string> = new Set(
   BOSS_INTERRUPT_TARGETS,
 );
 
-const REVIEW_SCOPES: ReadonlySet<string> = new Set([
-  'specItems',
-  'decisionRecords',
-  'mixed',
-]);
-
 const TELEMETRY_TOPIC = 'playbook.fsm.state';
 const TRACE_TOPIC = 'playbook.trace';
 
@@ -303,19 +195,16 @@ const CONTINUATION_PREAMBLE =
 
 const PLACEHOLDER_FIELDS: ReadonlyArray<readonly [string, keyof PlayerInput]> =
   [
-    ['<topic>', 'topic'],
-    ['<participant-proposal>', 'participantProposal'],
-    ['<host-previous-proposal>', 'hostProposal'],
-    ['<host-proposal>', 'hostProposal'],
-    ['<participant-previous-proposal>', 'participantProposal'],
-    ['<agreement>', 'agreement'],
-    ['<changes>', 'latestChanges'],
-    ['<review-items>', 'reviewItems'],
-    ['<rebuttals>', 'rebuttals'],
-    ['<host-llm>', 'hostLlm'],
-    ['<participant-llm>', 'participantLlm'],
+    ['<caller-topic>', 'callerTopic'],
+    ['<coder-llm>', 'coderLlm'],
   ];
 
+const VERBATIM_PAYLOAD_FIELDS: ReadonlySet<string> = new Set([
+  'coderProposal',
+  'reviewerProposal',
+  'coderOutput',
+]);
+
 function composePlayerPrompt(input: PlayerInput): string {
   const blocks: string[] = [];
 
@@ -333,13 +222,22 @@ function composePlayerPrompt(input: PlayerInput): string {
     );
   }
 
-  let body = input.prompt;
+  const replacements = new Map<string, string>();
   for (const [placeholder, field] of PLACEHOLDER_FIELDS) {
     const value = input[field];
-    if (typeof value === 'string') {
-      body = body.replaceAll(placeholder, value);
-    }
+    if (typeof value === 'string') replacements.set(placeholder, value);
   }
+  const body = input.prompt.replace(
+    /<caller-topic>|<coder-llm>/g,
+    (placeholder, offset: number, source: string) => {
+      const value = replacements.get(placeholder);
+      if (value === undefined) return placeholder;
+      const lineStart = source.lastIndexOf('\n', offset - 1) + 1;
+      return source.slice(lineStart, offset) === '> '
+        ? value.replaceAll('\n', '\n> ')
+        : value;
+    },
+  );
 
   blocks.push(body);
   return blocks.join('\n\n');
@@ -350,12 +248,10 @@ function resolvePlayerId(
   binding: Record<PlayerName, string>,
 ): string {
   switch (input.player) {
-    case 'Host':
-      return binding.Host;
-    case 'Participant':
-      return binding.Participant;
-    case 'Committer':
-      return input.committerPlayer ?? binding.Host;
+    case 'Coder':
+      return binding.Coder;
+    case 'Reviewer':
+      return binding.Reviewer;
     default: {
       const exhaustive: never = input.player;
       throw new Error(`unknown player ${String(exhaustive)}`);
@@ -363,11 +259,8 @@ function resolvePlayerId(
   }
 }
 
-// A `result` description names required payload fields in an
-// "Output shall include ..." sentence. One sentence can name several
-// fields — DISCUSS-5's wroteChanges names both `latestChanges` and
-// `reviewScope` — so every backticked `field:` token in the sentence
-// span is required, not just the one adjacent to the phrase.
+// A `result` description names required payload fields in its
+// "Output shall include ..." sentence.
 function requiredFieldsFor(description: string): string[] {
   const fields: string[] = [];
   const sentence = /Output shall include([^.]*)/g;
@@ -492,7 +385,7 @@ function buildClassifierPrompt(
   },
 ): string {
   const lines: string[] = [];
-  lines.push('You are the Boss-input classifier for the discuss playbook.');
+  lines.push('You are the Boss-input classifier for the decide playbook.');
   lines.push(
     'Classify the Boss message into exactly one FSM event, or into no event.',
   );
@@ -503,7 +396,7 @@ function buildClassifierPrompt(
     lines.push('Pending Boss questions:');
     for (const pending of ctx.pendingQuestions) {
       lines.push(
-        `- ${pending.questionId} (${pending.player}, ${pending.sourceItem}): ${pending.question}`,
+        `- ${pending.questionId} (${pending.player}): ${pending.question}`,
       );
     }
     lines.push(
@@ -513,98 +406,77 @@ function buildClassifierPrompt(
   lines.push('');
   lines.push('Events and payload contracts:');
   lines.push(
-    '- START_DISCUSSION: required topic string; optional hostLlm, participantLlm strings (identities normally come from run options).',
-  );
-  lines.push(
-    '- START_REVIEW: required latestChanges string, required reviewScope string ("specItems" | "decisionRecords" | "mixed"), optional rebuttals string.',
+    `- BOSS_INTERRUPT: required targetId string, exactly ${BOSS_INTERRUPT_TARGETS[0]}; the runtime attaches the exact Boss text as bossIntent.`,
   );
   lines.push(
-    `- BOSS_INTERRUPT: required targetId string, one of ${BOSS_INTERRUPT_TARGETS.join(', ')}.`,
-  );
-  lines.push(
-    '- BOSS_REPLY: required answer string and questionId when several questions are pending; valid only while at least one Boss question is pending.',
+    '- BOSS_REPLY: optional questionId when exactly one question is pending and required when several are pending; the runtime attaches the exact Boss text as answer.',
   );
+  lines.push('- NO_ACTION: no fields.');
   lines.push('');
   lines.push('Boss message:');
   lines.push(text);
   lines.push('');
   lines.push(
-    'Reply with a single JSON object: { "event": "<EVENT_TYPE or null>", ...payload fields }.',
+    'Reply with a single JSON object: { "type": "<EVENT_TYPE>", ...declared fields }.',
   );
-  lines.push('Use null when no FSM action applies.');
+  lines.push('Use NO_ACTION when no FSM action applies.');
   return lines.join('\n');
 }
 
 function parseClassification(
   raw: string,
+  text: string,
   pendingQuestionIds: readonly string[] = [],
-): DiscussEvent | null {
+): DecideEvent | { type: 'NO_ACTION' } | null {
   const obj = extractJson(raw);
   if (!obj) return null;
-  const eventType = obj.event ?? obj.type;
+  const exactKeys = (...keys: string[]): boolean => {
+    const ownKeys = Reflect.ownKeys(obj);
+    return (
+      ownKeys.length === keys.length &&
+      ownKeys.every(
+        (key) => typeof key === 'string' && keys.includes(key),
+      )
+    );
+  };
+  const eventType = obj.type;
 
-  if (eventType === 'START_DISCUSSION') {
-    // hostLlm/participantLlm are optional on the FSM event: the identities
-    // normally flow in via the machine input (run options).
-    if (typeof obj.topic === 'string') {
-      return {
-        type: 'START_DISCUSSION',
-        topic: obj.topic,
-        ...(typeof obj.hostLlm === 'string' ? { hostLlm: obj.hostLlm } : {}),
-        ...(typeof obj.participantLlm === 'string'
-          ? { participantLlm: obj.participantLlm }
-          : {}),
-      };
-    }
-    return null;
-  }
-
-  if (eventType === 'START_REVIEW') {
-    if (
-      typeof obj.latestChanges === 'string' &&
-      typeof obj.reviewScope === 'string' &&
-      REVIEW_SCOPES.has(obj.reviewScope)
-    ) {
-      return {
-        type: 'START_REVIEW',
-        latestChanges: obj.latestChanges,
-        reviewScope: obj.reviewScope as ReviewScope,
-        ...(typeof obj.rebuttals === 'string'
-          ? { rebuttals: obj.rebuttals }
-          : {}),
-      };
-    }
-    return null;
+  if (eventType === 'NO_ACTION') {
+    return exactKeys('type') ? { type: 'NO_ACTION' } : null;
   }
 
   if (eventType === 'BOSS_INTERRUPT') {
     if (
+      exactKeys('type', 'targetId') &&
       typeof obj.targetId === 'string' &&
       BOSS_INTERRUPT_TARGET_IDS.has(obj.targetId)
     ) {
-      return { type: 'BOSS_INTERRUPT', targetId: obj.targetId as never };
+      return {
+        type: 'BOSS_INTERRUPT',
+        targetId: obj.targetId as 'independentProposals',
+        bossIntent: text,
+      };
     }
     return null;
   }
 
   if (eventType === 'BOSS_REPLY') {
-    if (typeof obj.answer !== 'string' || pendingQuestionIds.length === 0) {
-      return null;
-    }
+    if (pendingQuestionIds.length === 0) return null;
     if (typeof obj.questionId === 'string') {
-      return pendingQuestionIds.includes(obj.questionId)
+      return exactKeys('type', 'questionId') &&
+        pendingQuestionIds.includes(obj.questionId)
         ? {
             type: 'BOSS_REPLY',
             questionId: obj.questionId as never,
-            answer: obj.answer,
+            answer: text,
           }
         : null;
     }
-    return pendingQuestionIds.length === 1
+    return exactKeys('type') && pendingQuestionIds.length === 1
       ? {
           type: 'BOSS_REPLY',
           questionId: pendingQuestionIds[0] as never,
-          answer: obj.answer,
+          answer: text,
         }
       : null;
   }
@@ -639,6 +511,18 @@ function buildAdjudicatorPrompt(
   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('');
+    lines.push(
+      `The runtime owns these verbatim fields; do not include them in your JSON: ${[...runtimeOwnedFields].join(', ')}.`,
+    );
+  }
   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 }.',
@@ -646,7 +530,11 @@ function buildAdjudicatorPrompt(
   return lines.join('\n');
 }
 
-function parseAdjudication(raw: string, input: PlayerInput): PlayerOutput {
+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');
@@ -659,15 +547,22 @@ function parseAdjudication(raw: string, input: PlayerInput): PlayerOutput {
     );
   }
 
-  // Per slc/link.md §Captain adjudication the judge answers
-  // `{ guard, …payloadFields }` and the runtime validates the required
-  // fields. Every payload field is carried through — dropping the
-  // non-required ones would blind FSM fallbacks such as
-  // `outputOf(event).reviewScope ?? context.reviewScope` on guards whose
-  // description says "may include".
-  const output = { ...obj, guard } as unknown as PlayerOutput;
-  for (const field of requiredFieldsFor(input.result[guard])) {
-    const value = output[field];
+  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 ||
@@ -677,19 +572,9 @@ function parseAdjudication(raw: string, input: PlayerInput): PlayerOutput {
         `adjudicator response for guard "${guard}" missing required field "${field}"`,
       );
     }
+    output[field] = value;
   }
-
-  if (
-    'reviewScope' in output &&
-    typeof output.reviewScope === 'string' &&
-    !REVIEW_SCOPES.has(output.reviewScope)
-  ) {
-    throw new Error(
-      `adjudicator returned invalid reviewScope "${output.reviewScope}"`,
-    );
-  }
-
-  return output;
+  return output as PlayerOutput;
 }
 
 function combineSignals(
@@ -713,10 +598,16 @@ function normalizeErrorFull(
   return err === undefined || err === null ? undefined : normalizeError(err);
 }
 
+// DR-028's unified empty predicate: a missing, empty, or whitespace-only
+// `finalText` on an `ok` player result is the one shape that earns exactly
+// one corrective re-ask before the existing failure path applies. Mirrors
+// the shared engine's predicate (PBRT-9).
+function isEmptyFinalText(finalText: string | undefined): boolean {
+  return finalText === undefined || finalText.trim().length === 0;
+}
+
 function isAbortFailure(error: unknown, signal: AbortSignal): boolean {
-  if (!signal.aborted) return false;
-  if (Object.is(error, signal.reason)) return true;
-  return normalizeErrorCompact(error)?.name === 'AbortError';
+  return signal.aborted && Object.is(error, signal.reason);
 }
 
 function pendingQuestionsFromContext(
@@ -753,10 +644,8 @@ function pendingQuestionsFromContext(
 }
 
 const WAIT_STATE_RESUME_IDS: Readonly<Record<string, string>> = {
-  waitHostInitialReply: 'askHostInitial',
-  waitParticipantInitialReply: 'askParticipantInitial',
-  waitHostReconciliationReply: 'hostInitialRound',
-  waitParticipantReconciliationReply: 'participantInitialRound',
+  waitCoderProposalReply: 'askCoderProposal',
+  waitReviewerProposalReply: 'askReviewerProposal',
 };
 
 const WAIT_STATE_IDS: ReadonlySet<string> = new Set([
@@ -765,7 +654,7 @@ const WAIT_STATE_IDS: ReadonlySet<string> = new Set([
 ]);
 
 const STATUS_STATE_IDS: ReadonlySet<string> = new Set([
-  ...CAPTAIN_STATE_IDS,
+  ...PLAYER_STATE_IDS,
   ...WAIT_STATE_IDS,
   'failed',
 ]);
@@ -785,25 +674,36 @@ function questionForWaitState(
     : undefined;
 }
 
-function normalizedEventType(event: unknown): JsonValue {
-  if (
-    event !== null &&
-    typeof event === 'object' &&
-    !Array.isArray(event) &&
-    'type' in event
-  ) {
-    const type = (event as { type: unknown }).type;
-    return typeof type === 'string' ? type : String(type);
+const TRANSITION_EVENT_FIELDS: readonly string[] = [
+  'callerTopic',
+  'targetId',
+  'bossIntent',
+  'questionId',
+  'answer',
+];
+
+function normalizedTransitionEvent(event: unknown): JsonValue {
+  if (event === null || typeof event !== 'object') {
+    return snapshotJsonValue(event ?? null, 'FSM event');
   }
-  if (
-    event === null ||
-    typeof event === 'string' ||
-    typeof event === 'boolean' ||
-    (typeof event === 'number' && Number.isFinite(event))
-  ) {
-    return event;
+  const source = event as Record<string, unknown>;
+  const descriptor: Record<string, JsonValue> = {};
+  if (typeof source.type === 'string') descriptor.type = source.type;
+  for (const field of TRANSITION_EVENT_FIELDS) {
+    if (typeof source[field] === 'string') {
+      descriptor[field] = source[field] as string;
+    }
+  }
+  if (source.output !== undefined) {
+    descriptor.output = snapshotJsonValue(source.output, 'FSM event output');
+  }
+  if (source.error !== undefined) {
+    descriptor.error = snapshotJsonValue(
+      normalizeError(source.error),
+      'FSM event error',
+    );
   }
-  return String(event);
+  return snapshotJsonValue(descriptor, 'FSM event');
 }
 
 function telemetryPayload(
@@ -812,22 +712,15 @@ function telemetryPayload(
   event: unknown,
   context: Record<string, unknown>,
 ): JsonValue {
-  const eventError =
-    event !== null &&
-    typeof event === 'object' &&
-    !Array.isArray(event) &&
-    'error' in event
-      ? normalizeErrorFull((event as { error: unknown }).error)
-      : undefined;
   const pendingBossQuestions = pendingQuestionsFromContext(context);
+  const prior = previousState ?? state;
   const payload = {
-    from: previousState?.value ?? null,
+    from: prior.value,
     to: state.value,
-    event: normalizedEventType(event),
-    previousState: previousState ?? null,
+    event: normalizedTransitionEvent(event),
+    previousState: prior,
     state,
     ...(pendingBossQuestions.length > 0 ? { pendingBossQuestions } : {}),
-    ...(eventError !== undefined ? { error: eventError } : {}),
     ...(state.activeStateIds.includes('failed')
       ? { lastError: normalizeErrorFull(context.lastError) ?? null }
       : {}),
@@ -839,15 +732,13 @@ function telemetryPayload(
 export const createPlaybookRuntime: PlaybookRuntimeFactory<
   PlaybookRuntimeOptions
 > = (options) => {
-  const boundOptions = snapshotDiscussRuntimeOptions(options);
+  const boundOptions = snapshotDecideRuntimeOptions(options);
   const binding: Record<PlayerName, string> = {
     ...DEFAULT_PLAYER_BINDING,
     ...(boundOptions.playerBinding ?? {}),
   };
-  const fsmInput: DiscussInput = {
-    host: boundOptions.host,
-    participant: boundOptions.participant,
-    committer: boundOptions.committer,
+  const fsmInput: DecideInput = {
+    coderLlm: boundOptions.coderLlm,
   };
 
   type SessionIdentity = Readonly<PlaybookSession>;
@@ -864,12 +755,15 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   let turnSequence = 0;
   let judgeCallSequence = 0;
   let playerCallSequence = 0;
+  let playbookCallSequence = 0;
   let lifecycleStarted = false;
   let initInFlight: Promise<void> | undefined;
   let disposed = false;
   let disposalPromise: Promise<void> | undefined;
   let controlPlaneError: unknown;
+  let nestedBridge: NestedPlaybookBridge<PlaybookInput>;
   const playerResumeTokens = new Map<string, string>();
+  const playbookCallTurnIds = new Map<string, number | undefined>();
   const inFlightPlayerIds = new Set<string>();
   const activeBoundaryCalls = new Set<Promise<unknown>>();
   const activeEmissionCalls = new Set<Promise<void>>();
@@ -891,6 +785,13 @@ 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 enqueue = (fn: () => Promise<void>): Promise<void> => {
     const queued = emissionQueue.add(fn);
     activeEmissionCalls.add(queued);
@@ -920,7 +821,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     const failures = emissionFailures;
     emissionFailures = [];
     if (failures.length === 1) throw failures[0];
-    throw new AggregateError(failures, 'discuss runtime emissions failed');
+    throw new AggregateError(failures, 'decide runtime emissions failed');
   };
   const drainBoundaryCallsAndEmissions = async (): Promise<void> => {
     while (true) {
@@ -941,22 +842,92 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   };
   const requirePorts = (): PlaybookPorts => {
     if (!ports) {
-      throw new Error('discuss runtime: init(session) must be called first');
+      throw new Error('decide runtime: init(session) must be called first');
     }
     return ports;
   };
   const requireSessionIdentity = (): SessionIdentity => {
     if (!sessionIdentity) {
-      throw new Error('discuss runtime: init(session) must be called first');
+      throw new Error('decide runtime: init(session) must be called first');
     }
     return sessionIdentity;
   };
+  const selectPlayerResume = (playerId: string): string | false => {
+    const session = requireSessionIdentity();
+    const selected = session.playerSessions
+      ? session.playerSessions.select(playerId)
+      : playerResumeTokens.get(playerId) ?? false;
+    if (
+      selected !== false &&
+      (typeof selected !== 'string' || selected.trim().length === 0)
+    ) {
+      throw new TypeError(
+        `player session store returned an invalid resume token for ${playerId}`,
+      );
+    }
+    return selected;
+  };
+  const updatePlayerResume = (
+    playerId: string,
+    resumeToken: string | undefined,
+  ): void => {
+    const session = requireSessionIdentity();
+    if (session.playerSessions) {
+      session.playerSessions.update(playerId, resumeToken);
+    } else if (resumeToken !== undefined && resumeToken.trim().length > 0) {
+      playerResumeTokens.set(playerId, resumeToken);
+    } else {
+      playerResumeTokens.delete(playerId);
+    }
+  };
+  const snapshotPlayerResumeTokens = (): Record<string, string> => {
+    const session = requireSessionIdentity();
+    const captured = snapshotJsonValue(
+      session.playerSessions
+        ? session.playerSessions.snapshot()
+        : Object.fromEntries(playerResumeTokens),
+      'player session store snapshot',
+    );
+    if (!isPlainObject(captured)) {
+      throw new TypeError('player session store snapshot must be an object');
+    }
+    const tokens: Record<string, string> = {};
+    for (const [playerId, token] of Object.entries(captured)) {
+      if (playerId.trim().length === 0) {
+        throw new TypeError(
+          'player session store snapshot player ids must be non-empty',
+        );
+      }
+      if (typeof token !== 'string' || token.trim().length === 0) {
+        throw new TypeError(
+          `player session store snapshot token for ${playerId} must be a non-empty string`,
+        );
+      }
+      tokens[playerId] = token;
+    }
+    return tokens;
+  };
+  const restorePlayerResumeTokens = (
+    tokens: Readonly<Record<string, string>>,
+  ): void => {
+    const session = requireSessionIdentity();
+    if (session.playerSessions) {
+      session.playerSessions.restore(tokens);
+      return;
+    }
+    playerResumeTokens.clear();
+    for (const [playerId, token] of Object.entries(tokens)) {
+      playerResumeTokens.set(playerId, token);
+    }
+  };
   const currentState = (): PlaybookState => {
     const live = actor;
     if (!live) {
-      throw new Error('discuss runtime: actor is not initialized');
+      throw new Error('decide runtime: actor is not initialized');
     }
-    return normalizePlaybookSnapshot(live.getSnapshot());
+    return normalizePlaybookSnapshot(live.getSnapshot(), {
+      pendingCall: nestedBridge.getPendingCall(),
+    });
   };
   const stateIdentity = (state: PlaybookState): { stateId?: string } => {
     return state.stateId === undefined ? {} : { stateId: state.stateId };
@@ -1062,7 +1033,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       ...(callStateId !== undefined ? { stateId: callStateId } : {}),
     };
     const queued = await judgeQueue.add(async () => {
-      // Keep the complete queue task pending until an active host promise
+      // Keep the complete queue task pending until an active coder promise
       // settles. PQueue's signal option may reject add() while that task is
       // still running, which would let the turn drain race a late finish.
       signal.throwIfAborted();
@@ -1134,10 +1105,15 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         `resolved player "${playerId}" already has an in-flight call`,
       );
     }
-    inFlightPlayerIds.add(playerId);
     const prompt = composePlayerPrompt(input);
-    const resume: PlayerCallOptions['resume'] =
-      playerResumeTokens.get(playerId) ?? false;
+    let resume: PlayerCallOptions['resume'];
+    try {
+      signal.throwIfAborted();
+      resume = selectPlayerResume(playerId);
+    } catch (error) {
+      latchControlPlaneError(error, signal);
+      throw error;
+    }
     const callId = `player-${++playerCallSequence}`;
     const identity = {
       purpose: 'captain',
@@ -1159,6 +1135,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         },
         { turnId: currentTurnId, callId },
       );
+    inFlightPlayerIds.add(playerId);
     try {
       await emitCallStarted(
         'player.call.started',
@@ -1175,13 +1152,13 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           requirePorts().callPlayer(playerId, prompt, signal, { resume }),
         );
         rawResult = await boundary;
-        // An XState sibling cancellation does not cancel an arbitrary host
+        // An XState sibling cancellation does not cancel an arbitrary coder
         // promise. Re-check before a late resolution can mutate continuity or
         // masquerade as a successful boundary finish.
         signal.throwIfAborted();
       } catch (error) {
         // A rejected call produced no authoritative result, so the previous
-        // token remains untouched. This also covers a host promise that
+        // token remains untouched. This also covers a coder promise that
         // resolves after its invocation signal was cancelled.
         latchControlPlaneError(error, signal);
         try {
@@ -1200,20 +1177,29 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         try {
           await emitFailure(error);
         } catch {
-          // The malformed host result remains authoritative.
+          // The malformed coder result remains authoritative.
         }
         throw error;
       }
 
       // The resolved result is authoritative even on aborted/error status.
       // Update continuation state before interpreting that status.
-      if (
-        typeof result.resumeToken === 'string' &&
-        result.resumeToken.trim().length > 0
-      ) {
-        playerResumeTokens.set(playerId, result.resumeToken);
-      } else {
-        playerResumeTokens.delete(playerId);
+      try {
+        updatePlayerResume(
+          playerId,
+          typeof result.resumeToken === 'string' &&
+            result.resumeToken.trim().length > 0
+            ? result.resumeToken
+            : undefined,
+        );
+      } catch (error) {
+        latchControlPlaneError(error, signal);
+        try {
+          await emitFailure(error);
+        } catch {
+          // The continuation-store failure remains authoritative.
+        }
+        throw error;
       }
 
       // Keep this finish outside the boundary catch. A trace sink can record
@@ -1263,7 +1249,19 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       }
       combined.throwIfAborted();
 
-      const { playerId, result } = await callPlayer(input, combined);
+      let { 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();
+        ({ playerId, result } = await callPlayer(input, combined));
+      }
       if (result.status !== 'ok') {
         throw new Error(
           `player "${playerId}" returned status "${result.status}"${
@@ -1271,7 +1269,8 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           }`,
         );
       }
-      if (result.finalText === undefined) {
+      const finalText = result.finalText ?? '';
+      if (isEmptyFinalText(finalText)) {
         throw new Error(
           `player "${playerId}" returned status "ok" with no finalText`,
         );
@@ -1279,7 +1278,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       combined.throwIfAborted();
 
       try {
-        const prompt = buildAdjudicatorPrompt(input, result.finalText);
+        const prompt = buildAdjudicatorPrompt(input, finalText);
         return parseAdjudication(
           await callJudge(
             prompt,
@@ -1288,6 +1287,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             input.stateId,
           ),
           input,
+          finalText,
         );
       } catch (error) {
         latchControlPlaneError(error, combined);
@@ -1296,89 +1296,162 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     },
   );
 
-  const providedMachine = discussMachine.provide({ actors: { player } });
+  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,
+        },
+        {
+          ...(currentTurnId === undefined ? {} : { turnId: currentTurnId }),
+          callId: event.callId,
+        },
+      );
+    },
+    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);
+    },
+  });
+
+  const providedMachine = decideMachine.provide({
+    actors: { player, playbook: nestedBridge.actorLogic },
+  });
 
   const inspect = (event: InspectionEvent): void => {
     if (event.type !== '@xstate.snapshot') return;
     if (actor === undefined || event.actorRef !== actor) return;
     if (suppressInspectionEmissions) return;
-    const snapshot = event.snapshot as SnapshotFrom<typeof discussMachine>;
-    const state = normalizePlaybookSnapshot(snapshot);
-    const prior = previousState;
-    previousState = state;
-
-    const runtimePorts = ports;
-    if (!runtimePorts) return;
-    const context = snapshot.context as Record<string, unknown>;
-    const fsmPayload = telemetryPayload(prior, state, event.event, context);
-    const describedFsmPayload = snapshotJsonValue(
-      fsmPayload,
-      'described FSM telemetry',
-    );
+    try {
+      const snapshot = event.snapshot as SnapshotFrom<typeof decideMachine>;
+      const state = normalizePlaybookSnapshot(snapshot);
+      const prior = previousState ?? state;
+      const context = snapshot.context as unknown as Record<string, unknown>;
+      const fsmPayload = telemetryPayload(prior, state, event.event, context);
+      const describedFsmPayload = snapshotJsonValue(
+        fsmPayload,
+        'described FSM telemetry',
+      );
 
-    void enqueueTracedEmission(
-      'fsm.transition',
-      fsmPayload,
-      { turnId: currentTurnId },
-      (emissionPorts) =>
-        emissionPorts.emitTelemetry({
-          topic: TELEMETRY_TOPIC,
-          payload: describedFsmPayload,
-        }),
-    ).catch(() => undefined);
-
-    const priorIds = new Set(prior?.activeStateIds ?? []);
-    const pendingQuestions = pendingQuestionsFromContext(context);
-    const bossRelevantStateIds = state.activeStateIds.filter((stateId) =>
-      STATUS_STATE_IDS.has(stateId),
-    );
-    const scheduleStatus = (
-      message: string,
-      stateId: string,
-      data?: JsonValue,
-    ): void => {
-      const tracePayload = {
-        ...(bossRelevantStateIds.length === 1 ? { stateId } : {}),
-        message,
-        state,
-        ...(data !== undefined ? { data } : {}),
-      };
-      assertJsonSafe(tracePayload);
       void enqueueTracedEmission(
-        'status.emitted',
-        tracePayload,
+        'fsm.transition',
+        fsmPayload,
         { turnId: currentTurnId },
-        (emissionPorts) => emissionPorts.emitStatus(message, data),
+        (emissionPorts) =>
+          emissionPorts.emitTelemetry({
+            topic: TELEMETRY_TOPIC,
+            payload: describedFsmPayload,
+          }),
       ).catch(() => undefined);
-    };
 
-    for (const activeStateId of state.activeStateIds) {
-      if (priorIds.has(activeStateId) || !STATUS_STATE_IDS.has(activeStateId)) {
-        continue;
-      }
-      if (WAIT_STATE_IDS.has(activeStateId)) {
-        const pending = questionForWaitState(activeStateId, pendingQuestions);
-        if (pending) {
-          scheduleStatus(
-            `${pending.player} asks: ${pending.question}`,
-            activeStateId,
-          );
-          scheduleStatus(
-            `◆ awaiting Boss reply · ${pending.resumeStateId} · ${pending.player} · ${pending.sourceItem}`,
+      const priorIds = new Set(previousState?.activeStateIds ?? []);
+      previousState = state;
+      const pendingQuestions = pendingQuestionsFromContext(context);
+      const bossRelevantStateIds = state.activeStateIds.filter((stateId) =>
+        STATUS_STATE_IDS.has(stateId),
+      );
+      const scheduleStatus = (
+        message: string,
+        stateId: string,
+        data?: JsonValue,
+      ): void => {
+        const tracePayload = {
+          ...(bossRelevantStateIds.length === 1 ? { stateId } : {}),
+          message,
+          state,
+          ...(data !== undefined ? { data } : {}),
+        };
+        assertJsonSafe(tracePayload);
+        void enqueueTracedEmission(
+          'status.emitted',
+          tracePayload,
+          { turnId: currentTurnId },
+          (emissionPorts) => emissionPorts.emitStatus(message, data),
+        ).catch(() => undefined);
+      };
+
+      for (const activeStateId of state.activeStateIds) {
+        if (
+          priorIds.has(activeStateId) ||
+          !STATUS_STATE_IDS.has(activeStateId)
+        ) {
+          continue;
+        }
+        if (WAIT_STATE_IDS.has(activeStateId)) {
+          const pending = questionForWaitState(
             activeStateId,
+            pendingQuestions,
           );
+          if (pending) {
+            scheduleStatus(
+              `${pending.player} asks: ${pending.question}`,
+              activeStateId,
+            );
+            scheduleStatus(
+              `◆ awaiting Boss reply · ${pending.resumeStateId} · ${pending.player} · ${pending.sourceItem}`,
+              activeStateId,
+            );
+          }
+          continue;
         }
-        continue;
+        const lastError =
+          activeStateId === 'failed'
+            ? normalizeErrorCompact(context.lastError)
+            : undefined;
+        const description = STATE_DESCRIPTIONS[activeStateId];
+        if (description === undefined) continue;
+        const playerState = PLAYER_STATES.find(
+          (candidate) => candidate.stateId === activeStateId,
+        );
+        scheduleStatus(
+          playerState === undefined
+            ? '◆ workflow failed; awaiting Boss recovery.'
+            : `⤷ ${playerState.player}: ${description}`,
+          activeStateId,
+          lastError === undefined ? undefined : { lastError },
+        );
       }
-      const lastError =
-        activeStateId === 'failed'
-          ? normalizeErrorCompact(context.lastError)
-          : undefined;
-      scheduleStatus(
-        STATE_DESCRIPTIONS[activeStateId] ?? activeStateId,
-        activeStateId,
-        lastError === undefined ? undefined : { lastError },
-      );
+    } catch (error) {
+      latchInspectionError(error);
     }
   };
 
@@ -1392,34 +1465,60 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         ? {}
         : {
             snapshot: machineSnapshot as unknown as SnapshotFrom<
-              typeof discussMachine
+              typeof decideMachine
             >,
           }),
       inspect,
     });
   };
 
+  // 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 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('discuss runtime: actor is not initialized');
-    await waitForPlaybookQuiescence(live);
+    if (!live) throw new Error('decide runtime: actor is not initialized');
+    await waitForPlaybookQuiescence(live, { pendingCalls: nestedBridge });
   };
 
   const classify = async (
     text: string,
     signal: AbortSignal,
-  ): Promise<DiscussEvent | null> => {
+  ): Promise<DecideEvent | { type: 'NO_ACTION' } | null> => {
     const live = actor;
-    if (!live) throw new Error('discuss runtime: actor is not initialized');
-    const snapshot = live.getSnapshot() as SnapshotFrom<typeof discussMachine>;
-    const context = snapshot.context as Record<string, unknown>;
-    const state = normalizePlaybookSnapshot(snapshot);
+    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 };
+    }
+    if (pendingQuestions.length === 0) return null;
     const prompt = buildClassifierPrompt(text, {
       state,
       pendingQuestions,
@@ -1432,16 +1531,18 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     );
     return parseClassification(
       raw,
+      text,
       pendingQuestions.map(({ questionId }) => questionId),
     );
   };
 
   const resultForSnapshot = (signal?: AbortSignal): PlaybookRunResult => {
     const live = actor;
-    if (!live) throw new Error('discuss runtime: actor is not initialized');
-    const snapshot = live.getSnapshot() as SnapshotFrom<typeof discussMachine>;
-    const state = normalizePlaybookSnapshot(snapshot);
-    const context = snapshot.context as Record<string, unknown>;
+    if (!live) throw new Error('decide runtime: actor is not initialized');
+    const snapshot = live.getSnapshot() as SnapshotFrom<typeof decideMachine>;
+    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',
@@ -1468,7 +1569,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     if (snapshot.status === 'error') {
       throw (
         (snapshot as { error?: unknown }).error ??
-        new Error('discuss runtime actor entered error status')
+        new Error('decide runtime actor entered error status')
       );
     }
     if (state.activeStateIds.includes('failed')) {
@@ -1479,6 +1580,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         ...(error === undefined ? {} : { error }),
       };
     }
+    if (pendingCall) {
+      return { outcome: 'suspended', state, pendingCall };
+    }
     return { outcome: 'quiescent', state };
   };
 
@@ -1499,9 +1603,8 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         // A state that cannot even normalize has no disposal descriptor.
       }
     }
-    suppressInspectionEmissions = true;
     try {
-      actor?.stop();
+      stopActor();
     } catch {
       // Preserve the original startup failure.
     }
@@ -1542,6 +1645,8 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     turnSequence = 0;
     judgeCallSequence = 0;
     playerCallSequence = 0;
+    playbookCallSequence = 0;
+    playbookCallTurnIds.clear();
     lifecycleStarted = false;
   };
 
@@ -1554,7 +1659,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         disposalPromise !== undefined
       ) {
         throw new Error(
-          'discuss runtime: init(session) may only be called once',
+          'decide runtime: init(session) may only be called once',
         );
       }
       const identity = snapshotPlaybookSession(session);
@@ -1588,8 +1693,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     // DR-014 §1 / PBRT-45: JSON-safe capture of a parked session.
     // Defined only at a safe capture point — initialized, not disposing
     // or disposed, no active public boundary, and the actor quiescent
-    // with status `active`. DISCUSS never opens nested playbook calls,
-    // so no pending-call guard applies.
+    // with status `active` and no pending nested REVIEW call.
     exportSnapshot(): PlaybookRuntimeSnapshot | undefined {
       if (
         !actor ||
@@ -1602,25 +1706,26 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       if (currentTurnId !== undefined || currentSignal !== undefined) {
         return undefined;
       }
+      if (nestedBridge.getPendingCall()) return undefined;
       const state = currentState();
       if (state.status !== 'active' || !state.quiescent) return undefined;
       const machine = detachPersistedMachineSnapshot(
         actor.getPersistedSnapshot(),
       );
       const context = (
-        actor.getSnapshot() as SnapshotFrom<typeof discussMachine>
-      ).context as Record<string, unknown>;
+        actor.getSnapshot() as SnapshotFrom<typeof decideMachine>
+      ).context as unknown as Record<string, unknown>;
       return {
         schemaVersion: 1,
         playbookId: sessionIdentity.playbookId,
         machine,
-        playerResumeTokens: Object.fromEntries(playerResumeTokens),
+        playerResumeTokens: snapshotPlayerResumeTokens(),
         sequences: {
           trace: traceSequence,
           turn: turnSequence,
           judgeCall: judgeCallSequence,
           playerCall: playerCallSequence,
-          playbookCall: 0,
+          playbookCall: playbookCallSequence,
         },
         state,
         pendingBossQuestions: pendingQuestionsFromContext(context).map(
@@ -1650,7 +1755,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         disposalPromise !== undefined
       ) {
         throw new Error(
-          'discuss runtime: restore(session, snapshot) may only be called once',
+          'decide runtime: restore(session, snapshot) may only be called once',
         );
       }
       const identity = snapshotPlaybookSession(session);
@@ -1666,32 +1771,45 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       lifecycleStarted = true;
       ports = identity.ports;
       sessionIdentity = identity;
+      let priorExternalPlayerTokens:
+        | Readonly<Record<string, string>>
+        | undefined;
       try {
         traceSequence = boundSnapshot.sequences.trace;
         turnSequence = boundSnapshot.sequences.turn;
         judgeCallSequence = boundSnapshot.sequences.judgeCall;
         playerCallSequence = boundSnapshot.sequences.playerCall;
-        playerResumeTokens.clear();
-        for (const [playerId, token] of Object.entries(
-          boundSnapshot.playerResumeTokens,
-        )) {
-          playerResumeTokens.set(playerId, token);
+        playbookCallSequence = boundSnapshot.sequences.playbookCall;
+        if (identity.playerSessions) {
+          priorExternalPlayerTokens = snapshotPlayerResumeTokens();
         }
+        restorePlayerResumeTokens(boundSnapshot.playerResumeTokens);
         suppressInspectionEmissions = true;
         createRuntimeActor(boundSnapshot.machine);
         actor?.start();
         const restoredState = currentState();
         if (restoredState.status !== 'active') {
           throw new Error(
-            `discuss runtime: restored actor status is ${restoredState.status}, expected active`,
+            `decide runtime: restored actor status is ${restoredState.status}, expected active`,
           );
         }
         suppressInspectionEmissions = false;
         previousState = restoredState;
         await flush();
       } catch (error) {
+        let failure = error;
+        if (priorExternalPlayerTokens !== undefined) {
+          try {
+            identity.playerSessions!.restore(priorExternalPlayerTokens);
+          } catch (rollbackError) {
+            failure = new AggregateError(
+              [error, rollbackError],
+              'DECIDE restore and player continuation rollback failed',
+            );
+          }
+        }
         await cleanupFailedStart({ emitDisposal: false });
-        throw error;
+        throw failure;
       } finally {
         finishInitialization();
         if (initInFlight === initialization) initInFlight = undefined;
@@ -1703,16 +1821,16 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       signal: AbortSignal;
     }): Promise<PlaybookRunResult> {
       if (disposalPromise !== undefined) {
-        throw new Error('discuss runtime: runtime is disposing or disposed');
+        throw new Error('decide runtime: runtime is disposing or disposed');
       }
       requirePorts();
       if (!actor) {
         throw new Error(
-          'discuss runtime: init(session) must be called before handleBossInput',
+          'decide runtime: init(session) must be called before handleBossInput',
         );
       }
-      if (currentTurnId !== undefined) {
-        throw new Error('discuss runtime: another runtime turn is active');
+      if (currentSignal !== undefined) {
+        throw new Error('decide runtime: another runtime turn is active');
       }
 
       const turnId = ++turnSequence;
@@ -1733,10 +1851,12 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             const state = currentState();
             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') {
-              actor.stop();
+              stopActor();
               startActor();
             }
 
@@ -1817,36 +1937,77 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
 
       if (failures.length === 1) throw failures[0];
       if (failures.length > 1) {
-        throw new AggregateError(failures, 'discuss runtime turn failed');
+        throw new AggregateError(failures, 'decide runtime turn failed');
       }
       return result;
     },
 
     async resumePlaybookCall({
       callId,
+      result: childResult,
+      signal,
     }: {
       callId: string;
       result: PlaybookCallResult;
       signal: AbortSignal;
     }): Promise<PlaybookRunResult> {
       if (disposalPromise !== undefined) {
-        throw new Error('discuss runtime: runtime is disposing or disposed');
+        throw new Error('decide runtime: runtime is disposing or disposed');
       }
       requirePorts();
       if (!actor) {
         throw new Error(
-          'discuss runtime: init(session) must be called before resumePlaybookCall',
+          'decide runtime: init(session) must be called before resumePlaybookCall',
         );
       }
-      throw new Error(`unknown or stale playbook call id ${callId}`);
+      if (currentSignal !== undefined) {
+        throw new Error('decide runtime: another runtime turn is active');
+      }
+      currentTurnId = playbookCallTurnIds.get(callId);
+      currentSignal = signal;
+      controlPlaneError = undefined;
+      let runResult: PlaybookRunResult | undefined;
+      let operationError: unknown;
+      try {
+        await nestedBridge.resume({
+          callId,
+          result: childResult,
+          signal,
+        });
+      } catch (error) {
+        operationError = error;
+      }
+      try {
+        await waitForPlaybookQuiescence(actor, {
+          pendingCalls: nestedBridge,
+        });
+        runResult = resultForSnapshot(signal);
+      } catch (error) {
+        operationError ??= error;
+      }
+      let drainError: unknown;
+      try {
+        await drainBoundaryCallsAndEmissions();
+      } catch (error) {
+        drainError = error;
+      }
+      const failure = controlPlaneError ?? drainError ?? operationError;
+      currentSignal = undefined;
+      currentTurnId = undefined;
+      controlPlaneError = undefined;
+      if (failure !== undefined) throw failure;
+      if (runResult === undefined) {
+        throw new Error('decide runtime: playbook resume produced no result');
+      }
+      return runResult;
     },
 
     dispose(): Promise<void> {
       if (disposalPromise !== undefined) return disposalPromise;
-      if (currentTurnId !== undefined) {
+      if (currentSignal !== undefined) {
         return Promise.reject(
           new Error(
-            'discuss runtime: cannot dispose while a runtime turn is active',
+            'decide runtime: cannot dispose while a runtime turn is active',
           ),
         );
       }
@@ -1859,8 +2020,11 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         }
         const finalState = currentState();
         const failures: unknown[] = [];
-        if (actor) {
-          actor.stop();
+        stopActor();
+        try {
+          await nestedBridge.dispose();
+        } catch (error) {
+          collectFailure(failures, error);
         }
         try {
           await drainBoundaryCallsAndEmissions();
@@ -1881,6 +2045,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           collectFailure(failures, error);
         } finally {
           playerResumeTokens.clear();
+          playbookCallTurnIds.clear();
           inFlightPlayerIds.clear();
           activeBoundaryCalls.clear();
           activeEmissionCalls.clear();
@@ -1897,7 +2062,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         }
         if (failures.length === 1) throw failures[0];
         if (failures.length > 1) {
-          throw new AggregateError(failures, 'discuss runtime disposal failed');
+          throw new AggregateError(failures, 'decide runtime disposal failed');
         }
       })();
       return disposalPromise;
@@ -1919,10 +2084,10 @@ export const _internal = {
   normalizeErrorCompact,
   normalizeErrorFull,
   DEFAULT_PLAYER_BINDING,
-  ALIAS_RESOLUTION,
   STATE_DESCRIPTIONS,
-  CAPTAIN_STATES,
-  CAPTAIN_STATE_IDS,
+  PLAYER_STATES,
+  PLAYER_STATE_IDS,
+  VERBATIM_PAYLOAD_FIELDS,
   BOSS_INTERRUPT_TARGETS,
   CONTINUATION_PREAMBLE,
   TELEMETRY_TOPIC,