@sublang/playbook 7.0.0 → 9.0.0

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

@@ -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
@@ -98,89 +98,88 @@ export type {
   PlaybookTraceType,
 };
 
-type PlayerName = 'Coder' | 'Reviewer';
+type RoleId = 'coder' | 'reviewer';
 
-export interface PlaybookRuntimeOptions extends DecideInput {
-  playerBinding?: Partial<Record<PlayerName, string>>;
-}
-
-const DEFAULT_PLAYER_BINDING: Readonly<Record<PlayerName, string>> = {
-  Coder: 'coder',
-  Reviewer: 'reviewer',
-};
+export type PlaybookRuntimeOptions = DecideInput;
 
 function snapshotDecideRuntimeOptions(value: unknown): PlaybookRuntimeOptions {
   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<PlayerName>(['Coder', 'Reviewer']);
-    for (const [player, playerId] of Object.entries(playerBinding)) {
-      if (!playerNames.has(player as PlayerName)) {
-        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({});
+}
+
+interface AuthoredStateConfig {
+  readonly meta?: {
+    readonly playbook?: {
+      readonly stateId?: unknown;
+      readonly description?: unknown;
+    };
+  };
+  readonly states?: Readonly<Record<string, AuthoredStateConfig>>;
+}
+
+function authoredStateDescriptions(
+  states: Readonly<Record<string, AuthoredStateConfig>> | undefined,
+): Readonly<Record<string, string>> {
+  const descriptions: Record<string, string> = {};
+  const visit = (
+    children: Readonly<Record<string, AuthoredStateConfig>> | undefined,
+  ): void => {
+    for (const state of Object.values(children ?? {})) {
+      const stateId = state.meta?.playbook?.stateId;
+      const description = state.meta?.playbook?.description;
+      if (
+        typeof stateId === 'string' &&
+        typeof description === 'string' &&
+        description.trim().length > 0
+      ) {
+        const existing = descriptions[stateId];
+        if (existing !== undefined && existing !== description) {
+          throw new Error(
+            `DECIDE state ${stateId} declares conflicting descriptions`,
+          );
+        }
+        descriptions[stateId] = description;
       }
+      visit(state.states);
     }
-  }
-  return captured as unknown as PlaybookRuntimeOptions;
+  };
+  visit(states);
+  return Object.freeze(descriptions);
 }
 
-const STATE_DESCRIPTIONS: Readonly<Record<string, string>> = {
-  ready: 'Waiting for a topic to decide.',
-  askCoderProposal: 'Coder independently proposes a spec design.',
-  askReviewerProposal: 'Reviewer independently proposes a spec design.',
-  waitCoderProposalReply: 'Coder waits for Boss to answer a question.',
-  waitReviewerProposalReply: 'Reviewer waits for Boss to answer a question.',
-  commitCoderProposal: 'Coder writes and commits Coder’s independent proposal.',
-  awaitBossReply: 'Waiting for Boss to answer Coder’s question.',
-  reviewCommit: 'REVIEW examines the committed proposal.',
-  failed: 'DECIDE failed and is waiting for a new topic.',
-  reportedReviewFailure:
-    'DECIDE reports REVIEW’s failure and its last commit.',
-  done: 'DECIDE completed with an approved commit.',
-};
+const STATE_DESCRIPTIONS = authoredStateDescriptions(
+  decideMachine.config.states as
+    | Readonly<Record<string, AuthoredStateConfig>>
+    | undefined,
+);
 
-const PLAYER_STATES = [
-  { stateId: 'askCoderProposal', player: 'Coder', sourceItem: 'DECIDE-1' },
+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' },
 ] as const;
 
-const PLAYER_STATE_IDS: ReadonlySet<string> = new Set(
-  PLAYER_STATES.map((state) => state.stateId),
+const ROLE_STATE_IDS: ReadonlySet<string> = new Set(
+  ROLE_STATES.map((state) => state.stateId),
 );
 
+const ROLE_IDS = ['coder', 'reviewer'] as const;
+const ROLE_ID_SET: ReadonlySet<string> = new Set(ROLE_IDS);
+
+const roleLabel = (roleId: RoleId): string =>
+  roleId === 'coder' ? 'Coder' : 'Reviewer';
+
 const BOSS_INTERRUPT_TARGETS = ['independentProposals'] as const;
 
 const BOSS_INTERRUPT_TARGET_IDS: ReadonlySet<string> = new Set(
@@ -194,10 +193,7 @@ 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: ReadonlyArray<readonly [string, keyof PlayerInput]> =
-  [
-    ['<caller-topic>', 'callerTopic'],
-    ['<coder-llm>', 'coderLlm'],
-  ];
+  [['<caller-topic>', 'callerTopic']];
 
 const VERBATIM_PAYLOAD_FIELDS: ReadonlySet<string> = new Set([
   'coderProposal',
@@ -205,7 +201,12 @@ const VERBATIM_PAYLOAD_FIELDS: ReadonlySet<string> = new Set([
   'coderOutput',
 ]);
 
-function composePlayerPrompt(input: PlayerInput): string {
+type PromptIdentity = (roleId: RoleId) => string;
+
+function composePlayerPrompt(
+  input: PlayerInput,
+  promptIdentity: PromptIdentity,
+): string {
   const blocks: string[] = [];
 
   if (input.pendingBossQuestion && input.bossReply !== undefined) {
@@ -227,6 +228,9 @@ function composePlayerPrompt(input: PlayerInput): string {
     const value = input[field];
     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: number, source: string) => {
@@ -243,22 +247,6 @@ function composePlayerPrompt(input: PlayerInput): string {
   return blocks.join('\n\n');
 }
 
-function resolvePlayerId(
-  input: PlayerInput,
-  binding: Record<PlayerName, string>,
-): string {
-  switch (input.player) {
-    case 'Coder':
-      return binding.Coder;
-    case 'Reviewer':
-      return binding.Reviewer;
-    default: {
-      const exhaustive: never = 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: string): string[] {
@@ -413,7 +401,7 @@ function buildClassifierPrompt(
     lines.push('Pending Boss questions:');
     for (const pending of ctx.pendingQuestions) {
       lines.push(
-        `- ${pending.questionId} (${pending.player}): ${pending.question}`,
+        `- ${pending.questionId} (${pending.asker.roleId}): ${pending.question}`,
       );
     }
     lines.push(
@@ -513,7 +501,7 @@ function buildAdjudicatorPrompt(
       '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}.`,
+    `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('');
@@ -627,6 +615,27 @@ function isAbortFailure(error: unknown, signal: AbortSignal): boolean {
   return signal.aborted && Object.is(error, signal.reason);
 }
 
+interface AbortReasonClassifier {
+  isAbortReason(error: unknown): boolean;
+}
+
+function abortReasonClassifier(
+  ...sources: readonly (AbortSignal | AbortReasonClassifier | undefined)[]
+): AbortReasonClassifier {
+  const captured = sources.filter(
+    (source): source is AbortSignal | AbortReasonClassifier =>
+      source !== undefined,
+  );
+  return Object.freeze({
+    isAbortReason: (error: unknown): boolean =>
+      captured.some((source) =>
+        source instanceof AbortSignal
+          ? isAbortFailure(error, source)
+          : source.isAbortReason(error),
+      ),
+  });
+}
+
 function pendingQuestionsFromContext(
   context: Record<string, unknown>,
 ): PendingBossQuestion[] {
@@ -649,7 +658,9 @@ function pendingQuestionsFromContext(
       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 as unknown as PendingBossQuestion);
@@ -671,11 +682,38 @@ const WAIT_STATE_IDS: ReadonlySet<string> = new Set([
 ]);
 
 const STATUS_STATE_IDS: ReadonlySet<string> = 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: Readonly<Record<string, string>> = {
+  ...Object.fromEntries(
+    Object.entries(WAIT_STATE_RESUME_IDS).map(([waitStateId, resumeStateId]) => [
+      resumeStateId,
+      waitStateId,
+    ]),
+  ),
+  commitCoderProposal: 'awaitBossReply',
+};
+
+function pendingQuestionsForState(
+  state: PlaybookState,
+  context: Record<string, unknown>,
+): PendingBossQuestion[] {
+  return pendingQuestionsFromContext(context).filter((pending) =>
+    state.activeStateIds.includes(
+      RESUME_WAIT_STATE_IDS[pending.resumeStateId] ?? '',
+    ),
+  );
+}
+
 function questionForWaitState(
   stateId: string,
   pendingQuestions: readonly PendingBossQuestion[],
@@ -729,7 +767,7 @@ function telemetryPayload(
   event: unknown,
   context: Record<string, unknown>,
 ): JsonValue {
-  const pendingBossQuestions = pendingQuestionsFromContext(context);
+  const pendingBossQuestions = pendingQuestionsForState(state, context);
   const prior = previousState ?? state;
   const payload = {
     from: prior.value,
@@ -749,14 +787,7 @@ function telemetryPayload(
 export const createPlaybookRuntime: PlaybookRuntimeFactory<
   PlaybookRuntimeOptions
 > = (options) => {
-  const boundOptions = snapshotDecideRuntimeOptions(options);
-  const binding: Record<PlayerName, string> = {
-    ...DEFAULT_PLAYER_BINDING,
-    ...(boundOptions.playerBinding ?? {}),
-  };
-  const fsmInput: DecideInput = {
-    coderLlm: boundOptions.coderLlm,
-  };
+  const fsmInput = snapshotDecideRuntimeOptions(options);
 
   type SessionIdentity = Readonly<PlaybookSession>;
 
@@ -764,6 +795,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   let sessionIdentity: SessionIdentity | undefined;
   let actor: ReturnType<typeof createActor> | undefined;
   let currentSignal: AbortSignal | undefined;
+  let currentAborts: AbortReasonClassifier | undefined;
+  const actorSettlementAborts: AbortReasonClassifier[] = [];
+  let actorSettlementErrorAborts: AbortReasonClassifier | undefined;
   let currentTurnId: number | undefined;
   let previousState: PlaybookState | undefined;
   let suppressInspectionEmissions = false;
@@ -779,9 +813,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   let disposalPromise: Promise<void> | undefined;
   let controlPlaneError: unknown;
   let nestedBridge: NestedPlaybookBridge<PlaybookInput>;
-  const playerResumeTokens = new Map<string, string>();
+  const privateResumeTokens = new Map<string, string>();
   const playbookCallTurnIds = new Map<string, number | undefined>();
-  const inFlightPlayerIds = new Set<string>();
+  const inFlightPlayerKeys = new Set<string>();
   const activeBoundaryCalls = new Set<Promise<unknown>>();
   const activeEmissionCalls = new Set<Promise<void>>();
   const emissionQueue = new PQueue({ concurrency: 1 });
@@ -802,26 +836,35 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   ): void => {
     if (!isAbortFailure(error, signal)) controlPlaneError ??= error;
   };
-  const latchInspectionError = (error: unknown): void => {
-    if (currentSignal !== undefined) {
-      latchControlPlaneError(error, currentSignal);
-    } else {
-      collectFailure(emissionFailures, error);
-    }
+  const latchInspectionError = (
+    error: unknown,
+    aborts: AbortReasonClassifier | undefined = currentAborts,
+  ): void => {
+    if (aborts?.isAbortReason(error)) return;
+    if (currentSignal !== undefined) controlPlaneError ??= error;
+    else collectFailure(emissionFailures, error);
   };
-  const enqueue = (fn: () => Promise<void>): Promise<void> => {
+  const enqueue = (
+    fn: () => Promise<void>,
+    aborts: AbortReasonClassifier | undefined = currentAborts,
+  ): Promise<void> => {
+    const enqueueAborts = aborts;
     const queued = emissionQueue.add(fn);
     activeEmissionCalls.add(queued);
     void queued.then(
       () => activeEmissionCalls.delete(queued),
       (error: unknown) => {
         activeEmissionCalls.delete(queued);
-        collectFailure(emissionFailures, error);
+        if (!enqueueAborts?.isAbortReason(error)) {
+          collectFailure(emissionFailures, error);
+        }
       },
     );
     return queued;
   };
-  const flush = async (): Promise<void> => {
+  const flush = async (
+    _aborts: AbortReasonClassifier | undefined = currentAborts,
+  ): Promise<void> => {
     while (true) {
       const active = [...activeEmissionCalls];
       if (active.length > 0) await Promise.allSettled(active);
@@ -837,8 +880,15 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     if (emissionFailures.length === 0) return;
     const failures = emissionFailures;
     emissionFailures = [];
-    if (failures.length === 1) throw failures[0];
-    throw new AggregateError(failures, 'decide runtime emissions failed');
+    const failure =
+      failures.length === 1
+        ? failures[0]
+        : new AggregateError(failures, 'decide runtime emissions failed');
+    // Enqueue ownership already classified every stored failure as distinct.
+    // Preserve that classification if an unrelated public boundary drains
+    // it with a signal whose reason happens to be the same object.
+    if (currentSignal !== undefined) controlPlaneError ??= failure;
+    throw failure;
   };
   const drainBoundaryCallsAndEmissions = async (): Promise<void> => {
     while (true) {
@@ -869,73 +919,176 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     }
     return sessionIdentity;
   };
-  const selectPlayerResume = (playerId: string): string | false => {
+
+  const bindSession = (nextSession: PlaybookSession): SessionIdentity => {
+    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: RoleId): string | undefined =>
+    requireSessionIdentity().roleBindings?.[roleId]?.playerId;
+
+  const promptIdentity = (roleId: RoleId): string =>
+    requireSessionIdentity().roleBindings?.[roleId]?.promptIdentity ?? roleId;
+
+  const composeInvocationPrompt = (input: PlayerInput): string => {
+    let active = true;
+    const lookup: PromptIdentity = (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: RoleId,
+    playerId: string | undefined,
+  ): string => playerId ?? roleId;
+
+  const tokensByContinuationKey = (
+    tokens: Readonly<Record<string, string>>,
+  ): Map<string, string> => {
+    const byKey = new Map<string, string>();
+    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 as 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<string, RoleId[]>();
+    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: RoleId,
+    playerId: string | undefined,
+  ): string | false => {
     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}`,
+        `player session store returned an invalid resume token for role ${roleId}`,
       );
     }
     return selected;
   };
   const updatePlayerResume = (
-    playerId: string,
-    resumeToken: string | undefined,
+    roleId: RoleId,
+    playerId: string | undefined,
+    result: PlayerResult,
   ): void => {
+    if (result.resumeToken === undefined && result.status !== 'ok') return;
     const session = requireSessionIdentity();
     if (session.playerSessions) {
-      session.playerSessions.update(playerId, resumeToken);
-    } else if (resumeToken !== undefined && resumeToken.trim().length > 0) {
-      playerResumeTokens.set(playerId, resumeToken);
+      session.playerSessions.update(roleId, result.resumeToken);
+    } else if (result.resumeToken !== undefined) {
+      privateResumeTokens.set(
+        continuationKey(roleId, playerId),
+        result.resumeToken,
+      );
     } else {
-      playerResumeTokens.delete(playerId);
+      privateResumeTokens.delete(continuationKey(roleId, playerId));
     }
   };
-  const snapshotPlayerResumeTokens = (): Record<string, string> => {
+  const snapshotRoleResumeTokens = (): Record<string, string> => {
     const session = requireSessionIdentity();
     const captured = snapshotJsonValue(
       session.playerSessions
         ? session.playerSessions.snapshot()
-        : Object.fromEntries(playerResumeTokens),
+        : 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: Record<string, string> = {};
-    for (const [playerId, token] of Object.entries(captured)) {
-      if (playerId.trim().length === 0) {
+    for (const [roleId, token] of Object.entries(captured)) {
+      if (!ROLE_ID_SET.has(roleId)) {
         throw new TypeError(
-          'player session store snapshot player ids must be non-empty',
+          `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`,
+          `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 = (
+  const restoreRoleResumeTokens = (
     tokens: Readonly<Record<string, string>>,
   ): void => {
+    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: PlaybookPendingCall | undefined =
@@ -957,12 +1110,13 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     payload: unknown,
     meta: { turnId?: number; callId?: string } = {},
     describedEmission?: (runtimePorts: PlaybookPorts) => Promise<void>,
+    aborts?: AbortReasonClassifier,
   ): Promise<void> => {
     const runtimePorts = requirePorts();
     const identity = requireSessionIdentity();
     const jsonPayload = snapshotJsonValue(payload, `trace ${type} payload`);
     const trace: PlaybookTraceEvent = Object.freeze({
-      schemaVersion: 2,
+      schemaVersion: 3,
       sessionId: identity.sessionId,
       playbookId: identity.playbookId,
       rootSessionId: identity.rootSessionId,
@@ -980,16 +1134,20 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       ...(meta.callId !== undefined ? { callId: meta.callId } : {}),
       payload: jsonPayload,
     });
-    return enqueue(async () => {
-      await runtimePorts.emitTelemetry({ topic: TRACE_TOPIC, payload: trace });
-      await describedEmission?.(runtimePorts);
-    });
+    return enqueue(
+      async () => {
+        await runtimePorts.emitTelemetry({ topic: TRACE_TOPIC, payload: trace });
+        await describedEmission?.(runtimePorts);
+      },
+      aborts,
+    );
   };
   const emitTrace = (
     type: PlaybookTraceType,
     payload: unknown,
     meta: { turnId?: number; callId?: string } = {},
-  ): Promise<void> => enqueueTracedEmission(type, payload, meta);
+    aborts?: AbortReasonClassifier,
+  ): Promise<void> => enqueueTracedEmission(type, payload, meta, undefined, aborts);
   const emitBoundaryStatus = async (
     message: string,
     state: PlaybookState,
@@ -1018,8 +1176,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     meta: { turnId?: number; callId?: string },
     signal: AbortSignal,
   ): Promise<void> => {
+    const aborts = abortReasonClassifier(signal);
     try {
-      await emitTrace(startedType, identity, meta);
+      await emitTrace(startedType, identity, meta, aborts);
     } catch (error) {
       latchControlPlaneError(error, signal);
       try {
@@ -1027,13 +1186,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           finishedType,
           {
             ...identity,
-            status: 'error',
+            // A started-trace sink rejection causally identical to the
+            // boundary reason is the abort's own evidence: the pair
+            // finishes 'aborted', not 'error' (DR-036 §4).
+            status: isAbortFailure(error, signal) ? 'aborted' : 'error',
             error: normalizeErrorFull(error) ?? {
               name: 'Error',
               message: String(error),
             },
           },
           meta,
+          aborts,
         );
       } catch {
         // Preserve the start failure after one best-effort finish attempt.
@@ -1048,6 +1211,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     purpose: 'boss-input-classification' | 'player-output-adjudication',
     callStateId: string | undefined,
   ): Promise<string> => {
+    const aborts = abortReasonClassifier(signal);
     const identity = {
       purpose,
       ...(callStateId !== undefined ? { stateId: callStateId } : {}),
@@ -1083,13 +1247,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           'judge.call.finished',
           {
             ...identity,
-            status: signal.aborted ? 'aborted' : 'error',
+            // Only the exact abort reason is cancellation; a distinct
+            // failure under an aborted signal stays an error
+            // (slc/link.md §Abort).
+            status: isAbortFailure(error, signal) ? 'aborted' : 'error',
             error: normalizeErrorFull(error) ?? {
               name: 'Error',
               message: String(error),
             },
           },
           { turnId: currentTurnId, callId },
+          aborts,
         );
         throw error;
       }
@@ -1098,6 +1266,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         'judge.call.finished',
         { ...identity, status: 'ok', reply: finalText },
         { turnId: currentTurnId, callId },
+        aborts,
       );
       return finalText;
     });
@@ -1118,28 +1287,35 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
   const runPlayerCall = async (
     input: PlayerInput,
     signal: AbortSignal,
-  ): Promise<{ playerId: string; result: PlayerResult }> => {
-    const playerId = resolvePlayerId(input, binding);
-    if (inFlightPlayerIds.has(playerId)) {
-      throw new Error(
-        `resolved player "${playerId}" already has an in-flight call`,
+  ): Promise<{
+    roleId: RoleId;
+    playerId?: string;
+    result: PlayerResult;
+  }> => {
+    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 prompt = composePlayerPrompt(input);
+    const roleId = input.role;
+    const playerId = resolvedPlayerId(roleId);
+    const playerKey = continuationKey(roleId, playerId);
+    const prompt = composeInvocationPrompt(input);
     let resume: PlayerCallOptions['resume'];
     try {
       signal.throwIfAborted();
-      resume = selectPlayerResume(playerId);
+      resume = selectPlayerResume(roleId, playerId);
     } catch (error) {
       latchControlPlaneError(error, signal);
       throw error;
     }
     const callId = `player-${++playerCallSequence}`;
     const identity = {
-      purpose: 'captain',
       stateId: input.stateId,
       sourceItem: input.sourceItem,
-      playerId,
+      roleId,
+      ...(playerId === undefined ? {} : { playerId }),
       resume,
     };
     const emitFailure = (error: unknown): Promise<void> =>
@@ -1147,15 +1323,33 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         'player.call.finished',
         {
           ...identity,
-          status: signal.aborted ? 'aborted' : 'error',
+          // Only the exact abort reason is cancellation; a distinct
+          // failure under an aborted signal stays an error
+          // (slc/link.md §Abort).
+          status: isAbortFailure(error, signal) ? 'aborted' : 'error',
           error: normalizeErrorFull(error) ?? {
             name: 'Error',
             message: String(error),
           },
         },
         { turnId: currentTurnId, callId },
+        aborts,
+      );
+    if (inFlightPlayerKeys.has(playerKey)) {
+      const error = new Error(
+        `resolved player key "${playerKey}" already has an in-flight call`,
+      );
+      await emitCallStarted(
+        'player.call.started',
+        'player.call.finished',
+        { ...identity, prompt },
+        { turnId: currentTurnId, callId },
+        signal,
       );
-    inFlightPlayerIds.add(playerId);
+      await emitFailure(error);
+      throw error;
+    }
+    inFlightPlayerKeys.add(playerKey);
     try {
       await emitCallStarted(
         'player.call.started',
@@ -1169,7 +1363,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       try {
         signal.throwIfAborted();
         const boundary = Promise.resolve(
-          requirePorts().callPlayer(playerId, prompt, signal, { resume }),
+          requirePorts().callPlayer(roleId, prompt, signal, { resume }),
         );
         rawResult = await boundary;
         // An XState sibling cancellation does not cancel an arbitrary coder
@@ -1205,13 +1399,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       // 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);
         try {
@@ -1241,77 +1429,96 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             : {}),
         },
         { turnId: currentTurnId, callId },
+        aborts,
       );
-      return { playerId, result };
+      return {
+        roleId,
+        ...(playerId === undefined ? {} : { playerId }),
+        result,
+      };
     } finally {
-      inFlightPlayerIds.delete(playerId);
+      inFlightPlayerKeys.delete(playerKey);
     }
   };
 
   const callPlayer = (
     input: PlayerInput,
     signal: AbortSignal,
-  ): Promise<{ playerId: string; result: PlayerResult }> => {
+  ): Promise<{
+    roleId: RoleId;
+    playerId?: string;
+    result: PlayerResult;
+  }> => {
     return trackBoundaryCall(runPlayerCall(input, signal));
   };
 
   const player = fromPromise<PlayerOutput, PlayerInput>(
     async ({ input, signal }) => {
       const combined = combineSignals(signal, currentSignal);
-      // XState starts invoked actors while publishing the entering snapshot.
-      // Yield through the runtime emission queue before crossing the player
-      // boundary so state trace/status always precede its call-start trace.
+      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();
+        try {
+          await flush(settlementAborts);
+        } catch (error) {
+          latchControlPlaneError(error, combined);
+          throw error;
+        }
         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,
-        );
-      } catch (error) {
-        latchControlPlaneError(error, combined);
-        throw error;
+        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;
+        }
+      } finally {
+        actorSettlementAborts.push(settlementAborts);
       }
     },
   );
@@ -1323,7 +1530,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       trackBoundaryCall(
         Promise.resolve(requirePorts().callPlaybook(request, signal)),
       ),
-    emitStarted: async (event) => {
+    emitStarted: async (event, aborts) => {
       playbookCallTurnIds.set(event.callId, currentTurnId);
       await emitTrace(
         'playbook.call.started',
@@ -1336,9 +1543,10 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           ...(currentTurnId === undefined ? {} : { turnId: currentTurnId }),
           callId: event.callId,
         },
+        aborts,
       );
     },
-    emitFinished: async (event) => {
+    emitFinished: async (event, aborts) => {
       const turnId = playbookCallTurnIds.get(event.callId);
       try {
         await emitTrace(
@@ -1353,23 +1561,32 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             ...(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);
+    },
+    bindActorSettlement: (aborts) => {
+      actorSettlementAborts.push(aborts);
     },
-    onControlPlaneError: (error) => {
-      const signal = currentSignal;
-      if (!signal || !isAbortFailure(error, signal)) {
+    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);
+      }
     },
   });
 
@@ -1377,10 +1594,27 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     actors: { player, playbook: nestedBridge.actorLogic },
   });
 
+  const consumeActorSettlementAborts = (
+    forSnapshot = false,
+  ): AbortReasonClassifier | undefined => {
+    const aborts = actorSettlementAborts.shift() ?? actorSettlementErrorAborts;
+    actorSettlementErrorAborts = undefined;
+    if (forSnapshot && aborts !== undefined) {
+      actorSettlementErrorAborts = aborts;
+      queueMicrotask(() => {
+        if (actorSettlementErrorAborts === aborts) {
+          actorSettlementErrorAborts = undefined;
+        }
+      });
+    }
+    return aborts;
+  };
+
   const inspect = (event: InspectionEvent): void => {
     if (event.type !== '@xstate.snapshot') return;
     if (actor === undefined || event.actorRef !== actor) return;
     if (suppressInspectionEmissions) return;
+    const settlementAborts = consumeActorSettlementAborts(true);
     try {
       const snapshot = event.snapshot as SnapshotFrom<typeof decideMachine>;
       const state = normalizePlaybookSnapshot(snapshot);
@@ -1401,6 +1635,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             topic: TELEMETRY_TOPIC,
             payload: describedFsmPayload,
           }),
+        settlementAborts,
       ).catch(() => undefined);
 
       const priorIds = new Set(previousState?.activeStateIds ?? []);
@@ -1426,6 +1661,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           tracePayload,
           { turnId: currentTurnId },
           (emissionPorts) => emissionPorts.emitStatus(message, data),
+          settlementAborts,
         ).catch(() => undefined);
       };
 
@@ -1443,11 +1679,11 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           );
           if (pending) {
             scheduleStatus(
-              `${pending.player} asks: ${pending.question}`,
+              `${pending.asker.roleId} asks: ${pending.question}`,
               activeStateId,
             );
             scheduleStatus(
-              `◆ awaiting Boss reply · ${pending.resumeStateId} · ${pending.player} · ${pending.sourceItem}`,
+              `◆ awaiting Boss reply · ${pending.resumeStateId} · ${pending.asker.roleId} · ${pending.sourceItem}`,
               activeStateId,
             );
           }
@@ -1459,19 +1695,19 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
             : undefined;
         const description = STATE_DESCRIPTIONS[activeStateId];
         if (description === undefined) continue;
-        const playerState = PLAYER_STATES.find(
+        const roleState = ROLE_STATES.find(
           (candidate) => candidate.stateId === activeStateId,
         );
         scheduleStatus(
-          playerState === undefined
+          roleState === undefined
             ? '◆ workflow failed; awaiting Boss recovery.'
-            : `⤷ ${playerState.player}: ${description}`,
+            : `⤷ ${roleLabel(roleState.role)}: ${description}`,
           activeStateId,
           lastError === undefined ? undefined : { lastError },
         );
       }
     } catch (error) {
-      latchInspectionError(error);
+      latchInspectionError(error, settlementAborts);
     }
   };
 
@@ -1490,6 +1726,16 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           }),
       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
@@ -1529,7 +1775,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     const state = normalizePlaybookSnapshot(snapshot, {
       pendingCall: nestedBridge.getPendingCall(),
     });
-    const pendingQuestions = pendingQuestionsFromContext(context);
+    const pendingQuestions = pendingQuestionsForState(state, context);
     if (
       pendingQuestions.length === 0 &&
       (snapshot.status === 'done' ||
@@ -1563,34 +1809,58 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
     const pendingCall = nestedBridge.getPendingCall();
     const state = normalizePlaybookSnapshot(snapshot, { pendingCall });
     const context = snapshot.context as unknown as Record<string, unknown>;
-    if (signal?.aborted) {
-      return {
-        outcome: 'aborted',
-        state,
-        ...(signal.reason === undefined
-          ? {}
-          : {
-              error: normalizeErrorFull(signal.reason) ?? {
-                name: 'AbortError',
-                message: String(signal.reason),
-              },
-            }),
-      };
+    const abortedResult = (abortSignal: AbortSignal): PlaybookRunResult => ({
+      outcome: 'aborted',
+      state,
+      ...(abortSignal.reason === undefined
+        ? {}
+        : {
+            error: normalizeErrorFull(abortSignal.reason) ?? {
+              name: 'AbortError',
+              message: String(abortSignal.reason),
+            },
+          }),
+    });
+    if (snapshot.status === 'error') {
+      // An errored actor outranks a coincident abort unless the actor's
+      // error is the abort reason itself (slc/link.md §Abort).
+      const actorError = (snapshot as { error?: unknown }).error;
+      if (
+        actorError !== undefined &&
+        signal !== undefined &&
+        isAbortFailure(actorError, signal)
+      ) {
+        return abortedResult(signal);
+      }
+      throw (
+        actorError ?? new Error('decide runtime actor entered error status')
+      );
     }
+    // Terminal completion outranks a coincident abort (DR-036 §3): reporting
+    // 'aborted' over a completed machine would hide a terminal state that the
+    // next turn silently restarts, duplicating the workflow's side effects.
     if (snapshot.status === 'done') {
       const output = (snapshot as { output?: unknown }).output;
       if (output !== undefined) assertJsonSafe(output, 'terminal output');
+      const stateDescription = state.activeStateIds.includes('done')
+        ? STATE_DESCRIPTIONS.done
+        : state.activeStateIds.includes('reportedReviewFailure')
+          ? STATE_DESCRIPTIONS.reportedReviewFailure
+          : undefined;
+      if (stateDescription === undefined) {
+        throw new Error(
+          'decide runtime: completed actor has no authored final-state description',
+        );
+      }
       return {
         outcome: 'terminal',
         state,
+        stateDescription,
         ...(output === undefined ? {} : { output }),
       };
     }
-    if (snapshot.status === 'error') {
-      throw (
-        (snapshot as { error?: unknown }).error ??
-        new Error('decide runtime actor entered error status')
-      );
+    if (signal?.aborted) {
+      return abortedResult(signal);
     }
     if (state.activeStateIds.includes('failed')) {
       const error = normalizeErrorFull(context.lastError);
@@ -1652,14 +1922,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         // 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;
@@ -1688,7 +1961,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           'decide runtime: init(session) may only be called once',
         );
       }
-      const identity = snapshotPlaybookSession(session);
+      const identity = bindSession(session);
       let finishInitialization!: () => void;
       const initialization = new Promise<void>((resolve) => {
         finishInitialization = resolve;
@@ -1773,10 +2046,10 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         actor.getSnapshot() as SnapshotFrom<typeof decideMachine>
       ).context as unknown as Record<string, unknown>;
       return {
-        schemaVersion: 2,
+        schemaVersion: 3,
         playbookId: sessionIdentity.playbookId,
         machine,
-        playerResumeTokens: snapshotPlayerResumeTokens(),
+        roleResumeTokens: snapshotRoleResumeTokens(),
         sequences: {
           trace: traceSequence,
           turn: turnSequence,
@@ -1785,10 +2058,10 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           playbookCall: playbookCallSequence,
         },
         state,
-        pendingBossQuestions: pendingQuestionsFromContext(context).map(
+        pendingBossQuestions: pendingQuestionsForState(state, context).map(
           (pending) => ({
             questionId: pending.questionId,
-            player: pending.player,
+            asker: pending.asker,
             question: pending.question,
             sourceItem: pending.sourceItem,
           }),
@@ -1816,16 +2089,13 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
           '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!: () => void;
       const initialization = new Promise<void>((resolve) => {
         finishInitialization = resolve;
@@ -1834,7 +2104,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       lifecycleStarted = true;
       ports = identity.ports;
       sessionIdentity = identity;
-      let priorExternalPlayerTokens:
+      let priorExternalRoleTokens:
         | Readonly<Record<string, string>>
         | undefined;
       try {
@@ -1844,9 +2114,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         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);
@@ -1877,9 +2147,9 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         nestedBridge.confirmRestore();
       } 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],
@@ -1915,12 +2185,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       const turnId = ++turnSequence;
       currentTurnId = turnId;
       currentSignal = turn.signal;
+      currentAborts = abortReasonClassifier(turn.signal);
       controlPlaneError = undefined;
       let result: PlaybookRunResult = resultForSnapshot(turn.signal);
       let settlement: unknown = result;
       const failures: unknown[] = [];
       try {
         await emitTrace('boss.input.received', { text: turn.text }, { turnId });
+        // A boundary entered aborted records the attempted input, then refuses
+        // delivery before deterministic mapping or the classifier can perform
+        // any host-visible work (DR-036 §5).
+        turn.signal.throwIfAborted();
         if (turn.text.trim().length === 0) {
           const state = currentState();
           result = { outcome: 'no-action', state };
@@ -1953,15 +2228,18 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         };
       } catch (error) {
         const primaryError = controlPlaneError;
+        // Only a rejection that is the exact abort reason settles as the
+        // cancellation; a distinct failure observed while the signal is
+        // aborted remains a control error (slc/link.md §Abort).
         if (primaryError !== undefined) {
           collectFailure(failures, primaryError);
-        } else if (!turn.signal.aborted) {
+        } else if (!isAbortFailure(error, turn.signal)) {
           collectFailure(failures, error);
         }
         const state = currentState();
         const effectiveError = primaryError ?? error;
         result =
-          turn.signal.aborted && primaryError === undefined
+          isAbortFailure(error, turn.signal) && primaryError === undefined
             ? resultForSnapshot(turn.signal)
             : {
                 outcome: 'failed',
@@ -1982,13 +2260,13 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       } catch (error) {
         const primaryError = controlPlaneError;
         const effectiveError = primaryError ?? error;
-        collectFailure(failures, effectiveError);
+        // A drain rejection that is the exact abort reason evidences the
+        // cancellation, not a control-plane failure (slc/link.md §Abort).
+        const drainAborted = isAbortFailure(effectiveError, turn.signal);
+        if (!drainAborted) collectFailure(failures, effectiveError);
         const state = currentState();
         result = {
-          outcome:
-            turn.signal.aborted && primaryError === undefined
-              ? 'aborted'
-              : 'failed',
+          outcome: drainAborted ? 'aborted' : 'failed',
           state,
           error: normalizeErrorFull(effectiveError) ?? {
             name: 'Error',
@@ -1997,18 +2275,28 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         };
         settlement = { ...result, ...stateIdentity(state) };
       }
-      currentSignal = undefined;
       try {
         await emitTrace('boss.input.settled', settlement, { turnId });
       } catch (error) {
-        collectFailure(failures, error);
+        // A settlement-trace rejection that is the exact abort reason also
+        // evidences the cancellation (slc/link.md §Abort).
+        if (!isAbortFailure(error, turn.signal)) {
+          collectFailure(failures, error);
+        }
       }
       try {
         await flush();
       } catch (error) {
-        collectFailure(failures, error);
+        // A late flush rejection that is the exact abort reason likewise
+        // evidences the cancellation; the settled result already labels
+        // the turn aborted then (slc/link.md §Abort).
+        if (!isAbortFailure(error, turn.signal)) {
+          collectFailure(failures, error);
+        }
       } finally {
         const primaryError = controlPlaneError;
+        currentSignal = undefined;
+        currentAborts = undefined;
         currentTurnId = undefined;
         controlPlaneError = undefined;
         if (primaryError !== undefined) throw primaryError;
@@ -2044,6 +2332,7 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       }
       currentTurnId = playbookCallTurnIds.get(callId);
       currentSignal = signal;
+      currentAborts = abortReasonClassifier(signal);
       controlPlaneError = undefined;
       let runResult: PlaybookRunResult | undefined;
       let operationError: unknown;
@@ -2070,13 +2359,56 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       } catch (error) {
         drainError = error;
       }
-      const failure = controlPlaneError ?? drainError ?? operationError;
+      const aborts = currentAborts ?? abortReasonClassifier(signal);
+      // The control latch has already classified its failure as distinct
+      // under the operation that owned it. Only still-unclassified drain and
+      // operation candidates may be cancellation evidence for this resume.
+      const controlFailure = controlPlaneError;
+      const drainAbort =
+        controlFailure === undefined &&
+        drainError !== undefined &&
+        aborts.isAbortReason(drainError);
+      const operationAbort =
+        controlFailure === undefined &&
+        operationError !== undefined &&
+        aborts.isAbortReason(operationError);
+      const abortEvidence =
+        (drainAbort ? drainError : undefined) ??
+        (operationAbort ? operationError : undefined);
+      const failure =
+        controlFailure ??
+        (drainAbort ? undefined : drainError) ??
+        (operationAbort ? undefined : operationError);
       currentSignal = undefined;
+      currentAborts = undefined;
       currentTurnId = undefined;
       controlPlaneError = undefined;
       if (failure !== undefined) throw failure;
+      if (
+        abortEvidence !== undefined &&
+        runResult?.outcome !== 'terminal' &&
+        runResult?.outcome !== 'suspended'
+      ) {
+        const state = currentState();
+        runResult = {
+          outcome: 'aborted',
+          state,
+          error: normalizeErrorFull(abortEvidence) ?? {
+            name: 'AbortError',
+            message: String(abortEvidence),
+          },
+        };
+      }
       if (runResult === undefined) {
-        throw new Error('decide runtime: playbook resume produced no result');
+        if (signal.aborted) {
+          // Every candidate was the abort's own evidence: settle on the
+          // machine's state under the aborted boundary signal (DR-036 §4).
+          runResult = resultForSnapshot(signal);
+        } else {
+          throw new Error(
+            'decide runtime: playbook resume produced no result',
+          );
+        }
       }
       return runResult;
     },
@@ -2123,15 +2455,18 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
         } catch (error) {
           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;
@@ -2146,12 +2481,17 @@ export const createPlaybookRuntime: PlaybookRuntimeFactory<
       })();
       return disposalPromise;
     },
+
+    // @internal — test-only parity with the shared factory's bridge escape
+    // hatch. This is hidden by the PlaybookRuntime return type.
+    _getNestedBridge() {
+      return nestedBridge;
+    },
   };
 };
 
 export const _internal = {
   composePlayerPrompt,
-  resolvePlayerId,
   requiredFieldsFor,
   extractJson,
   buildClassifierPrompt,
@@ -2160,12 +2500,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,