@sublang/playbook 7.0.0 → 9.0.0

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

@@ -7,8 +7,8 @@
 // Linker inputs:
 //   FSM artifact:       ./decide.fsm.ts
 //   Link target:        @sublang/playbook/runtime
-//   Player binding:     Coder -> coder, Reviewer -> reviewer
-//                       (default binding: lowercased player name)
+//   Role binding:       canonical coder and reviewer roles; concrete players
+//                       and prompt identities are supplied by the host session
 //   Adjudication:       LLM-judge per state (default)
 //   Boss-event mapping: free-text judge classification (default)
 //   Abort strategy:     natural rejection; every player-invoking state's
@@ -19,80 +19,64 @@ import PQueue from 'p-queue';
 import { createActor, fromPromise } from 'xstate';
 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 = {
-    Coder: 'coder',
-    Reviewer: 'reviewer',
-};
 function snapshotDecideRuntimeOptions(value) {
     const captured = snapshotJsonValue(value, 'DECIDE runtime options');
     if (!isPlainObject(captured)) {
         throw new TypeError('DECIDE runtime options must be an object');
     }
-    const allowed = new Set(['coderLlm', 'playerBinding']);
-    for (const key of Object.keys(captured)) {
-        if (!allowed.has(key)) {
-            throw new TypeError(`DECIDE runtime options.${key} is not declared`);
-        }
-    }
-    if (typeof captured.coderLlm !== 'string' ||
-        captured.coderLlm.trim().length === 0) {
-        throw new TypeError('DECIDE runtime options.coderLlm must be a non-empty string');
+    const [unknown] = Object.keys(captured);
+    if (unknown !== undefined) {
+        throw new TypeError(`DECIDE runtime options.${unknown} is not declared`);
     }
-    if ('playerBinding' in captured) {
-        const playerBinding = captured.playerBinding;
-        if (!isPlainObject(playerBinding)) {
-            throw new TypeError('DECIDE runtime options.playerBinding must be an object');
-        }
-        const playerNames = new Set(['Coder', 'Reviewer']);
-        for (const [player, playerId] of Object.entries(playerBinding)) {
-            if (!playerNames.has(player)) {
-                throw new TypeError(`DECIDE runtime options.playerBinding.${player} is not declared`);
-            }
-            if (typeof playerId !== 'string' || playerId.trim().length === 0) {
-                throw new TypeError(`DECIDE runtime options.playerBinding.${player} must be a non-empty string`);
+    return Object.freeze({});
+}
+function authoredStateDescriptions(states) {
+    const descriptions = {};
+    const visit = (children) => {
+        for (const state of Object.values(children ?? {})) {
+            const stateId = state.meta?.playbook?.stateId;
+            const description = state.meta?.playbook?.description;
+            if (typeof stateId === 'string' &&
+                typeof description === 'string' &&
+                description.trim().length > 0) {
+                const existing = descriptions[stateId];
+                if (existing !== undefined && existing !== description) {
+                    throw new Error(`DECIDE state ${stateId} declares conflicting descriptions`);
+                }
+                descriptions[stateId] = description;
             }
+            visit(state.states);
         }
-    }
-    return captured;
+    };
+    visit(states);
+    return Object.freeze(descriptions);
 }
-const STATE_DESCRIPTIONS = {
-    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 PLAYER_STATES = [
-    { stateId: 'askCoderProposal', player: 'Coder', sourceItem: 'DECIDE-1' },
+const STATE_DESCRIPTIONS = authoredStateDescriptions(decideMachine.config.states);
+const ROLE_STATES = [
+    { stateId: 'askCoderProposal', role: 'coder', sourceItem: 'DECIDE-1' },
     {
         stateId: 'askReviewerProposal',
-        player: 'Reviewer',
+        role: 'reviewer',
         sourceItem: 'DECIDE-2',
     },
-    { stateId: 'commitCoderProposal', player: 'Coder', sourceItem: 'DECIDE-3' },
+    { stateId: 'commitCoderProposal', role: 'coder', sourceItem: 'DECIDE-3' },
 ];
-const PLAYER_STATE_IDS = new Set(PLAYER_STATES.map((state) => state.stateId));
+const ROLE_STATE_IDS = new Set(ROLE_STATES.map((state) => state.stateId));
+const ROLE_IDS = ['coder', 'reviewer'];
+const ROLE_ID_SET = new Set(ROLE_IDS);
+const roleLabel = (roleId) => roleId === 'coder' ? 'Coder' : 'Reviewer';
 const BOSS_INTERRUPT_TARGETS = ['independentProposals'];
 const BOSS_INTERRUPT_TARGET_IDS = new Set(BOSS_INTERRUPT_TARGETS);
 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 = [
-    ['<caller-topic>', 'callerTopic'],
-    ['<coder-llm>', 'coderLlm'],
-];
+const PLACEHOLDER_FIELDS = [['<caller-topic>', 'callerTopic']];
 const VERBATIM_PAYLOAD_FIELDS = new Set([
     'coderProposal',
     'reviewerProposal',
     'coderOutput',
 ]);
-function composePlayerPrompt(input) {
+function composePlayerPrompt(input, promptIdentity) {
     const blocks = [];
     if (input.pendingBossQuestion && input.bossReply !== undefined) {
         blocks.push([
@@ -111,6 +95,9 @@ function composePlayerPrompt(input) {
         if (typeof value === 'string')
             replacements.set(placeholder, value);
     }
+    if (input.prompt.includes('<coder-llm>')) {
+        replacements.set('<coder-llm>', promptIdentity('coder'));
+    }
     const body = input.prompt.replace(/<caller-topic>|<coder-llm>/g, (placeholder, offset, source) => {
         const value = replacements.get(placeholder);
         if (value === undefined)
@@ -123,18 +110,6 @@ function composePlayerPrompt(input) {
     blocks.push(body);
     return blocks.join('\n\n');
 }
-function resolvePlayerId(input, binding) {
-    switch (input.player) {
-        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 its
 // "Output shall include ..." sentence.
 function requiredFieldsFor(description) {
@@ -283,7 +258,7 @@ 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.question}`);
+            lines.push(`- ${pending.questionId} (${pending.asker.roleId}): ${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.');
     }
@@ -354,7 +329,7 @@ function buildAdjudicatorPrompt(input, playerOutput) {
     lines.push('This is hidden control work. Do not call tools, inspect files, or ' +
         'seek external evidence. Decide only from the supplied player output ' +
         'and guard descriptions. Reply with exactly one JSON object and no prose.');
-    lines.push(`The player "${input.player}" produced the output below for source item ${input.sourceItem}.`);
+    lines.push(`The role "${roleLabel(input.role)}" produced the output below for source item ${input.sourceItem}.`);
     lines.push('Choose exactly one guard whose description matches that output.');
     lines.push('');
     lines.push('Player output (verbatim):');
@@ -435,6 +410,14 @@ function isEmptyFinalText(finalText) {
 function isAbortFailure(error, signal) {
     return signal.aborted && Object.is(error, signal.reason);
 }
+function abortReasonClassifier(...sources) {
+    const captured = sources.filter((source) => source !== undefined);
+    return Object.freeze({
+        isAbortReason: (error) => captured.some((source) => source instanceof AbortSignal
+            ? isAbortFailure(error, source)
+            : source.isAbortReason(error)),
+    });
+}
 function pendingQuestionsFromContext(context) {
     const pending = context.pendingBossQuestions;
     if (pending === undefined ||
@@ -452,7 +435,9 @@ function pendingQuestionsFromContext(context) {
             obj.questionId === key &&
             typeof obj.resumeStateId === 'string' &&
             typeof obj.sourceItem === 'string' &&
-            typeof obj.player === 'string' &&
+            isPlainObject(obj.asker) &&
+            obj.asker.kind === 'role' &&
+            ROLE_ID_SET.has(String(obj.asker.roleId)) &&
             typeof obj.question === 'string') {
             questions.push(obj);
         }
@@ -468,10 +453,26 @@ const WAIT_STATE_IDS = new Set([
     'awaitBossReply',
 ]);
 const STATUS_STATE_IDS = new Set([
-    ...PLAYER_STATE_IDS,
+    ...ROLE_STATE_IDS,
     ...WAIT_STATE_IDS,
     'failed',
 ]);
+// PBRT-45: a question is pending only while its authored reply-wait state
+// is active. The context retains an answered question through the resumed
+// player call so the Q+A continuation prompt can quote it, and each branch
+// keeps its own entry through the parallel region — so an unfiltered
+// projection would report the answered question as still awaiting during
+// the resume, and both branch questions after only one remains pending.
+const RESUME_WAIT_STATE_IDS = {
+    ...Object.fromEntries(Object.entries(WAIT_STATE_RESUME_IDS).map(([waitStateId, resumeStateId]) => [
+        resumeStateId,
+        waitStateId,
+    ])),
+    commitCoderProposal: 'awaitBossReply',
+};
+function pendingQuestionsForState(state, context) {
+    return pendingQuestionsFromContext(context).filter((pending) => state.activeStateIds.includes(RESUME_WAIT_STATE_IDS[pending.resumeStateId] ?? ''));
+}
 function questionForWaitState(stateId, pendingQuestions) {
     const resumeStateId = WAIT_STATE_RESUME_IDS[stateId];
     if (resumeStateId !== undefined) {
@@ -510,7 +511,7 @@ function normalizedTransitionEvent(event) {
     return snapshotJsonValue(descriptor, 'FSM event');
 }
 function telemetryPayload(previousState, state, event, context) {
-    const pendingBossQuestions = pendingQuestionsFromContext(context);
+    const pendingBossQuestions = pendingQuestionsForState(state, context);
     const prior = previousState ?? state;
     const payload = {
         from: prior.value,
@@ -527,18 +528,14 @@ function telemetryPayload(previousState, state, event, context) {
     return payload;
 }
 export const createPlaybookRuntime = (options) => {
-    const boundOptions = snapshotDecideRuntimeOptions(options);
-    const binding = {
-        ...DEFAULT_PLAYER_BINDING,
-        ...(boundOptions.playerBinding ?? {}),
-    };
-    const fsmInput = {
-        coderLlm: boundOptions.coderLlm,
-    };
+    const fsmInput = snapshotDecideRuntimeOptions(options);
     let ports;
     let sessionIdentity;
     let actor;
     let currentSignal;
+    let currentAborts;
+    const actorSettlementAborts = [];
+    let actorSettlementErrorAborts;
     let currentTurnId;
     let previousState;
     let suppressInspectionEmissions = false;
@@ -554,9 +551,9 @@ export const createPlaybookRuntime = (options) => {
     let disposalPromise;
     let controlPlaneError;
     let nestedBridge;
-    const playerResumeTokens = new Map();
+    const privateResumeTokens = new Map();
     const playbookCallTurnIds = new Map();
-    const inFlightPlayerIds = new Set();
+    const inFlightPlayerKeys = new Set();
     const activeBoundaryCalls = new Set();
     const activeEmissionCalls = new Set();
     const emissionQueue = new PQueue({ concurrency: 1 });
@@ -575,24 +572,27 @@ export const createPlaybookRuntime = (options) => {
         if (!isAbortFailure(error, signal))
             controlPlaneError ??= error;
     };
-    const latchInspectionError = (error) => {
-        if (currentSignal !== undefined) {
-            latchControlPlaneError(error, currentSignal);
-        }
-        else {
+    const latchInspectionError = (error, aborts = currentAborts) => {
+        if (aborts?.isAbortReason(error))
+            return;
+        if (currentSignal !== undefined)
+            controlPlaneError ??= error;
+        else
             collectFailure(emissionFailures, error);
-        }
     };
-    const enqueue = (fn) => {
+    const enqueue = (fn, aborts = currentAborts) => {
+        const enqueueAborts = aborts;
         const queued = emissionQueue.add(fn);
         activeEmissionCalls.add(queued);
         void queued.then(() => activeEmissionCalls.delete(queued), (error) => {
             activeEmissionCalls.delete(queued);
-            collectFailure(emissionFailures, error);
+            if (!enqueueAborts?.isAbortReason(error)) {
+                collectFailure(emissionFailures, error);
+            }
         });
         return queued;
     };
-    const flush = async () => {
+    const flush = async (_aborts = currentAborts) => {
         while (true) {
             const active = [...activeEmissionCalls];
             if (active.length > 0)
@@ -608,9 +608,15 @@ export const createPlaybookRuntime = (options) => {
             return;
         const failures = emissionFailures;
         emissionFailures = [];
-        if (failures.length === 1)
-            throw failures[0];
-        throw new AggregateError(failures, 'decide runtime emissions failed');
+        const failure = failures.length === 1
+            ? failures[0]
+            : new AggregateError(failures, 'decide runtime emissions failed');
+        // Enqueue ownership already classified every stored failure as distinct.
+        // Preserve that classification if an unrelated public boundary drains
+        // it with a signal whose reason happens to be the same object.
+        if (currentSignal !== undefined)
+            controlPlaneError ??= failure;
+        throw failure;
     };
     const drainBoundaryCallsAndEmissions = async () => {
         while (true) {
@@ -639,59 +645,130 @@ export const createPlaybookRuntime = (options) => {
         }
         return sessionIdentity;
     };
-    const selectPlayerResume = (playerId) => {
+    const bindSession = (nextSession) => {
+        const bound = snapshotPlaybookSession(nextSession);
+        if (bound.roleBindings === undefined)
+            return bound;
+        const actual = Object.keys(bound.roleBindings).sort();
+        const expected = [...ROLE_IDS].sort();
+        const missing = expected.filter((roleId) => !actual.includes(roleId));
+        const extra = actual.filter((roleId) => !ROLE_ID_SET.has(roleId));
+        if (missing.length > 0 || extra.length > 0) {
+            throw new TypeError(`DECIDE session roleBindings must cover exactly [${expected.join(', ')}]` +
+                `${missing.length === 0 ? '' : `; missing [${missing.join(', ')}]`}` +
+                `${extra.length === 0 ? '' : `; extra [${extra.join(', ')}]`}`);
+        }
+        return bound;
+    };
+    const resolvedPlayerId = (roleId) => requireSessionIdentity().roleBindings?.[roleId]?.playerId;
+    const promptIdentity = (roleId) => requireSessionIdentity().roleBindings?.[roleId]?.promptIdentity ?? roleId;
+    const composeInvocationPrompt = (input) => {
+        let active = true;
+        const lookup = (roleId) => {
+            if (!active) {
+                throw new Error('DECIDE prompt identity lookup is no longer active for this invocation');
+            }
+            if (!ROLE_ID_SET.has(roleId)) {
+                throw new TypeError(`DECIDE prompt identity lookup rejected undeclared role ${String(roleId)}`);
+            }
+            return promptIdentity(roleId);
+        };
+        try {
+            return composePlayerPrompt(input, lookup);
+        }
+        finally {
+            active = false;
+        }
+    };
+    const continuationKey = (roleId, playerId) => playerId ?? roleId;
+    const tokensByContinuationKey = (tokens) => {
+        const byKey = new Map();
+        for (const [roleId, token] of Object.entries(tokens)) {
+            if (!ROLE_ID_SET.has(roleId)) {
+                throw new TypeError(`DECIDE role tokens contain unknown role ${roleId}`);
+            }
+            const typedRole = roleId;
+            const key = continuationKey(typedRole, resolvedPlayerId(typedRole));
+            const prior = byKey.get(key);
+            if (prior !== undefined && prior !== token) {
+                throw new TypeError(`DECIDE runtime snapshot assigns conflicting tokens to roles bound to player ${key}`);
+            }
+            byKey.set(key, token);
+        }
+        const rolesByKey = new Map();
+        for (const roleId of ROLE_IDS) {
+            const key = continuationKey(roleId, resolvedPlayerId(roleId));
+            rolesByKey.set(key, [...(rolesByKey.get(key) ?? []), roleId]);
+        }
+        for (const [key, roles] of rolesByKey) {
+            if (roles.length < 2)
+                continue;
+            const present = roles.filter((roleId) => tokens[roleId] !== undefined);
+            if (present.length !== 0 && present.length !== roles.length) {
+                throw new TypeError(`DECIDE role tokens must project player ${key} through every aliased role [${roles.join(', ')}]`);
+            }
+        }
+        return byKey;
+    };
+    const selectPlayerResume = (roleId, playerId) => {
         const session = requireSessionIdentity();
         const selected = session.playerSessions
-            ? session.playerSessions.select(playerId)
-            : playerResumeTokens.get(playerId) ?? false;
+            ? session.playerSessions.select(roleId)
+            : privateResumeTokens.get(continuationKey(roleId, 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}`);
+            throw new TypeError(`player session store returned an invalid resume token for role ${roleId}`);
         }
         return selected;
     };
-    const updatePlayerResume = (playerId, resumeToken) => {
+    const updatePlayerResume = (roleId, playerId, result) => {
+        if (result.resumeToken === undefined && result.status !== 'ok')
+            return;
         const session = requireSessionIdentity();
         if (session.playerSessions) {
-            session.playerSessions.update(playerId, resumeToken);
+            session.playerSessions.update(roleId, result.resumeToken);
         }
-        else if (resumeToken !== undefined && resumeToken.trim().length > 0) {
-            playerResumeTokens.set(playerId, resumeToken);
+        else if (result.resumeToken !== undefined) {
+            privateResumeTokens.set(continuationKey(roleId, playerId), result.resumeToken);
         }
         else {
-            playerResumeTokens.delete(playerId);
+            privateResumeTokens.delete(continuationKey(roleId, playerId));
         }
     };
-    const snapshotPlayerResumeTokens = () => {
+    const snapshotRoleResumeTokens = () => {
         const session = requireSessionIdentity();
         const captured = snapshotJsonValue(session.playerSessions
             ? session.playerSessions.snapshot()
-            : Object.fromEntries(playerResumeTokens), 'player session store snapshot');
+            : Object.fromEntries(ROLE_IDS.flatMap((roleId) => {
+                const token = privateResumeTokens.get(continuationKey(roleId, resolvedPlayerId(roleId)));
+                return token === undefined ? [] : [[roleId, token]];
+            })), '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');
+        for (const [roleId, token] of Object.entries(captured)) {
+            if (!ROLE_ID_SET.has(roleId)) {
+                throw new TypeError(`player session store snapshot contains unknown role ${roleId}`);
             }
             if (typeof token !== 'string' || token.trim().length === 0) {
-                throw new TypeError(`player session store snapshot token for ${playerId} must be a non-empty string`);
+                throw new TypeError(`player session store snapshot token for ${roleId} must be a non-empty string`);
             }
-            tokens[playerId] = token;
+            tokens[roleId] = token;
         }
+        tokensByContinuationKey(tokens);
         return tokens;
     };
-    const restorePlayerResumeTokens = (tokens) => {
+    const restoreRoleResumeTokens = (tokens) => {
+        const byKey = tokensByContinuationKey(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);
-        }
+        privateResumeTokens.clear();
+        for (const [key, token] of byKey)
+            privateResumeTokens.set(key, token);
     };
     const currentState = (pendingCall = nestedBridge.getPendingCall()) => {
         const live = actor;
@@ -705,12 +782,12 @@ export const createPlaybookRuntime = (options) => {
     const stateIdentity = (state) => {
         return state.stateId === undefined ? {} : { stateId: state.stateId };
     };
-    const enqueueTracedEmission = (type, payload, meta = {}, describedEmission) => {
+    const enqueueTracedEmission = (type, payload, meta = {}, describedEmission, aborts) => {
         const runtimePorts = requirePorts();
         const identity = requireSessionIdentity();
         const jsonPayload = snapshotJsonValue(payload, `trace ${type} payload`);
         const trace = Object.freeze({
-            schemaVersion: 2,
+            schemaVersion: 3,
             sessionId: identity.sessionId,
             playbookId: identity.playbookId,
             rootSessionId: identity.rootSessionId,
@@ -731,9 +808,9 @@ export const createPlaybookRuntime = (options) => {
         return enqueue(async () => {
             await runtimePorts.emitTelemetry({ topic: TRACE_TOPIC, payload: trace });
             await describedEmission?.(runtimePorts);
-        });
+        }, aborts);
     };
-    const emitTrace = (type, payload, meta = {}) => enqueueTracedEmission(type, payload, meta);
+    const emitTrace = (type, payload, meta = {}, aborts) => enqueueTracedEmission(type, payload, meta, undefined, aborts);
     const emitBoundaryStatus = async (message, state) => {
         const bossRelevantStateIds = state.activeStateIds.filter((stateId) => STATUS_STATE_IDS.has(stateId));
         await enqueueTracedEmission('status.emitted', {
@@ -745,20 +822,24 @@ export const createPlaybookRuntime = (options) => {
         }, { turnId: currentTurnId }, (runtimePorts) => runtimePorts.emitStatus(message));
     };
     const emitCallStarted = async (startedType, finishedType, identity, meta, signal) => {
+        const aborts = abortReasonClassifier(signal);
         try {
-            await emitTrace(startedType, identity, meta);
+            await emitTrace(startedType, identity, meta, aborts);
         }
         catch (error) {
             latchControlPlaneError(error, signal);
             try {
                 await emitTrace(finishedType, {
                     ...identity,
-                    status: 'error',
+                    // A started-trace sink rejection causally identical to the
+                    // boundary reason is the abort's own evidence: the pair
+                    // finishes 'aborted', not 'error' (DR-036 §4).
+                    status: isAbortFailure(error, signal) ? 'aborted' : 'error',
                     error: normalizeErrorFull(error) ?? {
                         name: 'Error',
                         message: String(error),
                     },
-                }, meta);
+                }, meta, aborts);
             }
             catch {
                 // Preserve the start failure after one best-effort finish attempt.
@@ -767,6 +848,7 @@ export const createPlaybookRuntime = (options) => {
         }
     };
     const runJudgeCall = async (prompt, signal, purpose, callStateId) => {
+        const aborts = abortReasonClassifier(signal);
         const identity = {
             purpose,
             ...(callStateId !== undefined ? { stateId: callStateId } : {}),
@@ -794,15 +876,18 @@ export const createPlaybookRuntime = (options) => {
                 latchControlPlaneError(error, signal);
                 await emitTrace('judge.call.finished', {
                     ...identity,
-                    status: signal.aborted ? 'aborted' : 'error',
+                    // Only the exact abort reason is cancellation; a distinct
+                    // failure under an aborted signal stays an error
+                    // (slc/link.md §Abort).
+                    status: isAbortFailure(error, signal) ? 'aborted' : 'error',
                     error: normalizeErrorFull(error) ?? {
                         name: 'Error',
                         message: String(error),
                     },
-                }, { turnId: currentTurnId, callId });
+                }, { turnId: currentTurnId, callId }, aborts);
                 throw error;
             }
-            await emitTrace('judge.call.finished', { ...identity, status: 'ok', reply: finalText }, { turnId: currentTurnId, callId });
+            await emitTrace('judge.call.finished', { ...identity, status: 'ok', reply: finalText }, { turnId: currentTurnId, callId }, aborts);
             return finalText;
         });
         if (queued === undefined) {
@@ -812,15 +897,18 @@ export const createPlaybookRuntime = (options) => {
     };
     const callJudge = (prompt, signal, purpose, callStateId) => trackBoundaryCall(runJudgeCall(prompt, signal, purpose, callStateId));
     const runPlayerCall = async (input, signal) => {
-        const playerId = resolvePlayerId(input, binding);
-        if (inFlightPlayerIds.has(playerId)) {
-            throw new Error(`resolved player "${playerId}" already has an in-flight call`);
-        }
-        const prompt = composePlayerPrompt(input);
+        const aborts = abortReasonClassifier(signal);
+        if (!ROLE_ID_SET.has(input.role)) {
+            throw new TypeError(`DECIDE player input role must name a declared local role`);
+        }
+        const roleId = input.role;
+        const playerId = resolvedPlayerId(roleId);
+        const playerKey = continuationKey(roleId, playerId);
+        const prompt = composeInvocationPrompt(input);
         let resume;
         try {
             signal.throwIfAborted();
-            resume = selectPlayerResume(playerId);
+            resume = selectPlayerResume(roleId, playerId);
         }
         catch (error) {
             latchControlPlaneError(error, signal);
@@ -828,27 +916,36 @@ export const createPlaybookRuntime = (options) => {
         }
         const callId = `player-${++playerCallSequence}`;
         const identity = {
-            purpose: 'captain',
             stateId: input.stateId,
             sourceItem: input.sourceItem,
-            playerId,
+            roleId,
+            ...(playerId === undefined ? {} : { playerId }),
             resume,
         };
         const emitFailure = (error) => emitTrace('player.call.finished', {
             ...identity,
-            status: signal.aborted ? 'aborted' : 'error',
+            // Only the exact abort reason is cancellation; a distinct
+            // failure under an aborted signal stays an error
+            // (slc/link.md §Abort).
+            status: isAbortFailure(error, signal) ? 'aborted' : 'error',
             error: normalizeErrorFull(error) ?? {
                 name: 'Error',
                 message: String(error),
             },
-        }, { turnId: currentTurnId, callId });
-        inFlightPlayerIds.add(playerId);
+        }, { turnId: currentTurnId, callId }, aborts);
+        if (inFlightPlayerKeys.has(playerKey)) {
+            const error = new Error(`resolved player key "${playerKey}" already has an in-flight call`);
+            await emitCallStarted('player.call.started', 'player.call.finished', { ...identity, prompt }, { turnId: currentTurnId, callId }, signal);
+            await emitFailure(error);
+            throw error;
+        }
+        inFlightPlayerKeys.add(playerKey);
         try {
             await emitCallStarted('player.call.started', 'player.call.finished', { ...identity, prompt }, { turnId: currentTurnId, callId }, signal);
             let rawResult;
             try {
                 signal.throwIfAborted();
-                const boundary = Promise.resolve(requirePorts().callPlayer(playerId, prompt, signal, { resume }));
+                const boundary = Promise.resolve(requirePorts().callPlayer(roleId, prompt, signal, { resume }));
                 rawResult = await boundary;
                 // An XState sibling cancellation does not cancel an arbitrary coder
                 // promise. Re-check before a late resolution can mutate continuity or
@@ -885,10 +982,7 @@ export const createPlaybookRuntime = (options) => {
             // The resolved result is authoritative even on aborted/error status.
             // Update continuation state before interpreting that status.
             try {
-                updatePlayerResume(playerId, typeof result.resumeToken === 'string' &&
-                    result.resumeToken.trim().length > 0
-                    ? result.resumeToken
-                    : undefined);
+                updatePlayerResume(roleId, playerId, result);
             }
             catch (error) {
                 latchControlPlaneError(error, signal);
@@ -915,11 +1009,15 @@ export const createPlaybookRuntime = (options) => {
                 ...(result.error !== undefined
                     ? { error: normalizeErrorFull(result.error) }
                     : {}),
-            }, { turnId: currentTurnId, callId });
-            return { playerId, result };
+            }, { turnId: currentTurnId, callId }, aborts);
+            return {
+                roleId,
+                ...(playerId === undefined ? {} : { playerId }),
+                result,
+            };
         }
         finally {
-            inFlightPlayerIds.delete(playerId);
+            inFlightPlayerKeys.delete(playerKey);
         }
     };
     const callPlayer = (input, signal) => {
@@ -927,52 +1025,59 @@ export const createPlaybookRuntime = (options) => {
     };
     const player = fromPromise(async ({ input, signal }) => {
         const combined = combineSignals(signal, currentSignal);
-        // XState starts invoked actors while publishing the entering snapshot.
-        // Yield through the runtime emission queue before crossing the player
-        // boundary so state trace/status always precede its call-start trace.
+        const settlementAborts = abortReasonClassifier(combined);
         try {
-            await flush();
-        }
-        catch (error) {
-            latchControlPlaneError(error, combined);
-            throw error;
-        }
-        combined.throwIfAborted();
-        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).
+            // XState starts invoked actors while publishing the entering snapshot.
+            // Yield through the runtime emission queue before crossing the player
+            // boundary so state trace/status always precede its call-start trace.
             combined.throwIfAborted();
-            ({ playerId, result } = await callPlayer(input, combined));
-        }
-        if (result.status !== 'ok') {
-            throw new Error(`player "${playerId}" returned status "${result.status}"${result.error ? `: ${result.error}` : ''}`);
-        }
-        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, finalText);
-            return parseAdjudication(await callJudge(prompt, combined, 'player-output-adjudication', input.stateId), input, finalText);
+            try {
+                await flush(settlementAborts);
+            }
+            catch (error) {
+                latchControlPlaneError(error, combined);
+                throw error;
+            }
+            combined.throwIfAborted();
+            let { roleId, playerId, result } = await callPlayer(input, combined);
+            if (result.status === 'ok' && isEmptyFinalText(result.finalText)) {
+                // DR-028: an `ok` result whose finalText is missing, empty, or
+                // whitespace-only earns exactly one corrective re-ask — the same
+                // composed call repeated, traced by runPlayerCall as its own
+                // player-call pair, with the resume selection re-read from the
+                // token map the first result left (PBRT-38). An abort that lands
+                // between the two calls ends the turn without the re-ask (aborts
+                // are never retried), and a rejecting finish emission rejects
+                // `callPlayer` itself, so it never reaches this branch (PBRT-47).
+                combined.throwIfAborted();
+                ({ roleId, playerId, result } = await callPlayer(input, combined));
+            }
+            if (result.status !== 'ok') {
+                throw new Error(`${roleLabel(roleId)}${playerId === undefined ? '' : ` (${playerId})`} returned status "${result.status}"${result.error ? `: ${result.error}` : ''}`);
+            }
+            const finalText = result.finalText ?? '';
+            if (isEmptyFinalText(finalText)) {
+                throw new Error(`${roleLabel(roleId)}${playerId === undefined ? '' : ` (${playerId})`} returned status "ok" with no finalText`);
+            }
+            combined.throwIfAborted();
+            try {
+                const prompt = buildAdjudicatorPrompt(input, finalText);
+                return parseAdjudication(await callJudge(prompt, combined, 'player-output-adjudication', input.stateId), input, finalText);
+            }
+            catch (error) {
+                latchControlPlaneError(error, combined);
+                throw error;
+            }
         }
-        catch (error) {
-            latchControlPlaneError(error, combined);
-            throw error;
+        finally {
+            actorSettlementAborts.push(settlementAborts);
         }
     });
     nestedBridge = createNestedPlaybookBridge({
         nextCallId: () => `playbook-${++playbookCallSequence}`,
         getBoundarySignal: () => currentSignal,
         callPlaybook: (request, signal) => trackBoundaryCall(Promise.resolve(requirePorts().callPlaybook(request, signal))),
-        emitStarted: async (event) => {
+        emitStarted: async (event, aborts) => {
             playbookCallTurnIds.set(event.callId, currentTurnId);
             await emitTrace('playbook.call.started', {
                 stateId: event.stateId,
@@ -981,9 +1086,9 @@ export const createPlaybookRuntime = (options) => {
             }, {
                 ...(currentTurnId === undefined ? {} : { turnId: currentTurnId }),
                 callId: event.callId,
-            });
+            }, aborts);
         },
-        emitFinished: async (event) => {
+        emitFinished: async (event, aborts) => {
             const turnId = playbookCallTurnIds.get(event.callId);
             try {
                 await emitTrace('playbook.call.finished', {
@@ -994,29 +1099,48 @@ export const createPlaybookRuntime = (options) => {
                 }, {
                     ...(turnId === undefined ? {} : { turnId }),
                     callId: event.callId,
-                });
+                }, aborts);
             }
             finally {
                 playbookCallTurnIds.delete(event.callId);
             }
         },
         drain: flush,
-        bindResumeSignal: (signal) => {
+        bindResumeSignal: (signal, aborts) => {
             currentSignal = signal;
+            currentAborts = aborts ?? abortReasonClassifier(signal);
         },
-        onControlPlaneError: (error) => {
-            const signal = currentSignal;
-            if (!signal || !isAbortFailure(error, signal)) {
+        bindActorSettlement: (aborts) => {
+            actorSettlementAborts.push(aborts);
+        },
+        onControlPlaneError: (error, aborts) => {
+            if (!aborts?.isAbortReason(error) &&
+                !currentAborts?.isAbortReason(error)) {
                 controlPlaneError ??= error;
             }
         },
-        onBackgroundError: (error) => {
-            collectFailure(emissionFailures, error);
+        onBackgroundError: (error, aborts) => {
+            if (!aborts?.isAbortReason(error)) {
+                collectFailure(emissionFailures, error);
+            }
         },
     });
     const providedMachine = decideMachine.provide({
         actors: { player, playbook: nestedBridge.actorLogic },
     });
+    const consumeActorSettlementAborts = (forSnapshot = false) => {
+        const aborts = actorSettlementAborts.shift() ?? actorSettlementErrorAborts;
+        actorSettlementErrorAborts = undefined;
+        if (forSnapshot && aborts !== undefined) {
+            actorSettlementErrorAborts = aborts;
+            queueMicrotask(() => {
+                if (actorSettlementErrorAborts === aborts) {
+                    actorSettlementErrorAborts = undefined;
+                }
+            });
+        }
+        return aborts;
+    };
     const inspect = (event) => {
         if (event.type !== '@xstate.snapshot')
             return;
@@ -1024,6 +1148,7 @@ export const createPlaybookRuntime = (options) => {
             return;
         if (suppressInspectionEmissions)
             return;
+        const settlementAborts = consumeActorSettlementAborts(true);
         try {
             const snapshot = event.snapshot;
             const state = normalizePlaybookSnapshot(snapshot);
@@ -1034,7 +1159,7 @@ export const createPlaybookRuntime = (options) => {
             void enqueueTracedEmission('fsm.transition', fsmPayload, { turnId: currentTurnId }, (emissionPorts) => emissionPorts.emitTelemetry({
                 topic: TELEMETRY_TOPIC,
                 payload: describedFsmPayload,
-            })).catch(() => undefined);
+            }), settlementAborts).catch(() => undefined);
             const priorIds = new Set(previousState?.activeStateIds ?? []);
             previousState = state;
             const pendingQuestions = pendingQuestionsFromContext(context);
@@ -1047,7 +1172,7 @@ export const createPlaybookRuntime = (options) => {
                     ...(data !== undefined ? { data } : {}),
                 };
                 assertJsonSafe(tracePayload);
-                void enqueueTracedEmission('status.emitted', tracePayload, { turnId: currentTurnId }, (emissionPorts) => emissionPorts.emitStatus(message, data)).catch(() => undefined);
+                void enqueueTracedEmission('status.emitted', tracePayload, { turnId: currentTurnId }, (emissionPorts) => emissionPorts.emitStatus(message, data), settlementAborts).catch(() => undefined);
             };
             for (const activeStateId of state.activeStateIds) {
                 if (priorIds.has(activeStateId) ||
@@ -1057,8 +1182,8 @@ export const createPlaybookRuntime = (options) => {
                 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);
+                        scheduleStatus(`${pending.asker.roleId} asks: ${pending.question}`, activeStateId);
+                        scheduleStatus(`◆ awaiting Boss reply · ${pending.resumeStateId} · ${pending.asker.roleId} · ${pending.sourceItem}`, activeStateId);
                     }
                     continue;
                 }
@@ -1068,14 +1193,14 @@ export const createPlaybookRuntime = (options) => {
                 const description = STATE_DESCRIPTIONS[activeStateId];
                 if (description === undefined)
                     continue;
-                const playerState = PLAYER_STATES.find((candidate) => candidate.stateId === activeStateId);
-                scheduleStatus(playerState === undefined
+                const roleState = ROLE_STATES.find((candidate) => candidate.stateId === activeStateId);
+                scheduleStatus(roleState === undefined
                     ? '◆ workflow failed; awaiting Boss recovery.'
-                    : `⤷ ${playerState.player}: ${description}`, activeStateId, lastError === undefined ? undefined : { lastError });
+                    : `⤷ ${roleLabel(roleState.role)}: ${description}`, activeStateId, lastError === undefined ? undefined : { lastError });
             }
         }
         catch (error) {
-            latchInspectionError(error);
+            latchInspectionError(error, settlementAborts);
         }
     };
     const createRuntimeActor = (machineSnapshot) => {
@@ -1091,6 +1216,15 @@ export const createPlaybookRuntime = (options) => {
                 }),
             inspect,
         });
+        // A synchronous FSM action throw errors the actor without any pending
+        // boundary await to observe it; unobserved, XState would surface it via
+        // reportUnhandledError as an uncaughtException. Observe it here: latch
+        // it as a control error while a turn signal is active (unless it is
+        // the abort reason itself), otherwise collect it with the emission
+        // failures (slc/link.md §Abort).
+        actor.subscribe({
+            error: (error) => latchInspectionError(error, consumeActorSettlementAborts()),
+        });
     };
     // PBRT-6: the single seam that stops this runtime's actor. Stopping a
     // still-running actor fires one more `@xstate.snapshot` for the *unchanged*
@@ -1126,7 +1260,7 @@ export const createPlaybookRuntime = (options) => {
         const state = normalizePlaybookSnapshot(snapshot, {
             pendingCall: nestedBridge.getPendingCall(),
         });
-        const pendingQuestions = pendingQuestionsFromContext(context);
+        const pendingQuestions = pendingQuestionsForState(state, context);
         if (pendingQuestions.length === 0 &&
             (snapshot.status === 'done' ||
                 state.activeStateIds.includes('ready') ||
@@ -1150,33 +1284,53 @@ export const createPlaybookRuntime = (options) => {
         const pendingCall = nestedBridge.getPendingCall();
         const state = normalizePlaybookSnapshot(snapshot, { pendingCall });
         const context = snapshot.context;
-        if (signal?.aborted) {
-            return {
-                outcome: 'aborted',
-                state,
-                ...(signal.reason === undefined
-                    ? {}
-                    : {
-                        error: normalizeErrorFull(signal.reason) ?? {
-                            name: 'AbortError',
-                            message: String(signal.reason),
-                        },
-                    }),
-            };
-        }
+        const abortedResult = (abortSignal) => ({
+            outcome: 'aborted',
+            state,
+            ...(abortSignal.reason === undefined
+                ? {}
+                : {
+                    error: normalizeErrorFull(abortSignal.reason) ?? {
+                        name: 'AbortError',
+                        message: String(abortSignal.reason),
+                    },
+                }),
+        });
+        if (snapshot.status === 'error') {
+            // An errored actor outranks a coincident abort unless the actor's
+            // error is the abort reason itself (slc/link.md §Abort).
+            const actorError = snapshot.error;
+            if (actorError !== undefined &&
+                signal !== undefined &&
+                isAbortFailure(actorError, signal)) {
+                return abortedResult(signal);
+            }
+            throw (actorError ?? new Error('decide runtime actor entered error status'));
+        }
+        // Terminal completion outranks a coincident abort (DR-036 §3): reporting
+        // 'aborted' over a completed machine would hide a terminal state that the
+        // next turn silently restarts, duplicating the workflow's side effects.
         if (snapshot.status === 'done') {
             const output = snapshot.output;
             if (output !== undefined)
                 assertJsonSafe(output, 'terminal output');
+            const stateDescription = state.activeStateIds.includes('done')
+                ? STATE_DESCRIPTIONS.done
+                : state.activeStateIds.includes('reportedReviewFailure')
+                    ? STATE_DESCRIPTIONS.reportedReviewFailure
+                    : undefined;
+            if (stateDescription === undefined) {
+                throw new Error('decide runtime: completed actor has no authored final-state description');
+            }
             return {
                 outcome: 'terminal',
                 state,
+                stateDescription,
                 ...(output === undefined ? {} : { output }),
             };
         }
-        if (snapshot.status === 'error') {
-            throw (snapshot.error ??
-                new Error('decide runtime actor entered error status'));
+        if (signal?.aborted) {
+            return abortedResult(signal);
         }
         if (state.activeStateIds.includes('failed')) {
             const error = normalizeErrorFull(context.lastError);
@@ -1239,14 +1393,17 @@ export const createPlaybookRuntime = (options) => {
                 // The session-start error remains authoritative.
             }
         }
-        playerResumeTokens.clear();
-        inFlightPlayerIds.clear();
+        privateResumeTokens.clear();
+        inFlightPlayerKeys.clear();
         activeBoundaryCalls.clear();
         activeEmissionCalls.clear();
         emissionQueue.clear();
         judgeQueue.clear();
         actor = undefined;
         currentSignal = undefined;
+        currentAborts = undefined;
+        actorSettlementAborts.length = 0;
+        actorSettlementErrorAborts = undefined;
         currentTurnId = undefined;
         ports = undefined;
         sessionIdentity = undefined;
@@ -1270,7 +1427,7 @@ export const createPlaybookRuntime = (options) => {
                 disposalPromise !== undefined) {
                 throw new Error('decide runtime: init(session) may only be called once');
             }
-            const identity = snapshotPlaybookSession(session);
+            const identity = bindSession(session);
             let finishInitialization;
             const initialization = new Promise((resolve) => {
                 finishInitialization = resolve;
@@ -1348,10 +1505,10 @@ export const createPlaybookRuntime = (options) => {
             const machine = detachPersistedMachineSnapshot(actor.getPersistedSnapshot());
             const context = actor.getSnapshot().context;
             return {
-                schemaVersion: 2,
+                schemaVersion: 3,
                 playbookId: sessionIdentity.playbookId,
                 machine,
-                playerResumeTokens: snapshotPlayerResumeTokens(),
+                roleResumeTokens: snapshotRoleResumeTokens(),
                 sequences: {
                     trace: traceSequence,
                     turn: turnSequence,
@@ -1360,9 +1517,9 @@ export const createPlaybookRuntime = (options) => {
                     playbookCall: playbookCallSequence,
                 },
                 state,
-                pendingBossQuestions: pendingQuestionsFromContext(context).map((pending) => ({
+                pendingBossQuestions: pendingQuestionsForState(state, context).map((pending) => ({
                     questionId: pending.questionId,
-                    player: pending.player,
+                    asker: pending.asker,
                     question: pending.question,
                     sourceItem: pending.sourceItem,
                 })),
@@ -1381,11 +1538,9 @@ export const createPlaybookRuntime = (options) => {
                 disposalPromise !== undefined) {
                 throw new Error('decide runtime: restore(session, snapshot) may only be called once');
             }
-            const identity = snapshotPlaybookSession(session);
+            const identity = bindSession(session);
             const boundSnapshot = assertPlaybookRuntimeSnapshot(snapshot, identity.playbookId, { allowSuspendedCall: true });
-            const suspendedCall = boundSnapshot.schemaVersion === 2
-                ? boundSnapshot.suspendedCall
-                : undefined;
+            const suspendedCall = boundSnapshot.suspendedCall;
             let finishInitialization;
             const initialization = new Promise((resolve) => {
                 finishInitialization = resolve;
@@ -1394,7 +1549,7 @@ export const createPlaybookRuntime = (options) => {
             lifecycleStarted = true;
             ports = identity.ports;
             sessionIdentity = identity;
-            let priorExternalPlayerTokens;
+            let priorExternalRoleTokens;
             try {
                 traceSequence = boundSnapshot.sequences.trace;
                 turnSequence = boundSnapshot.sequences.turn;
@@ -1402,9 +1557,9 @@ export const createPlaybookRuntime = (options) => {
                 playerCallSequence = boundSnapshot.sequences.playerCall;
                 playbookCallSequence = boundSnapshot.sequences.playbookCall;
                 if (identity.playerSessions) {
-                    priorExternalPlayerTokens = snapshotPlayerResumeTokens();
+                    priorExternalRoleTokens = snapshotRoleResumeTokens();
                 }
-                restorePlayerResumeTokens(boundSnapshot.playerResumeTokens);
+                restoreRoleResumeTokens(boundSnapshot.roleResumeTokens);
                 nestedBridge.prepareRestore(suspendedCall);
                 if (suspendedCall !== undefined) {
                     playbookCallTurnIds.set(suspendedCall.callId, suspendedCall.turnId);
@@ -1430,9 +1585,9 @@ export const createPlaybookRuntime = (options) => {
             }
             catch (error) {
                 let failure = error;
-                if (priorExternalPlayerTokens !== undefined) {
+                if (priorExternalRoleTokens !== undefined) {
                     try {
-                        identity.playerSessions.restore(priorExternalPlayerTokens);
+                        identity.playerSessions.restore(priorExternalRoleTokens);
                     }
                     catch (rollbackError) {
                         failure = new AggregateError([error, rollbackError], 'DECIDE restore and player continuation rollback failed');
@@ -1461,12 +1616,17 @@ export const createPlaybookRuntime = (options) => {
             const turnId = ++turnSequence;
             currentTurnId = turnId;
             currentSignal = turn.signal;
+            currentAborts = abortReasonClassifier(turn.signal);
             controlPlaneError = undefined;
             let result = resultForSnapshot(turn.signal);
             let settlement = result;
             const failures = [];
             try {
                 await emitTrace('boss.input.received', { text: turn.text }, { turnId });
+                // A boundary entered aborted records the attempted input, then refuses
+                // delivery before deterministic mapping or the classifier can perform
+                // any host-visible work (DR-036 §5).
+                turn.signal.throwIfAborted();
                 if (turn.text.trim().length === 0) {
                     const state = currentState();
                     result = { outcome: 'no-action', state };
@@ -1502,16 +1662,19 @@ export const createPlaybookRuntime = (options) => {
             }
             catch (error) {
                 const primaryError = controlPlaneError;
+                // Only a rejection that is the exact abort reason settles as the
+                // cancellation; a distinct failure observed while the signal is
+                // aborted remains a control error (slc/link.md §Abort).
                 if (primaryError !== undefined) {
                     collectFailure(failures, primaryError);
                 }
-                else if (!turn.signal.aborted) {
+                else if (!isAbortFailure(error, turn.signal)) {
                     collectFailure(failures, error);
                 }
                 const state = currentState();
                 const effectiveError = primaryError ?? error;
                 result =
-                    turn.signal.aborted && primaryError === undefined
+                    isAbortFailure(error, turn.signal) && primaryError === undefined
                         ? resultForSnapshot(turn.signal)
                         : {
                             outcome: 'failed',
@@ -1532,12 +1695,14 @@ export const createPlaybookRuntime = (options) => {
             catch (error) {
                 const primaryError = controlPlaneError;
                 const effectiveError = primaryError ?? error;
-                collectFailure(failures, effectiveError);
+                // A drain rejection that is the exact abort reason evidences the
+                // cancellation, not a control-plane failure (slc/link.md §Abort).
+                const drainAborted = isAbortFailure(effectiveError, turn.signal);
+                if (!drainAborted)
+                    collectFailure(failures, effectiveError);
                 const state = currentState();
                 result = {
-                    outcome: turn.signal.aborted && primaryError === undefined
-                        ? 'aborted'
-                        : 'failed',
+                    outcome: drainAborted ? 'aborted' : 'failed',
                     state,
                     error: normalizeErrorFull(effectiveError) ?? {
                         name: 'Error',
@@ -1546,21 +1711,31 @@ export const createPlaybookRuntime = (options) => {
                 };
                 settlement = { ...result, ...stateIdentity(state) };
             }
-            currentSignal = undefined;
             try {
                 await emitTrace('boss.input.settled', settlement, { turnId });
             }
             catch (error) {
-                collectFailure(failures, error);
+                // A settlement-trace rejection that is the exact abort reason also
+                // evidences the cancellation (slc/link.md §Abort).
+                if (!isAbortFailure(error, turn.signal)) {
+                    collectFailure(failures, error);
+                }
             }
             try {
                 await flush();
             }
             catch (error) {
-                collectFailure(failures, error);
+                // A late flush rejection that is the exact abort reason likewise
+                // evidences the cancellation; the settled result already labels
+                // the turn aborted then (slc/link.md §Abort).
+                if (!isAbortFailure(error, turn.signal)) {
+                    collectFailure(failures, error);
+                }
             }
             finally {
                 const primaryError = controlPlaneError;
+                currentSignal = undefined;
+                currentAborts = undefined;
                 currentTurnId = undefined;
                 controlPlaneError = undefined;
                 if (primaryError !== undefined)
@@ -1586,6 +1761,7 @@ export const createPlaybookRuntime = (options) => {
             }
             currentTurnId = playbookCallTurnIds.get(callId);
             currentSignal = signal;
+            currentAborts = abortReasonClassifier(signal);
             controlPlaneError = undefined;
             let runResult;
             let operationError;
@@ -1615,14 +1791,50 @@ export const createPlaybookRuntime = (options) => {
             catch (error) {
                 drainError = error;
             }
-            const failure = controlPlaneError ?? drainError ?? operationError;
+            const aborts = currentAborts ?? abortReasonClassifier(signal);
+            // The control latch has already classified its failure as distinct
+            // under the operation that owned it. Only still-unclassified drain and
+            // operation candidates may be cancellation evidence for this resume.
+            const controlFailure = controlPlaneError;
+            const drainAbort = controlFailure === undefined &&
+                drainError !== undefined &&
+                aborts.isAbortReason(drainError);
+            const operationAbort = controlFailure === undefined &&
+                operationError !== undefined &&
+                aborts.isAbortReason(operationError);
+            const abortEvidence = (drainAbort ? drainError : undefined) ??
+                (operationAbort ? operationError : undefined);
+            const failure = controlFailure ??
+                (drainAbort ? undefined : drainError) ??
+                (operationAbort ? undefined : operationError);
             currentSignal = undefined;
+            currentAborts = undefined;
             currentTurnId = undefined;
             controlPlaneError = undefined;
             if (failure !== undefined)
                 throw failure;
+            if (abortEvidence !== undefined &&
+                runResult?.outcome !== 'terminal' &&
+                runResult?.outcome !== 'suspended') {
+                const state = currentState();
+                runResult = {
+                    outcome: 'aborted',
+                    state,
+                    error: normalizeErrorFull(abortEvidence) ?? {
+                        name: 'AbortError',
+                        message: String(abortEvidence),
+                    },
+                };
+            }
             if (runResult === undefined) {
-                throw new Error('decide runtime: playbook resume produced no result');
+                if (signal.aborted) {
+                    // Every candidate was the abort's own evidence: settle on the
+                    // machine's state under the aborted boundary signal (DR-036 §4).
+                    runResult = resultForSnapshot(signal);
+                }
+                else {
+                    throw new Error('decide runtime: playbook resume produced no result');
+                }
             }
             return runResult;
         },
@@ -1671,15 +1883,18 @@ export const createPlaybookRuntime = (options) => {
                     collectFailure(failures, error);
                 }
                 finally {
-                    playerResumeTokens.clear();
+                    privateResumeTokens.clear();
                     playbookCallTurnIds.clear();
-                    inFlightPlayerIds.clear();
+                    inFlightPlayerKeys.clear();
                     activeBoundaryCalls.clear();
                     activeEmissionCalls.clear();
                     emissionQueue.clear();
                     judgeQueue.clear();
                     actor = undefined;
                     currentSignal = undefined;
+                    currentAborts = undefined;
+                    actorSettlementAborts.length = 0;
+                    actorSettlementErrorAborts = undefined;
                     currentTurnId = undefined;
                     ports = undefined;
                     sessionIdentity = undefined;
@@ -1695,11 +1910,15 @@ export const createPlaybookRuntime = (options) => {
             })();
             return disposalPromise;
         },
+        // @internal — test-only parity with the shared factory's bridge escape
+        // hatch. This is hidden by the PlaybookRuntime return type.
+        _getNestedBridge() {
+            return nestedBridge;
+        },
     };
 };
 export const _internal = {
     composePlayerPrompt,
-    resolvePlayerId,
     requiredFieldsFor,
     extractJson,
     buildClassifierPrompt,
@@ -1708,12 +1927,12 @@ export const _internal = {
     parseAdjudication,
     combineSignals,
     pendingQuestionsFromContext,
+    pendingQuestionsForState,
     normalizeErrorCompact,
     normalizeErrorFull,
-    DEFAULT_PLAYER_BINDING,
     STATE_DESCRIPTIONS,
-    PLAYER_STATES,
-    PLAYER_STATE_IDS,
+    ROLE_STATES,
+    ROLE_STATE_IDS,
     VERBATIM_PAYLOAD_FIELDS,
     BOSS_INTERRUPT_TARGETS,
     CONTINUATION_PREAMBLE,