@sublang/playbook 5.0.0 → 6.0.0

package/reference/sdlc/code.playbook/code.registry.d.ts

@@ -1,24 +1,4 @@
 import { type CodePlaybookOptions, type PlaybookRuntime } from './code.playbook.js';
-export declare const codeCopyPasteGuardNames: readonly ["accepted", "approved", "challengeAccepted", "challengeRejected", "challengesRaised", "changesMadeCode", "changesMadeCodeAndChallenged", "changesMadeMixed", "changesMadeMixedAndChallenged", "changesMadeSpecs", "changesMadeSpecsAndChallenged", "hasFindings", "needsRevision", "noFindings", "noOpenItems"];
-export declare const codeStateCountLabels: {
-    readonly adjudicateChallenges: "rebuttal";
-    readonly reviewBossCommitSpecs: "review round";
-    readonly reviewBossCommitCode: "review round";
-    readonly reviewBossCommitMixed: "review round";
-    readonly reviewIrTaskCommitSpecs: "review round";
-    readonly reviewIrTaskCommitCode: "review round";
-    readonly reviewIrTaskCommitMixed: "review round";
-    readonly reviewChangesSpecs: "review round";
-    readonly reviewChangesCode: "review round";
-    readonly reviewChangesMixed: "review round";
-    readonly reviewChangesAndChallengesSpecs: "review round";
-    readonly reviewChangesAndChallengesCode: "review round";
-    readonly reviewChangesAndChallengesMixed: "review round";
-};
-export declare function codeSavedCountsLine(counts: {
-    interruptions: number;
-    copyPastes: number;
-}, rounds: number): string;
 export interface PlaybookSummaryPolicy {
     stateCountLabels: Readonly<Record<string, string>>;
     copyPasteGuardNames: readonly string[];
@@ -27,10 +7,6 @@ export interface PlaybookSummaryPolicy {
         copyPastes: number;
     }, rounds: number): string;
 }
-export declare const codeSummaryPolicy: PlaybookSummaryPolicy;
-export interface CodeOptions {
-    committer?: 'coder' | 'reviewer';
-}
 export interface RegistryPlayer {
     id: string;
     adapter?: string;
@@ -40,15 +16,23 @@ export interface CreateCodeRuntimeOptions {
     captainOptions: unknown;
     players: readonly RegistryPlayer[];
 }
+export type CodeOptions = Readonly<Record<string, never>>;
 export interface CodePlaybookRegistryEntry {
     id: 'code';
     command: 'code';
     intent: string;
-    requiredRoleIds: readonly string[];
+    requiredRoleIds: readonly ['coder'];
     summaryPolicy: PlaybookSummaryPolicy;
     validateOptions(captainOptions: unknown): CodeOptions;
     createRuntime(options: CreateCodeRuntimeOptions): PlaybookRuntime;
 }
+export declare const codeStateCountLabels: {};
+export declare const codeCopyPasteGuardNames: readonly ["directCommit", "irCommit", "moreTasks", "finalTask"];
+export declare function codeSavedCountsLine(counts: {
+    interruptions: number;
+    copyPastes: number;
+}, rounds: number): string;
+export declare const codeSummaryPolicy: PlaybookSummaryPolicy;
 export declare function validateCodeOptions(optionSlice: unknown): CodeOptions;
 export declare function createCodeRuntimeOptions({ captainOptions, players, }: CreateCodeRuntimeOptions): CodePlaybookOptions;
 export declare const codePlaybookRegistryEntry: CodePlaybookRegistryEntry;

package/reference/sdlc/code.playbook/code.registry.js

@@ -1,55 +1,18 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
 import createPlaybookRuntime from './code.playbook.js';
-// PBRT-30: the CODE registry entry validates the option slice the shell
-// passes it (`captain.options.playbooks.code.options`), not a namespace
-// it extracts from the full Captain options bag. The schema defines one
-// key, `committer`: an optional Committer-alias player id, one of the
-// baked role ids `coder` / `reviewer`. A valid slice is absent, `{}`, or
-// `{ committer: 'coder' | 'reviewer' }`; every other key is unknown and
-// rejected with a path-named error. A further CODE option shall be
-// introduced as its own higher-numbered item that widens
-// `CODE_OPTION_KEYS`; the validator still fails closed on stray keys.
-const CODE_OPTION_KEYS = new Set(['committer']);
-const COMMITTER_PLAYER_IDS = new Set(['coder', 'reviewer']);
+// REVIEW owns and labels its real review rounds. CODE's two suspended wrapper
+// states only delegate to that child and must not double-count those rounds.
+export const codeStateCountLabels = {};
 export const codeCopyPasteGuardNames = [
-    'accepted',
-    'approved',
-    'challengeAccepted',
-    'challengeRejected',
-    'challengesRaised',
-    'changesMadeCode',
-    'changesMadeCodeAndChallenged',
-    'changesMadeMixed',
-    'changesMadeMixedAndChallenged',
-    'changesMadeSpecs',
-    'changesMadeSpecsAndChallenged',
-    'hasFindings',
-    'needsRevision',
-    'noFindings',
-    'noOpenItems',
+    'directCommit',
+    'irCommit',
+    'moreTasks',
+    'finalTask',
 ];
-export const codeStateCountLabels = {
-    adjudicateChallenges: 'rebuttal',
-    reviewBossCommitSpecs: 'review round',
-    reviewBossCommitCode: 'review round',
-    reviewBossCommitMixed: 'review round',
-    reviewIrTaskCommitSpecs: 'review round',
-    reviewIrTaskCommitCode: 'review round',
-    reviewIrTaskCommitMixed: 'review round',
-    reviewChangesSpecs: 'review round',
-    reviewChangesCode: 'review round',
-    reviewChangesMixed: 'review round',
-    reviewChangesAndChallengesSpecs: 'review round',
-    reviewChangesAndChallengesCode: 'review round',
-    reviewChangesAndChallengesMixed: 'review round',
-};
 function countNoun(count, singular, plural = `${singular}s`) {
     return `${count} ${count === 1 ? singular : plural}`;
 }
-// PBRT-15 / CAPTAIN-19: the CODE saved-counts line wording is
-// registry-owned. The shell renders this exact line through the active
-// entry's summary policy rather than hardcoding CODE phrasing.
 export function codeSavedCountsLine(counts, rounds) {
     return [
         'Saved you',
@@ -68,57 +31,36 @@ export const codeSummaryPolicy = {
 };
 export function validateCodeOptions(optionSlice) {
     if (optionSlice === undefined)
-        return {};
-    if (typeof optionSlice !== 'object' ||
-        optionSlice === null ||
+        return Object.freeze({});
+    if (optionSlice === null ||
+        typeof optionSlice !== 'object' ||
         Array.isArray(optionSlice)) {
         throw new Error('captain.options.playbooks.code.options must be an object');
     }
-    const slice = optionSlice;
-    for (const key of Object.keys(slice)) {
-        if (!CODE_OPTION_KEYS.has(key)) {
-            throw new Error(`Unknown config field captain.options.playbooks.code.options.${key}`);
-        }
-    }
-    const options = {};
-    const committer = slice.committer;
-    if (committer !== undefined) {
-        if (typeof committer !== 'string' || !COMMITTER_PLAYER_IDS.has(committer)) {
-            throw new Error("captain.options.playbooks.code.options.committer must be " +
-                "'coder' or 'reviewer'");
-        }
-        options.committer = committer;
+    const keys = Object.keys(optionSlice);
+    if (keys.length > 0) {
+        throw new Error(`Unknown config field captain.options.playbooks.code.options.${keys[0]}`);
     }
-    return options;
+    return Object.freeze({});
 }
 function playerIdentity(players, id) {
-    const entry = players.find((p) => p.id === id);
-    return entry?.model ?? entry?.adapter;
+    const player = players.find((entry) => entry.id === id);
+    return player?.model ?? player?.adapter;
 }
 export function createCodeRuntimeOptions({ captainOptions, players, }) {
-    const codeOptions = validateCodeOptions(captainOptions);
+    validateCodeOptions(captainOptions);
     const coderPlayer = playerIdentity(players, 'coder');
-    const reviewerPlayer = playerIdentity(players, 'reviewer');
-    return {
-        coderPlayer,
-        reviewerPlayer,
-        ...(codeOptions.committer !== undefined
-            ? { committerPlayer: codeOptions.committer }
-            : {}),
-    };
+    return coderPlayer === undefined ? {} : { coderPlayer };
 }
 export const codePlaybookRegistryEntry = {
     id: 'code',
     command: 'code',
-    intent: 'software development / SDLC coding workflow',
-    requiredRoleIds: ['coder', 'reviewer'],
+    intent: 'implement a coding intent in reviewed, one-commit phases, using an intent record when needed',
+    requiredRoleIds: ['coder'],
     summaryPolicy: codeSummaryPolicy,
     validateOptions: validateCodeOptions,
     createRuntime(options) {
         return createPlaybookRuntime(createCodeRuntimeOptions(options));
     },
 };
-// CAPTAIN-16 / PBRT-16: the published `@sublang/playbook/code/registry`
-// module's default export is the CODE registry entry the Playbook Captain
-// shell loads when a playbook block's `from` names this module.
 export default codePlaybookRegistryEntry;

package/reference/sdlc/code.playbook/code.registry.ts

@@ -6,77 +6,6 @@ import createPlaybookRuntime, {
   type PlaybookRuntime,
 } from './code.playbook.js';
 
-// PBRT-30: the CODE registry entry validates the option slice the shell
-// passes it (`captain.options.playbooks.code.options`), not a namespace
-// it extracts from the full Captain options bag. The schema defines one
-// key, `committer`: an optional Committer-alias player id, one of the
-// baked role ids `coder` / `reviewer`. A valid slice is absent, `{}`, or
-// `{ committer: 'coder' | 'reviewer' }`; every other key is unknown and
-// rejected with a path-named error. A further CODE option shall be
-// introduced as its own higher-numbered item that widens
-// `CODE_OPTION_KEYS`; the validator still fails closed on stray keys.
-const CODE_OPTION_KEYS = new Set<string>(['committer']);
-const COMMITTER_PLAYER_IDS = new Set<string>(['coder', 'reviewer']);
-export const codeCopyPasteGuardNames = [
-  'accepted',
-  'approved',
-  'challengeAccepted',
-  'challengeRejected',
-  'challengesRaised',
-  'changesMadeCode',
-  'changesMadeCodeAndChallenged',
-  'changesMadeMixed',
-  'changesMadeMixedAndChallenged',
-  'changesMadeSpecs',
-  'changesMadeSpecsAndChallenged',
-  'hasFindings',
-  'needsRevision',
-  'noFindings',
-  'noOpenItems',
-] as const;
-
-export const codeStateCountLabels = {
-  adjudicateChallenges: 'rebuttal',
-  reviewBossCommitSpecs: 'review round',
-  reviewBossCommitCode: 'review round',
-  reviewBossCommitMixed: 'review round',
-  reviewIrTaskCommitSpecs: 'review round',
-  reviewIrTaskCommitCode: 'review round',
-  reviewIrTaskCommitMixed: 'review round',
-  reviewChangesSpecs: 'review round',
-  reviewChangesCode: 'review round',
-  reviewChangesMixed: 'review round',
-  reviewChangesAndChallengesSpecs: 'review round',
-  reviewChangesAndChallengesCode: 'review round',
-  reviewChangesAndChallengesMixed: 'review round',
-} as const;
-
-function countNoun(count: number, singular: string, plural = `${singular}s`): string {
-  return `${count} ${count === 1 ? singular : plural}`;
-}
-
-// PBRT-15 / CAPTAIN-19: the CODE saved-counts line wording is
-// registry-owned. The shell renders this exact line through the active
-// entry's summary policy rather than hardcoding CODE phrasing.
-export function codeSavedCountsLine(
-  counts: { interruptions: number; copyPastes: number },
-  rounds: number,
-): string {
-  return [
-    'Saved you',
-    countNoun(counts.interruptions, 'interruption'),
-    'and',
-    countNoun(counts.copyPastes, 'copy-paste'),
-    'across',
-    countNoun(rounds, 'round'),
-    'of reviews/rebuttals.',
-  ].join(' ');
-}
-
-// CAPTAIN-20 summary policy: the counted state-id labels, the
-// copy-paste guard names, and the saved-counts line wording an entry
-// owns for the shell's turn-summary aggregation. An entry without a
-// summary policy opts out of visible turn summaries.
 export interface PlaybookSummaryPolicy {
   stateCountLabels: Readonly<Record<string, string>>;
   copyPasteGuardNames: readonly string[];
@@ -86,19 +15,6 @@ export interface PlaybookSummaryPolicy {
   ): string;
 }
 
-export const codeSummaryPolicy: PlaybookSummaryPolicy = {
-  stateCountLabels: codeStateCountLabels,
-  copyPasteGuardNames: codeCopyPasteGuardNames,
-  savedCountsLine: codeSavedCountsLine,
-};
-
-// The validated CODE options set. `committer`, when present, is the
-// resolved Committer-alias player id (PBRT-8 / PBRT-30); a future CODE
-// option widens both this type and `CODE_OPTION_KEYS`.
-export interface CodeOptions {
-  committer?: 'coder' | 'reviewer';
-}
-
 export interface RegistryPlayer {
   id: string;
   adapter?: string;
@@ -110,76 +26,99 @@ export interface CreateCodeRuntimeOptions {
   players: readonly RegistryPlayer[];
 }
 
+export type CodeOptions = Readonly<Record<string, never>>;
+
 export interface CodePlaybookRegistryEntry {
   id: 'code';
   command: 'code';
   intent: string;
-  requiredRoleIds: readonly string[];
+  requiredRoleIds: readonly ['coder'];
   summaryPolicy: PlaybookSummaryPolicy;
   validateOptions(captainOptions: unknown): CodeOptions;
   createRuntime(options: CreateCodeRuntimeOptions): PlaybookRuntime;
 }
 
+// REVIEW owns and labels its real review rounds. CODE's two suspended wrapper
+// states only delegate to that child and must not double-count those rounds.
+export const codeStateCountLabels = {} as const;
+
+export const codeCopyPasteGuardNames = [
+  'directCommit',
+  'irCommit',
+  'moreTasks',
+  'finalTask',
+] as const;
+
+function countNoun(
+  count: number,
+  singular: string,
+  plural = `${singular}s`,
+): string {
+  return `${count} ${count === 1 ? singular : plural}`;
+}
+
+export function codeSavedCountsLine(
+  counts: { interruptions: number; copyPastes: number },
+  rounds: number,
+): string {
+  return [
+    'Saved you',
+    countNoun(counts.interruptions, 'interruption'),
+    'and',
+    countNoun(counts.copyPastes, 'copy-paste'),
+    'across',
+    countNoun(rounds, 'round'),
+    'of reviews/rebuttals.',
+  ].join(' ');
+}
+
+export const codeSummaryPolicy: PlaybookSummaryPolicy = {
+  stateCountLabels: codeStateCountLabels,
+  copyPasteGuardNames: codeCopyPasteGuardNames,
+  savedCountsLine: codeSavedCountsLine,
+};
+
 export function validateCodeOptions(optionSlice: unknown): CodeOptions {
-  if (optionSlice === undefined) return {};
+  if (optionSlice === undefined) return Object.freeze({});
   if (
-    typeof optionSlice !== 'object' ||
     optionSlice === null ||
+    typeof optionSlice !== 'object' ||
     Array.isArray(optionSlice)
   ) {
     throw new Error('captain.options.playbooks.code.options must be an object');
   }
-  const slice = optionSlice as Record<string, unknown>;
-  for (const key of Object.keys(slice)) {
-    if (!CODE_OPTION_KEYS.has(key)) {
-      throw new Error(
-        `Unknown config field captain.options.playbooks.code.options.${key}`,
-      );
-    }
-  }
-  const options: CodeOptions = {};
-  const committer = slice.committer;
-  if (committer !== undefined) {
-    if (typeof committer !== 'string' || !COMMITTER_PLAYER_IDS.has(committer)) {
-      throw new Error(
-        "captain.options.playbooks.code.options.committer must be " +
-          "'coder' or 'reviewer'",
-      );
-    }
-    options.committer = committer as 'coder' | 'reviewer';
+  const keys = Object.keys(optionSlice);
+  if (keys.length > 0) {
+    throw new Error(
+      `Unknown config field captain.options.playbooks.code.options.${keys[0]}`,
+    );
   }
-  return options;
+  return Object.freeze({});
 }
 
 function playerIdentity(
   players: readonly RegistryPlayer[],
   id: string,
 ): string | undefined {
-  const entry = players.find((p) => p.id === id);
-  return entry?.model ?? entry?.adapter;
+  const player = players.find((entry) => entry.id === id);
+  return player?.model ?? player?.adapter;
 }
 
 export function createCodeRuntimeOptions({
   captainOptions,
   players,
 }: CreateCodeRuntimeOptions): CodePlaybookOptions {
-  const codeOptions = validateCodeOptions(captainOptions);
+  validateCodeOptions(captainOptions);
   const coderPlayer = playerIdentity(players, 'coder');
-  const reviewerPlayer = playerIdentity(players, 'reviewer');
-  return {
-    coderPlayer,
-    reviewerPlayer,
-    ...(codeOptions.committer !== undefined
-      ? { committerPlayer: codeOptions.committer }
-      : {}),
-  };
+  return coderPlayer === undefined ? {} : { coderPlayer };
 }
 
 export const codePlaybookRegistryEntry: CodePlaybookRegistryEntry = {
   id: 'code',
   command: 'code',
-  intent: 'software development / SDLC coding workflow',
-  requiredRoleIds: ['coder', 'reviewer'],
+  intent:
+    'implement a coding intent in reviewed, one-commit phases, using an intent record when needed',
+  requiredRoleIds: ['coder'],
   summaryPolicy: codeSummaryPolicy,
   validateOptions: validateCodeOptions,
   createRuntime(options) {
@@ -187,7 +126,4 @@ export const codePlaybookRegistryEntry: CodePlaybookRegistryEntry = {
   },
 };
 
-// CAPTAIN-16 / PBRT-16: the published `@sublang/playbook/code/registry`
-// module's default export is the CODE registry entry the Playbook Captain
-// shell loads when a playbook block's `from` names this module.
 export default codePlaybookRegistryEntry;

package/reference/sdlc/code.playbook/playbook-captain.js

@@ -495,7 +495,6 @@ async function buildEnablements(options, players, loadModule) {
             optionInput: record.options,
             boundPlayers,
             hostPlayerId: (localRole) => `${entry.id}-${localRole}`,
-            visiblePlayerIds: entry.requiredRoleIds.map((role) => `${entry.id}-${role}`),
         });
     }
     return { entries, byCommand, byId, enablementById };
@@ -555,6 +554,24 @@ export function createPlaybookCaptainShell(options, deps = {}) {
     const rootFrame = () => frames[0];
     const leafFrame = () => frames.at(-1);
     const frameLabel = (frame) => `/${frame.enablement.command}`;
+    const bindingFor = (frame, localRole) => {
+        const binding = frame.playerBindings.get(localRole);
+        if (!binding) {
+            throw new Error(`${frameLabel(frame)} resolved undeclared player role ${JSON.stringify(localRole)}`);
+        }
+        return binding;
+    };
+    const summaryIncludes = (frame) => {
+        const owner = activeTurnSummary?.owner;
+        if (!owner)
+            return false;
+        for (let current = frame; current;) {
+            if (current === owner)
+                return true;
+            current = current.parent?.frame;
+        }
+        return false;
+    };
     const requireSession = () => {
         if (!session) {
             throw new Error('init must be called first');
@@ -717,7 +734,8 @@ export function createPlaybookCaptainShell(options, deps = {}) {
             return;
         const previousActiveIds = new Set(frame.state?.activeStateIds ?? []);
         frame.state = state;
-        if (activeTurnSummary?.owner === frame) {
+        const summary = activeTurnSummary;
+        if (summary && summaryIncludes(frame)) {
             for (const stateId of state.activeStateIds) {
                 const newlyActive = !previousActiveIds.has(stateId);
                 const structuredEntry = stateValueContains(record.to, stateId) &&
@@ -726,7 +744,7 @@ export function createPlaybookCaptainShell(options, deps = {}) {
                     continue;
                 const countLabel = stateCountLabel(stateId, frame.entry);
                 if (countLabel) {
-                    activeTurnSummary.stateCounts.set(countLabel, (activeTurnSummary.stateCounts.get(countLabel) ?? 0) + 1);
+                    summary.stateCounts.set(countLabel, (summary.stateCounts.get(countLabel) ?? 0) + 1);
                 }
             }
         }
@@ -747,7 +765,7 @@ export function createPlaybookCaptainShell(options, deps = {}) {
             }
             const context = activeContext;
             signal.throwIfAborted();
-            const hostPlayerId = frame.enablement.hostPlayerId(playerId);
+            const hostPlayerId = bindingFor(frame, playerId).hostPlayerId;
             const result = await trackHostCall(frame, context.callPlayer(hostPlayerId, prompt, {
                 resume: options.resume,
             }));
@@ -759,8 +777,9 @@ export function createPlaybookCaptainShell(options, deps = {}) {
             // CAPTAIN-20: only a player call that actually produced work is an
             // interruption the Boss was spared. A call that errored or aborted
             // saved nothing, so it never feeds the saved-counts gate.
-            if (activeTurnSummary?.owner === frame && result.status === 'ok') {
-                activeTurnSummary.counts.interruptions++;
+            const summary = activeTurnSummary;
+            if (summary && summaryIncludes(frame) && result.status === 'ok') {
+                summary.counts.interruptions++;
             }
             return {
                 status: result.status,
@@ -806,10 +825,12 @@ export function createPlaybookCaptainShell(options, deps = {}) {
                 throw new Error('callCaptain returned status=ok with no finalText');
             }
             const guard = guardFromJudgeReply(result.finalText);
+            const summary = activeTurnSummary;
             if (guard &&
-                activeTurnSummary?.owner === frame &&
+                summary &&
+                summaryIncludes(frame) &&
                 frame.entry.summaryPolicy?.copyPasteGuardNames.includes(guard)) {
-                activeTurnSummary.counts.copyPastes++;
+                summary.counts.copyPastes++;
             }
             return result.finalText;
         },
@@ -841,8 +862,8 @@ export function createPlaybookCaptainShell(options, deps = {}) {
     // visibility for that playbook's generated host players. A pane
     // reconciliation failure is display-only in tmux-play and does not
     // reject; the legacy path carries no generated set and skips this.
-    const requestVisibility = async (enablement) => {
-        const ids = enablement.visiblePlayerIds;
+    const requestVisibility = async (frame) => {
+        const ids = [...new Set([...frame.playerBindings.values()].map(({ hostPlayerId }) => hostPlayerId))];
         if (!ids || ids.length === 0 || !activeContext)
             return;
         try {
@@ -878,9 +899,30 @@ export function createPlaybookCaptainShell(options, deps = {}) {
     const makeFrame = (enablement, parent) => {
         const entry = enablement.entry;
         const sessionId = allocateSessionId();
+        const playerBindings = new Map();
+        for (const role of entry.requiredRoleIds) {
+            let inherited;
+            for (let ancestor = parent?.frame; ancestor && inherited === undefined; ancestor = ancestor.parent?.frame) {
+                inherited = ancestor.playerBindings.get(role);
+            }
+            if (inherited) {
+                playerBindings.set(role, inherited);
+                continue;
+            }
+            const configured = enablement.boundPlayers.find((player) => player.id === role) ?? { id: role };
+            playerBindings.set(role, {
+                hostPlayerId: enablement.hostPlayerId(role),
+                player: configured,
+            });
+        }
+        const playerResumeTokens = parent?.frame.playerResumeTokens ?? new Map();
         const runtime = entry.createRuntime({
             captainOptions: enablement.optionInput,
-            players: enablement.boundPlayers,
+            players: [...playerBindings].map(([role, { player }]) => ({
+                id: role,
+                ...(player.adapter === undefined ? {} : { adapter: player.adapter }),
+                ...(player.model === undefined ? {} : { model: player.model }),
+            })),
         });
         return {
             entry,
@@ -889,10 +931,45 @@ export function createPlaybookCaptainShell(options, deps = {}) {
             sessionId,
             rootSessionId: parent?.frame.rootSessionId ?? sessionId,
             depth: parent ? parent.frame.depth + 1 : 0,
+            playerBindings,
+            playerResumeTokens,
             ...(parent ? { parent } : {}),
             inFlightHostCalls: new Set(),
         };
     };
+    const playerSessionStore = (frame) => ({
+        select(playerId) {
+            const binding = bindingFor(frame, playerId);
+            return frame.playerResumeTokens.get(binding.hostPlayerId) ?? false;
+        },
+        update(playerId, resumeToken) {
+            const binding = bindingFor(frame, playerId);
+            if (resumeToken === undefined) {
+                frame.playerResumeTokens.delete(binding.hostPlayerId);
+            }
+            else {
+                frame.playerResumeTokens.set(binding.hostPlayerId, resumeToken);
+            }
+        },
+        snapshot() {
+            const tokens = {};
+            for (const [playerId, binding] of frame.playerBindings) {
+                const token = frame.playerResumeTokens.get(binding.hostPlayerId);
+                if (token !== undefined)
+                    tokens[playerId] = token;
+            }
+            return tokens;
+        },
+        restore(tokens) {
+            for (const binding of frame.playerBindings.values()) {
+                frame.playerResumeTokens.delete(binding.hostPlayerId);
+            }
+            for (const [playerId, token] of Object.entries(tokens)) {
+                const binding = bindingFor(frame, playerId);
+                frame.playerResumeTokens.set(binding.hostPlayerId, token);
+            }
+        },
+    });
     const initFrame = async (frame) => {
         await frame.runtime.init({
             sessionId: frame.sessionId,
@@ -905,6 +982,7 @@ export function createPlaybookCaptainShell(options, deps = {}) {
                 }
                 : {}),
             depth: frame.depth,
+            playerSessions: playerSessionStore(frame),
             ports: createPorts(frame),
         });
     };
@@ -1076,7 +1154,7 @@ export function createPlaybookCaptainShell(options, deps = {}) {
         }
         let visibilityError;
         try {
-            await requestVisibility(parent.enablement);
+            await requestVisibility(parent);
         }
         catch (error) {
             visibilityError = error;
@@ -1184,7 +1262,7 @@ export function createPlaybookCaptainShell(options, deps = {}) {
         // boundary — a `setVisiblePlayers` or telemetry rejection here leaves the
         // runtime uninvoked and owes the Boss the CAPTAIN-34 reply rather than an
         // exception filed against an effect that never ran.
-        await requestVisibility(frame.enablement);
+        await requestVisibility(frame);
         await setMode('engaged.driving', 'submit');
         const result = await runEffect(() => frame.runtime.handleBossInput({ text, signal }));
         frame.state = result.state;
@@ -1306,7 +1384,7 @@ export function createPlaybookCaptainShell(options, deps = {}) {
             cleanupError = error;
         }
         if (frames.includes(parent)) {
-            await requestVisibility(parent.enablement);
+            await requestVisibility(parent);
         }
         if (cleanupError !== undefined)
             throw cleanupError;
@@ -1418,7 +1496,7 @@ export function createPlaybookCaptainShell(options, deps = {}) {
             }
             if (frames.includes(parent)) {
                 try {
-                    await requestVisibility(parent.enablement);
+                    await requestVisibility(parent);
                 }
                 catch (visibilityError) {
                     visibilityControlFailure = true;