@sublang/playbook 4.0.0 → 6.0.0

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

@@ -1,205 +1,97 @@
 // 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';
-import { assertJsonSafe, assertPlaybookRuntimeSnapshot, combineAbortSignals, detachPersistedMachineSnapshot, normalizeError, normalizePlaybookSnapshot, snapshotJsonValue, snapshotPlaybookSession, validatePlayerResult, waitForPlaybookQuiescence, } from '../../../src/xstate-runtime.js';
-import discussMachine from './discuss.fsm.js';
+import { assertJsonSafe, assertPlaybookRuntimeSnapshot, combineAbortSignals, createNestedPlaybookBridge, detachPersistedMachineSnapshot, normalizeError, normalizePlaybookSnapshot, snapshotJsonValue, snapshotPlaybookSession, validatePlayerResult, waitForPlaybookQuiescence, } from '../../../src/xstate-runtime.js';
+import decideMachine from './decide.fsm.js';
 const DEFAULT_PLAYER_BINDING = {
-    Host: 'host',
-    Participant: 'participant',
-    Committer: 'committer',
+    Coder: 'coder',
+    Reviewer: 'reviewer',
 };
-const ALIAS_RESOLUTION = {
-    '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) {
-    const captured = snapshotJsonValue(value, 'DISCUSS runtime options');
+function snapshotDecideRuntimeOptions(value) {
+    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']) {
-        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');
+            throw new TypeError('DECIDE runtime options.playerBinding must be an object');
         }
-        const playerNames = new Set([
-            'Host',
-            'Participant',
-            'Committer',
-        ]);
+        const playerNames = new Set(['Coder', 'Reviewer']);
         for (const [player, playerId] of Object.entries(playerBinding)) {
             if (!playerNames.has(player)) {
-                throw new TypeError(`DISCUSS runtime options.playerBinding.${player} is not declared`);
+                throw new TypeError(`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`);
+                throw new TypeError(`DECIDE runtime options.playerBinding.${player} must be a non-empty string`);
             }
         }
     }
     return captured;
 }
 const STATE_DESCRIPTIONS = {
-    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' },
-    {
-        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',
-    },
+const PLAYER_STATES = [
+    { stateId: 'askCoderProposal', player: 'Coder', sourceItem: 'DECIDE-1' },
     {
-        stateId: 'participantAddressesRebuttals',
-        player: 'Participant',
-        sourceItem: 'DISCUSS-13',
+        stateId: 'askReviewerProposal',
+        player: 'Reviewer',
+        sourceItem: 'DECIDE-2',
     },
-    {
-        stateId: 'commitReviewedChanges',
-        player: 'Committer',
-        sourceItem: 'DISCUSS-15',
-    },
-];
-const CAPTAIN_STATE_IDS = new Set(CAPTAIN_STATES.map((state) => state.stateId));
-const BOSS_INTERRUPT_TARGETS = [
-    'ready',
-    'initialProposalRound',
-    'reconciliationRound',
-    'hostWritesAgreement',
-    'commitInitialChanges',
-    'reviewSpecInitialCommit',
-    'reviewSpecHostChanges',
-    'reviewDrInitialCommit',
-    'reviewDrHostChanges',
-    'reviewMixedInitialCommit',
-    'reviewMixedHostChanges',
-    'hostAddressesFindings',
-    'participantAddressesRebuttals',
-    'commitReviewedChanges',
-    'failed',
+    { stateId: 'commitCoderProposal', player: 'Coder', sourceItem: 'DECIDE-3' },
 ];
+const PLAYER_STATE_IDS = new Set(PLAYER_STATES.map((state) => state.stateId));
+const BOSS_INTERRUPT_TARGETS = ['independentProposals'];
 const BOSS_INTERRUPT_TARGET_IDS = new Set(BOSS_INTERRUPT_TARGETS);
-const REVIEW_SCOPES = new Set([
-    'specItems',
-    'decisionRecords',
-    'mixed',
-]);
 const TELEMETRY_TOPIC = 'playbook.fsm.state';
 const TRACE_TOPIC = 'playbook.trace';
 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.';
 const PLACEHOLDER_FIELDS = [
-    ['<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 = new Set([
+    'coderProposal',
+    'reviewerProposal',
+    'coderOutput',
+]);
 function composePlayerPrompt(input) {
     const blocks = [];
     if (input.pendingBossQuestion && input.bossReply !== undefined) {
@@ -213,35 +105,38 @@ function composePlayerPrompt(input) {
             input.bossReply,
         ].join('\n'));
     }
-    let body = input.prompt;
+    const replacements = new Map();
     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, source) => {
+        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');
 }
 function resolvePlayerId(input, binding) {
     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 = input.player;
             throw new Error(`unknown player ${String(exhaustive)}`);
         }
     }
 }
-// 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) {
     const fields = [];
     const sentence = /Output shall include([^.]*)/g;
@@ -364,7 +259,7 @@ function dropTrailingComma(value) {
 }
 function buildClassifierPrompt(text, ctx) {
     const lines = [];
-    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.');
     lines.push('');
     lines.push(`Current FSM state: ${JSON.stringify(ctx.state.value)}`);
@@ -372,84 +267,66 @@ function buildClassifierPrompt(text, ctx) {
     if (ctx.pendingQuestions.length > 0) {
         lines.push('Pending Boss questions:');
         for (const pending of ctx.pendingQuestions) {
-            lines.push(`- ${pending.questionId} (${pending.player}, ${pending.sourceItem}): ${pending.question}`);
+            lines.push(`- ${pending.questionId} (${pending.player}): ${pending.question}`);
         }
         lines.push('If the Boss message answers a pending question, classify it as BOSS_REPLY; if it is a fresh directive, classify it accordingly.');
     }
     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.');
-    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.');
+    lines.push(`- BOSS_INTERRUPT: required targetId string, exactly ${BOSS_INTERRUPT_TARGETS[0]}; the runtime attaches the exact Boss text as bossIntent.`);
+    lines.push('- 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 }.');
-    lines.push('Use null when no FSM action applies.');
+    lines.push('Reply with a single JSON object: { "type": "<EVENT_TYPE>", ...declared fields }.');
+    lines.push('Use NO_ACTION when no FSM action applies.');
     return lines.join('\n');
 }
-function parseClassification(raw, pendingQuestionIds = []) {
+function parseClassification(raw, text, pendingQuestionIds = []) {
     const obj = extractJson(raw);
     if (!obj)
         return null;
-    const eventType = obj.event ?? 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,
-                ...(typeof obj.rebuttals === 'string'
-                    ? { rebuttals: obj.rebuttals }
-                    : {}),
-            };
-        }
-        return null;
+    const exactKeys = (...keys) => {
+        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 === 'NO_ACTION') {
+        return exactKeys('type') ? { type: 'NO_ACTION' } : null;
     }
     if (eventType === 'BOSS_INTERRUPT') {
-        if (typeof obj.targetId === 'string' &&
+        if (exactKeys('type', 'targetId') &&
+            typeof obj.targetId === 'string' &&
             BOSS_INTERRUPT_TARGET_IDS.has(obj.targetId)) {
-            return { type: 'BOSS_INTERRUPT', targetId: obj.targetId };
+            return {
+                type: 'BOSS_INTERRUPT',
+                targetId: obj.targetId,
+                bossIntent: text,
+            };
         }
         return null;
     }
     if (eventType === 'BOSS_REPLY') {
-        if (typeof obj.answer !== 'string' || pendingQuestionIds.length === 0) {
+        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,
-                    answer: obj.answer,
+                    answer: text,
                 }
                 : null;
         }
-        return pendingQuestionIds.length === 1
+        return exactKeys('type') && pendingQuestionIds.length === 1
             ? {
                 type: 'BOSS_REPLY',
                 questionId: pendingQuestionIds[0],
-                answer: obj.answer,
+                answer: text,
             }
             : null;
     }
@@ -473,11 +350,22 @@ function buildAdjudicatorPrompt(input, playerOutput) {
     for (const [guard, description] of Object.entries(input.result)) {
         lines.push(`- ${guard}: ${description}`);
     }
+    const runtimeOwnedFields = new Set();
+    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 }.');
     return lines.join('\n');
 }
-function parseAdjudication(raw, input) {
+function parseAdjudication(raw, input, finalText) {
     const obj = extractJson(raw);
     if (!obj || typeof obj.guard !== 'string' || obj.guard.trim() === '') {
         throw new Error('adjudicator returned empty or malformed JSON');
@@ -486,25 +374,26 @@ function parseAdjudication(raw, input) {
     if (!Object.prototype.hasOwnProperty.call(input.result, guard)) {
         throw new Error(`adjudicator returned undeclared guard "${guard}" for ${input.sourceItem}`);
     }
-    // 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 };
-    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 = { 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}"`);
         }
-    }
-    if ('reviewScope' in output &&
-        typeof output.reviewScope === 'string' &&
-        !REVIEW_SCOPES.has(output.reviewScope)) {
-        throw new Error(`adjudicator returned invalid reviewScope "${output.reviewScope}"`);
+        output[field] = value;
     }
     return output;
 }
@@ -520,12 +409,15 @@ function normalizeErrorCompact(err) {
 function normalizeErrorFull(err) {
     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) {
+    return finalText === undefined || finalText.trim().length === 0;
+}
 function isAbortFailure(error, signal) {
-    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(context) {
     const pending = context.pendingBossQuestions;
@@ -552,17 +444,15 @@ function pendingQuestionsFromContext(context) {
     return questions.sort((left, right) => left.questionId.localeCompare(right.questionId));
 }
 const WAIT_STATE_RESUME_IDS = {
-    waitHostInitialReply: 'askHostInitial',
-    waitParticipantInitialReply: 'askParticipantInitial',
-    waitHostReconciliationReply: 'hostInitialRound',
-    waitParticipantReconciliationReply: 'participantInitialRound',
+    waitCoderProposalReply: 'askCoderProposal',
+    waitReviewerProposalReply: 'askReviewerProposal',
 };
 const WAIT_STATE_IDS = new Set([
     ...Object.keys(WAIT_STATE_RESUME_IDS),
     'awaitBossReply',
 ]);
 const STATUS_STATE_IDS = new Set([
-    ...CAPTAIN_STATE_IDS,
+    ...PLAYER_STATE_IDS,
     ...WAIT_STATE_IDS,
     'failed',
 ]);
@@ -575,38 +465,44 @@ function questionForWaitState(stateId, pendingQuestions) {
         ? pendingQuestions[0]
         : undefined;
 }
-function normalizedEventType(event) {
-    if (event !== null &&
-        typeof event === 'object' &&
-        !Array.isArray(event) &&
-        'type' in event) {
-        const type = event.type;
-        return typeof type === 'string' ? type : String(type);
+const TRANSITION_EVENT_FIELDS = [
+    'callerTopic',
+    'targetId',
+    'bossIntent',
+    'questionId',
+    'answer',
+];
+function normalizedTransitionEvent(event) {
+    if (event === null || typeof event !== 'object') {
+        return snapshotJsonValue(event ?? null, 'FSM event');
+    }
+    const source = event;
+    const descriptor = {};
+    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];
+        }
     }
-    if (event === null ||
-        typeof event === 'string' ||
-        typeof event === 'boolean' ||
-        (typeof event === 'number' && Number.isFinite(event))) {
-        return event;
+    if (source.output !== undefined) {
+        descriptor.output = snapshotJsonValue(source.output, 'FSM event output');
     }
-    return String(event);
+    if (source.error !== undefined) {
+        descriptor.error = snapshotJsonValue(normalizeError(source.error), 'FSM event error');
+    }
+    return snapshotJsonValue(descriptor, 'FSM event');
 }
 function telemetryPayload(previousState, state, event, context) {
-    const eventError = event !== null &&
-        typeof event === 'object' &&
-        !Array.isArray(event) &&
-        'error' in event
-        ? normalizeErrorFull(event.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 }
             : {}),
@@ -615,15 +511,13 @@ function telemetryPayload(previousState, state, event, context) {
     return payload;
 }
 export const createPlaybookRuntime = (options) => {
-    const boundOptions = snapshotDiscussRuntimeOptions(options);
+    const boundOptions = snapshotDecideRuntimeOptions(options);
     const binding = {
         ...DEFAULT_PLAYER_BINDING,
         ...(boundOptions.playerBinding ?? {}),
     };
     const fsmInput = {
-        host: boundOptions.host,
-        participant: boundOptions.participant,
-        committer: boundOptions.committer,
+        coderLlm: boundOptions.coderLlm,
     };
     let ports;
     let sessionIdentity;
@@ -637,12 +531,15 @@ export const createPlaybookRuntime = (options) => {
     let turnSequence = 0;
     let judgeCallSequence = 0;
     let playerCallSequence = 0;
+    let playbookCallSequence = 0;
     let lifecycleStarted = false;
     let initInFlight;
     let disposed = false;
     let disposalPromise;
     let controlPlaneError;
+    let nestedBridge;
     const playerResumeTokens = new Map();
+    const playbookCallTurnIds = new Map();
     const inFlightPlayerIds = new Set();
     const activeBoundaryCalls = new Set();
     const activeEmissionCalls = new Set();
@@ -662,6 +559,14 @@ export const createPlaybookRuntime = (options) => {
         if (!isAbortFailure(error, signal))
             controlPlaneError ??= error;
     };
+    const latchInspectionError = (error) => {
+        if (currentSignal !== undefined) {
+            latchControlPlaneError(error, currentSignal);
+        }
+        else {
+            collectFailure(emissionFailures, error);
+        }
+    };
     const enqueue = (fn) => {
         const queued = emissionQueue.add(fn);
         activeEmissionCalls.add(queued);
@@ -689,7 +594,7 @@ export const createPlaybookRuntime = (options) => {
         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 () => {
         while (true) {
@@ -708,22 +613,78 @@ export const createPlaybookRuntime = (options) => {
     };
     const requirePorts = () => {
         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 = () => {
         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) => {
+        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, resumeToken) => {
+        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 = () => {
+        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 = {};
+        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) => {
+        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 = () => {
         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) => {
         return state.stateId === undefined ? {} : { stateId: state.stateId };
@@ -795,7 +756,7 @@ export const createPlaybookRuntime = (options) => {
             ...(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();
@@ -839,9 +800,16 @@ export const createPlaybookRuntime = (options) => {
         if (inFlightPlayerIds.has(playerId)) {
             throw new Error(`resolved player "${playerId}" already has an in-flight call`);
         }
-        inFlightPlayerIds.add(playerId);
         const prompt = composePlayerPrompt(input);
-        const resume = playerResumeTokens.get(playerId) ?? false;
+        let resume;
+        try {
+            signal.throwIfAborted();
+            resume = selectPlayerResume(playerId);
+        }
+        catch (error) {
+            latchControlPlaneError(error, signal);
+            throw error;
+        }
         const callId = `player-${++playerCallSequence}`;
         const identity = {
             purpose: 'captain',
@@ -858,6 +826,7 @@ export const createPlaybookRuntime = (options) => {
                 message: String(error),
             },
         }, { turnId: currentTurnId, callId });
+        inFlightPlayerIds.add(playerId);
         try {
             await emitCallStarted('player.call.started', 'player.call.finished', { ...identity, prompt }, { turnId: currentTurnId, callId }, signal);
             let rawResult;
@@ -865,14 +834,14 @@ export const createPlaybookRuntime = (options) => {
                 signal.throwIfAborted();
                 const boundary = Promise.resolve(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 {
@@ -893,18 +862,27 @@ export const createPlaybookRuntime = (options) => {
                     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);
+            try {
+                updatePlayerResume(playerId, typeof result.resumeToken === 'string' &&
+                    result.resumeToken.trim().length > 0
+                    ? result.resumeToken
+                    : undefined);
             }
-            else {
-                playerResumeTokens.delete(playerId);
+            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
             // the event and then reject; retrying from that catch would duplicate the
@@ -944,24 +922,85 @@ export const createPlaybookRuntime = (options) => {
             throw error;
         }
         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}"${result.error ? `: ${result.error}` : ''}`);
         }
-        if (result.finalText === undefined) {
+        const finalText = result.finalText ?? '';
+        if (isEmptyFinalText(finalText)) {
             throw new Error(`player "${playerId}" returned status "ok" with no finalText`);
         }
         combined.throwIfAborted();
         try {
-            const prompt = buildAdjudicatorPrompt(input, result.finalText);
-            return parseAdjudication(await callJudge(prompt, combined, 'player-output-adjudication', input.stateId), input);
+            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 providedMachine = discussMachine.provide({ actors: { player } });
+    nestedBridge = createNestedPlaybookBridge({
+        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) => {
         if (event.type !== '@xstate.snapshot')
             return;
@@ -969,49 +1008,58 @@ export const createPlaybookRuntime = (options) => {
             return;
         if (suppressInspectionEmissions)
             return;
-        const snapshot = event.snapshot;
-        const state = normalizePlaybookSnapshot(snapshot);
-        const prior = previousState;
-        previousState = state;
-        const runtimePorts = ports;
-        if (!runtimePorts)
-            return;
-        const context = snapshot.context;
-        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, stateId, data) => {
-            const tracePayload = {
-                ...(bossRelevantStateIds.length === 1 ? { stateId } : {}),
-                message,
-                state,
-                ...(data !== undefined ? { data } : {}),
+        try {
+            const snapshot = event.snapshot;
+            const state = normalizePlaybookSnapshot(snapshot);
+            const prior = previousState ?? state;
+            const context = snapshot.context;
+            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(previousState?.activeStateIds ?? []);
+            previousState = state;
+            const pendingQuestions = pendingQuestionsFromContext(context);
+            const bossRelevantStateIds = state.activeStateIds.filter((stateId) => STATUS_STATE_IDS.has(stateId));
+            const scheduleStatus = (message, stateId, data) => {
+                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);
             };
-            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);
+            for (const activeStateId of state.activeStateIds) {
+                if (priorIds.has(activeStateId) ||
+                    !STATUS_STATE_IDS.has(activeStateId)) {
+                    continue;
                 }
-                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;
+                }
+                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);
         }
     };
     const createRuntimeActor = (machineSnapshot) => {
@@ -1028,37 +1076,63 @@ export const createPlaybookRuntime = (options) => {
             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 = () => {
+        if (!actor)
+            return;
+        suppressInspectionEmissions = true;
+        actor.stop();
+    };
     const startActor = () => {
         createRuntimeActor();
+        // A fresh actor's emissions are real state entries again.
+        suppressInspectionEmissions = false;
         actor?.start();
     };
     const driveToQuiescence = async () => {
         const live = actor;
         if (!live)
-            throw new Error('discuss runtime: actor is not initialized');
-        await waitForPlaybookQuiescence(live);
+            throw new Error('decide runtime: actor is not initialized');
+        await waitForPlaybookQuiescence(live, { pendingCalls: nestedBridge });
     };
     const classify = async (text, signal) => {
         const live = actor;
         if (!live)
-            throw new Error('discuss runtime: actor is not initialized');
+            throw new Error('decide runtime: actor is not initialized');
         const snapshot = live.getSnapshot();
         const context = snapshot.context;
-        const state = normalizePlaybookSnapshot(snapshot);
+        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,
         });
         const raw = await callJudge(prompt, signal, 'boss-input-classification', state.stateId);
-        return parseClassification(raw, pendingQuestions.map(({ questionId }) => questionId));
+        return parseClassification(raw, text, pendingQuestions.map(({ questionId }) => questionId));
     };
     const resultForSnapshot = (signal) => {
         const live = actor;
         if (!live)
-            throw new Error('discuss runtime: actor is not initialized');
+            throw new Error('decide runtime: actor is not initialized');
         const snapshot = live.getSnapshot();
-        const state = normalizePlaybookSnapshot(snapshot);
+        const pendingCall = nestedBridge.getPendingCall();
+        const state = normalizePlaybookSnapshot(snapshot, { pendingCall });
         const context = snapshot.context;
         if (signal?.aborted) {
             return {
@@ -1086,7 +1160,7 @@ export const createPlaybookRuntime = (options) => {
         }
         if (snapshot.status === 'error') {
             throw (snapshot.error ??
-                new Error('discuss runtime actor entered error status'));
+                new Error('decide runtime actor entered error status'));
         }
         if (state.activeStateIds.includes('failed')) {
             const error = normalizeErrorFull(context.lastError);
@@ -1096,6 +1170,9 @@ export const createPlaybookRuntime = (options) => {
                 ...(error === undefined ? {} : { error }),
             };
         }
+        if (pendingCall) {
+            return { outcome: 'suspended', state, pendingCall };
+        }
         return { outcome: 'quiescent', state };
     };
     // Shared failed-start cleanup for init and restore: stop the actor,
@@ -1114,9 +1191,8 @@ export const createPlaybookRuntime = (options) => {
                 // A state that cannot even normalize has no disposal descriptor.
             }
         }
-        suppressInspectionEmissions = true;
         try {
-            actor?.stop();
+            stopActor();
         }
         catch {
             // Preserve the original startup failure.
@@ -1160,6 +1236,8 @@ export const createPlaybookRuntime = (options) => {
         turnSequence = 0;
         judgeCallSequence = 0;
         playerCallSequence = 0;
+        playbookCallSequence = 0;
+        playbookCallTurnIds.clear();
         lifecycleStarted = false;
     };
     return {
@@ -1168,7 +1246,7 @@ export const createPlaybookRuntime = (options) => {
                 initInFlight !== undefined ||
                 disposed ||
                 disposalPromise !== undefined) {
-                throw new Error('discuss runtime: init(session) may only be called once');
+                throw new Error('decide runtime: init(session) may only be called once');
             }
             const identity = snapshotPlaybookSession(session);
             let finishInitialization;
@@ -1203,8 +1281,7 @@ export const createPlaybookRuntime = (options) => {
         // 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() {
             if (!actor ||
                 !sessionIdentity ||
@@ -1215,6 +1292,8 @@ export const createPlaybookRuntime = (options) => {
             if (currentTurnId !== undefined || currentSignal !== undefined) {
                 return undefined;
             }
+            if (nestedBridge.getPendingCall())
+                return undefined;
             const state = currentState();
             if (state.status !== 'active' || !state.quiescent)
                 return undefined;
@@ -1224,13 +1303,13 @@ export const createPlaybookRuntime = (options) => {
                 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((pending) => ({
@@ -1251,7 +1330,7 @@ export const createPlaybookRuntime = (options) => {
                 initInFlight !== undefined ||
                 disposed ||
                 disposalPromise !== undefined) {
-                throw new Error('discuss runtime: restore(session, snapshot) may only be called once');
+                throw new Error('decide runtime: restore(session, snapshot) may only be called once');
             }
             const identity = snapshotPlaybookSession(session);
             const boundSnapshot = assertPlaybookRuntimeSnapshot(snapshot, identity.playbookId);
@@ -1263,29 +1342,40 @@ export const createPlaybookRuntime = (options) => {
             lifecycleStarted = true;
             ports = identity.ports;
             sessionIdentity = identity;
+            let priorExternalPlayerTokens;
             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`);
+                    throw new Error(`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();
@@ -1295,14 +1385,14 @@ export const createPlaybookRuntime = (options) => {
         },
         async handleBossInput(turn) {
             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');
+                throw new Error('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;
             currentTurnId = turnId;
@@ -1324,10 +1414,13 @@ export const createPlaybookRuntime = (options) => {
                         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();
                         }
                         actor.send(event);
@@ -1412,25 +1505,68 @@ export const createPlaybookRuntime = (options) => {
             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, }) {
+        async resumePlaybookCall({ callId, result: childResult, signal, }) {
             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');
+                throw new Error('decide runtime: init(session) must be called before resumePlaybookCall');
+            }
+            if (currentSignal !== undefined) {
+                throw new Error('decide runtime: another runtime turn is active');
+            }
+            currentTurnId = playbookCallTurnIds.get(callId);
+            currentSignal = signal;
+            controlPlaneError = undefined;
+            let runResult;
+            let operationError;
+            try {
+                await nestedBridge.resume({
+                    callId,
+                    result: childResult,
+                    signal,
+                });
+            }
+            catch (error) {
+                operationError = error;
             }
-            throw new Error(`unknown or stale playbook call id ${callId}`);
+            try {
+                await waitForPlaybookQuiescence(actor, {
+                    pendingCalls: nestedBridge,
+                });
+                runResult = resultForSnapshot(signal);
+            }
+            catch (error) {
+                operationError ??= error;
+            }
+            let drainError;
+            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() {
             if (disposalPromise !== undefined)
                 return disposalPromise;
-            if (currentTurnId !== undefined) {
-                return Promise.reject(new Error('discuss runtime: cannot dispose while a runtime turn is active'));
+            if (currentSignal !== undefined) {
+                return Promise.reject(new Error('decide runtime: cannot dispose while a runtime turn is active'));
             }
             disposalPromise = (async () => {
                 const initialization = initInFlight;
@@ -1442,8 +1578,12 @@ export const createPlaybookRuntime = (options) => {
                 }
                 const finalState = currentState();
                 const failures = [];
-                if (actor) {
-                    actor.stop();
+                stopActor();
+                try {
+                    await nestedBridge.dispose();
+                }
+                catch (error) {
+                    collectFailure(failures, error);
                 }
                 try {
                     await drainBoundaryCallsAndEmissions();
@@ -1468,6 +1608,7 @@ export const createPlaybookRuntime = (options) => {
                 }
                 finally {
                     playerResumeTokens.clear();
+                    playbookCallTurnIds.clear();
                     inFlightPlayerIds.clear();
                     activeBoundaryCalls.clear();
                     activeEmissionCalls.clear();
@@ -1485,7 +1626,7 @@ export const createPlaybookRuntime = (options) => {
                 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;
@@ -1506,10 +1647,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,