@sublang/playbook 15.1.0 → 17.0.0

package/reference/sdlc/code.playbook/code.gears.md

@@ -1,7 +1,7 @@
 <!-- SPDX-License-Identifier: Apache-2.0 -->
 <!-- SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai> -->
 
-# CODE: Commit-Based Coding Workflow
+# Code
 
 Roles:
 
@@ -11,11 +11,12 @@ Roles:
 
 ### CODE-1
 
-When the first coding phase begins, Captain shall prompt Coder:
+Each phase ends with exactly one new Coder commit owned by `code`, and no existing commit is rewritten.
+Captain uses the repository-effect receipt as the authoritative identity of the phase's new commit.
+When the request may continue an existing IR that it does not identify unambiguously, Coder asks Boss before changing files, and Boss's answer resumes this same phase.
+
+When the first coding phase begins for the caller's coding request and any relevant context, Captain shall prompt Coder:
 
-> > Original request: <caller-input>
-> > Run results: <run-results>
->
 > First determine whether the coding request starts a new coding intent or continues an existing IR with unfinished work.
 > If the request may continue an existing IR but does not identify it unambiguously, ask Boss before changing files.
 >
@@ -37,36 +38,39 @@ When the first coding phase begins, Captain shall prompt Coder:
 > Make the commit message explain concisely what changed and why, including relevant verification.
 > Identify every new commit you make.
 > Credit every AI that contributed to this commit: Coder <coder-llm>.
+>
+> > Original request: <caller-input>
+> > Run results: <run-results>
 
 Results:
-- `directCommit`: Coder completed and committed the direct implementation phase. Output shall include `coderOutput: <verbatim final text>` and `latestCommit: <commit identity>`.
-- `irCommit`: Coder created and committed a new IR without implementing an IR task. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, and `irNumber` identifying the created IR.
-- `moreTasks`: Coder continued an existing IR, completed and committed exactly its next unfinished task, and at least one task remains. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the continued IR, and `irTask` naming the implemented task.
-- `finalTask`: Coder continued an existing IR and completed and committed its final task. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the continued IR, and `irTask` naming the implemented task.
+- `directCommit`: Coder completed the new coding intent as one direct implementation phase and made its one new commit; Coder's result affirmatively supports this outcome, and no fixed presentation format of the reply is required. Output shall include `coderOutput: <verbatim final text>` and `latestCommit: <commit identity>`.
+- `irCommit`: Coder decomposed the new coding intent into a new IR, implemented no IR task, and made its one new commit; Coder's result affirmatively supports this outcome, and no fixed presentation format of the reply is required. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, and `irNumber` identifying the created IR.
+- `moreTasks`: Coder continued an existing IR, implemented exactly its next unfinished task, made its one new commit, and at least one IR task remains unfinished; Coder's result affirmatively supports this outcome, and no fixed presentation format of the reply is required. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the continued IR, and `irTask` naming the implemented task.
+- `finalTask`: Coder continued an existing IR, implemented its final unfinished task, and made its one new commit; Coder's result affirmatively supports this outcome, and no fixed presentation format of the reply is required. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the continued IR, and `irTask` naming the implemented task.
 
 ### CODE-2
 
-When a direct implementation or new-IR phase has one new commit, Captain shall call playbook `review`:
+Captain waits until `review` passes with no unsettled findings; playbook `review` owns every review round and every review-fix commit, and no existing commit is rewritten.
+
+When a direct implementation or new-IR phase ends with its one new `code`-owned commit, Captain shall call playbook `review`:
 
 > > Original intent: <caller-input>
 > > Review scope: the commit <code-commit> from this coding phase and its resulting repository state.
 > > Coder output: <coder-output>
 
-Workflow outcomes:
-- A nested `review` passes the phase only when its result applies to the supplied review scope, returns the exact evaluated repository revision, and affirmatively establishes that no unsettled findings remain.
-- A pass after a direct implementation phase completes `code` with the exact last `code`-owned commit, the exact final evaluated repository revision, and the fact that every phase's review passed with no unsettled findings.
-- A pass after a new-IR phase continues with the next unfinished IR-task phase.
-- An authored `review` abort or failure, or a terminal result that does not establish that the supplied scope was evaluated with no unsettled findings, terminates `code` with the failure and the last `code`-owned commit.
-- Any other nested-call error parks `code` as failed and retains the control-plane error.
+A nested `review` passes the phase only when its result applies to that supplied review scope, returns the exact evaluated repository revision, and affirmatively establishes that no unsettled findings remain.
+When `review` passes a direct implementation phase, `code` is complete and returns to its caller the exact last `code`-owned commit, the exact final evaluated repository revision, and the fact that every phase's review passed with no unsettled findings.
+When `review` passes a new-IR phase, Captain continues with the next unfinished IR-task phase.
+When `review` returns an authored abort or failure, or a terminal result that does not establish that the supplied scope was evaluated with no unsettled findings, `code` starts no further phase and reports the failure and the last `code`-owned commit to its caller.
+When the nested `review` call fails outside that authored result contract, `code` parks as failed and retains the control-plane error instead of reporting an authored review outcome.
 
 ### CODE-3
 
+Each phase ends with exactly one new Coder commit owned by `code`, and no existing commit is rewritten.
+Captain uses the repository-effect receipt as the authoritative identity of the phase's new commit.
+
 When a later IR-task phase begins, Captain shall prompt Coder:
 
-> > Original request: <caller-input>
-> > IR number: <ir-number>
-> > Run results: <run-results>
->
 > Read the identified IR and implement exactly its next unfinished task, including corresponding tests or specs if any.
 > Do not implement a later task in this phase.
 > Mark the IR's progress and deliverables when relevant.
@@ -78,23 +82,29 @@ When a later IR-task phase begins, Captain shall prompt Coder:
 > Make the commit message explain concisely what changed and why, including relevant verification.
 > Identify every new commit you make.
 > Credit every AI that contributed to this commit: Coder <coder-llm>.
+>
+> > Original request: <caller-input>
+> > IR number: <ir-number>
+> > Run results: <run-results>
 
 Results:
-- `moreTasks`: Coder completed and committed exactly the IR's next unfinished task and at least one task remains. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the continued IR, and `irTask` naming the implemented task.
-- `finalTask`: Coder completed and committed the IR's final task. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the continued IR, and `irTask` naming the implemented task.
+- `moreTasks`: Coder implemented exactly the IR's next unfinished task, made its one new commit, and at least one IR task remains unfinished; Coder's result affirmatively supports this outcome, and no fixed presentation format of the reply is required. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the IR, and `irTask` naming the implemented task.
+- `finalTask`: Coder implemented the IR's final unfinished task and made its one new commit; Coder's result affirmatively supports this outcome, and no fixed presentation format of the reply is required. Output shall include `coderOutput: <verbatim final text>`, `latestCommit: <commit identity>`, `irNumber` identifying the IR, and `irTask` naming the implemented task.
 
 ### CODE-4
 
-When an IR-task phase has one new commit, Captain shall call playbook `review`:
+Captain waits until `review` passes with no unsettled findings; playbook `review` owns every review round and every review-fix commit, and no existing commit is rewritten.
+
+When an IR-task phase, including the first phase for an existing IR, ends with its one new `code`-owned commit, Captain shall call playbook `review`:
 
 > > Original intent: <caller-input>
 > > Review scope: the commit <code-commit> from this coding phase and its resulting repository state.
 > > Coder output: <coder-output>
+>
 > > Current IR task: <ir-task>
 
-Workflow outcomes:
-- A nested `review` passes the phase only when its result applies to the supplied review scope, returns the exact evaluated repository revision, and affirmatively establishes that no unsettled findings remain.
-- A pass after a nonfinal IR-task phase continues with the next unfinished IR-task phase.
-- A pass after the final IR-task phase completes `code` with the exact last `code`-owned commit, the exact final evaluated repository revision, and the fact that every phase's review passed with no unsettled findings.
-- An authored `review` abort or failure, or a terminal result that does not establish that the supplied scope was evaluated with no unsettled findings, terminates `code` with the failure and the last `code`-owned commit.
-- Any other nested-call error parks `code` as failed and retains the control-plane error.
+A nested `review` passes the phase only when its result applies to that supplied review scope, returns the exact evaluated repository revision, and affirmatively establishes that no unsettled findings remain.
+When `review` passes a nonfinal IR-task phase, Captain continues with the next unfinished IR-task phase.
+When `review` passes the final IR-task phase, `code` is complete and returns to its caller the exact last `code`-owned commit, the exact final evaluated repository revision, and the fact that every phase's review passed with no unsettled findings.
+When `review` returns an authored abort or failure, or a terminal result that does not establish that the supplied scope was evaluated with no unsettled findings, `code` starts no further phase and reports the failure and the last `code`-owned commit to its caller.
+When the nested `review` call fails outside that authored result contract, `code` parks as failed and retains the control-plane error instead of reporting an authored review outcome.

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

@@ -1,20 +1,17 @@
-import { type XStatePlaybookRuntimeFactory, type XStatePlaybookRuntimeConstruction, type XStatePromptIdentity } from '@sublang/playbook/xstate-runtime';
-import { type CodingInput, type PlayerInput } from './code.fsm.js';
-import type { PlaybookHostConstructionCapabilities } from './playbook-captain.js';
-import type { CaptainCallOptions, CaptainResult, JsonValue, NormalizedError, PlayerCallOptions, PlaybookCallRequest, PlaybookCallResult, PlaybookCallStart, PlaybookControlReceipt, PlaybookControlView, PlaybookPendingCall, PlaybookPorts, PlaybookRunResult, PlaybookRuntime, PlaybookRuntimeFactory, PlaybookRuntimeSnapshot, PlaybookSession, PlaybookState, PlaybookStateValue, PlaybookTraceEvent, PlaybookTraceType, PlayerResult, PlayerSessionStore } from '@sublang/playbook/runtime';
-export type { CaptainCallOptions, CaptainResult, JsonValue, NormalizedError, PlayerCallOptions, PlaybookCallRequest, PlaybookCallResult, PlaybookCallStart, PlaybookControlReceipt, PlaybookControlView, PlaybookPendingCall, PlaybookPorts, PlaybookRunResult, PlaybookRuntime, PlaybookRuntimeFactory, PlaybookRuntimeSnapshot, PlaybookSession, PlaybookState, PlaybookStateValue, PlaybookTraceEvent, PlaybookTraceType, PlayerResult, PlayerSessionStore, };
-export type CodePlaybookOptions = CodingInput;
-export type CodePlaybookHostCapabilities = PlaybookHostConstructionCapabilities & XStatePlaybookRuntimeConstruction<CodePlaybookOptions, object>['hostCapabilities'];
-/**
- * Preserve authored Markdown quote markers around every line of relayed
- * runtime text. The generic composer preserves the marker itself; CODE's
- * override additionally keeps a multiline value inside that quote.
- */
-declare function composePlayerPrompt(input: PlayerInput, promptIdentity: XStatePromptIdentity, resuming?: boolean): string;
+import { type XStatePromptIdentity, type PlaybookPlayerInput, type XStatePlaybookRuntimeConstruction, type XStatePlaybookRuntimeFactory } from '@sublang/playbook/xstate-runtime';
+export type { PlayerResult, PlayerCallOptions, PlayerSessionStore, CaptainResult, CaptainCallOptions, JsonValue, NormalizedError, PlaybookCallRequest, PlaybookCallResult, PlaybookCallStart, PlaybookStateValue, PlaybookState, PlaybookPendingCall, PlaybookRunResult, PlaybookRuntime, PlaybookRuntimeFactory, PlaybookRuntimeSnapshot, PlaybookSession, PlaybookPorts, PlaybookTraceEvent, PlaybookTraceType, PlaybookControlReceipt, PlaybookControlView, } from '@sublang/playbook/runtime';
+export interface PlaybookRuntimeOptions {
+    readonly "runResults"?: string;
+}
+export type PlaybookHostCapabilities = XStatePlaybookRuntimeConstruction<PlaybookRuntimeOptions, {
+    readonly authority: object;
+}>['hostCapabilities'];
+export declare function validateOptions(value: unknown): PlaybookRuntimeOptions;
 export declare const _internal: {
-    composePlayerPrompt: typeof composePlayerPrompt;
-    VERBATIM_PAYLOAD_FIELDS: ReadonlySet<string>;
+    composePlayerPrompt: (input: PlaybookPlayerInput, promptIdentity: XStatePromptIdentity, resuming?: boolean) => string;
+    RESUMABLE_STATE_IDS: ReadonlySet<string>;
     UNFINISHED_FINAL_STATE_IDS: ReadonlySet<string>;
+    VERBATIM_PAYLOAD_FIELDS: ReadonlySet<string>;
 };
-declare const createPlaybookRuntime: XStatePlaybookRuntimeFactory<XStatePlaybookRuntimeConstruction<CodePlaybookOptions, CodePlaybookHostCapabilities>, 3>;
+declare const createPlaybookRuntime: XStatePlaybookRuntimeFactory<XStatePlaybookRuntimeConstruction<PlaybookRuntimeOptions, PlaybookHostCapabilities>, 3>;
 export default createPlaybookRuntime;

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

@@ -1,177 +1,196 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
-//
-// Generated by slc/link.md (FSM-to-Runtime linker).
-// Source FSM:    ./code.fsm.ts
-// Role metadata: Coder→coder (canonical local role)
-// Boss event:    deterministic START_CODE entry; exact Boss text becomes
-//                callerInput; pending Coder questions retain BOSS_REPLY
-// Adjudication:  LLM judge per player state; coderOutput is carried verbatim;
-//                the first phase decides among four semantic outcomes
-// Nested call:   literal review target through the shared bridge
-// Compat:        artifact schema 3 / runtime ABI 1
-import { createXStatePlaybookRuntime, composePlayerContinuation, snapshotJsonValue, } from '@sublang/playbook/xstate-runtime';
-import { codingMachine, } from './code.fsm.js';
-const OPTION_KEYS = new Set(['runResults']);
-const PLACEHOLDER = /<(#|[A-Za-z_$][A-Za-z0-9_$-]*)>/g;
-const VERBATIM_PAYLOAD_FIELDS = new Set([
-    'coderOutput',
+// Generated by slc/materialize-link.mjs; governed by the complete slc/link.md.
+// FSM: "./code.fsm.js"; export: codeMachine; strategies: shared defaults with labelled string relays and nested actors.
+import { codeMachine as machine } from "./code.fsm.js";
+import { createXStatePlaybookRuntime, snapshotJsonValue, composePlayerContinuation, } from '@sublang/playbook/xstate-runtime';
+const OPTION_SCHEMA = {
+    "runResults": {
+        "type": "string",
+        "required": false
+    }
+};
+const INPUT_MAPPING = {
+    "runResults": "runResults"
+};
+const RESUMABLE_STATE_IDS = new Set([
+    "firstPhase",
+    "irTaskPhase"
 ]);
 const UNFINISHED_FINAL_STATE_IDS = new Set([
-    'reportedReviewFailure',
+    "reviewFailed"
 ]);
-function snapshotCodeOptions(value) {
-    const captured = snapshotJsonValue(value, 'CODE runtime options');
-    if (captured === null ||
-        typeof captured !== 'object' ||
-        Array.isArray(captured)) {
-        throw new TypeError('CODE runtime options must be an object');
+const VERBATIM_PAYLOAD_FIELDS = new Set([
+    "coderOutput"
+]);
+export function validateOptions(value) {
+    const captured = snapshotJsonValue(value === undefined ? {} : value, "CODE runtime options");
+    if (captured === null || typeof captured !== 'object' || Array.isArray(captured)) {
+        throw new TypeError("CODE runtime options must be an object");
+    }
+    const fields = captured;
+    for (const key of Object.keys(captured)) {
+        if (!Object.hasOwn(OPTION_SCHEMA, key))
+            throw new TypeError("CODE runtime options." + key + ' is not declared');
     }
-    const record = captured;
-    for (const [key, option] of Object.entries(record)) {
-        if (!OPTION_KEYS.has(key)) {
-            throw new TypeError(`CODE runtime options.${key} is not declared`);
+    for (const [key, schema] of Object.entries(OPTION_SCHEMA)) {
+        if (!Object.hasOwn(captured, key)) {
+            if (schema.required)
+                throw new TypeError("CODE runtime options." + key + ' is required');
         }
-        if (typeof option !== 'string') {
-            throw new TypeError(`CODE runtime options.${key} must be a string`);
+        else if (typeof fields[key] !== schema.type || (schema.type === 'number' && !Number.isFinite(fields[key]))) {
+            throw new TypeError("CODE runtime options." + key + ' must be a ' + schema.type);
         }
     }
     return captured;
 }
-function placeholderField(token) {
-    if (token === '#')
-        return 'irNumber';
-    return token.replace(/-([A-Za-z0-9_$])/g, (_match, next) => next.toUpperCase());
-}
-function quoteContinuation(value) {
-    return value.replaceAll('\n', '\n> ');
-}
-/**
- * Preserve authored Markdown quote markers around every line of relayed
- * runtime text. The generic composer preserves the marker itself; CODE's
- * override additionally keeps a multiline value inside that quote.
- */
-function composePlayerPrompt(input, promptIdentity, resuming = false) {
+function renderPlayerPrompt(input, promptIdentity, resuming = false) {
     const fields = input;
-    const template = input.prompt
-        .split('\n')
-        .filter((line) => !(line === '> Run results: <run-results>' && input.runResults.length === 0))
-        .join('\n');
-    const body = template.replace(PLACEHOLDER, (match, token, offset, source) => {
-        const value = token === 'coder-llm'
-            ? promptIdentity('coder')
-            : fields[placeholderField(token)];
-        if (typeof value !== 'string')
-            return match;
-        const lineStart = source.lastIndexOf('\n', offset - 1) + 1;
-        const literal = source.slice(lineStart, offset);
-        return literal.startsWith('> ') ? quoteContinuation(value) : value;
-    });
+    const mapping = {};
+    const identities = { "coder-llm": "coder" };
+    const omitted = new Set(["> Run results: <run-results>"]);
+    const fieldFor = (token) => Object.hasOwn(mapping, token) ? mapping[token] : (token === '#' ? 'irNumber' : token.replace(/-([A-Za-z0-9_$])/g, (_match, next) => next.toUpperCase()));
+    const parts = input.prompt.split(/(\r?\n)/);
+    let body = '';
+    for (let index = 0; index < parts.length; index += 2) {
+        const line = parts[index];
+        if (omitted.has(line)) {
+            const token = /<(#|[A-Za-z_$][A-Za-z0-9_$-]*)>$/.exec(line)[1];
+            if (fields[fieldFor(token)] === '')
+                continue;
+        }
+        body += line.replace(/<(#|[A-Za-z_$][A-Za-z0-9_$-]*)>/g, (match, token) => {
+            const value = Object.hasOwn(identities, token) ? promptIdentity(identities[token]) : fields[fieldFor(token)];
+            if (typeof value !== 'string')
+                return match;
+            return line.startsWith('> ') ? value.replace(/\r?\n/g, (ending) => ending + '> ') : value;
+        }) + (parts[index + 1] ?? '');
+    }
     return composePlayerContinuation(input, body, resuming);
 }
-export const _internal = {
-    composePlayerPrompt,
-    VERBATIM_PAYLOAD_FIELDS,
-    UNFINISHED_FINAL_STATE_IDS,
-};
+const composePlayerPrompt = (input, promptIdentity, resuming) => renderPlayerPrompt(input, promptIdentity, resuming);
 const runtimeSpec = {
-    label: 'CODE',
-    // DR-022 / slc/link.md: the declaration carries the value current at link
-    // time — a literal, never the loading engine's RUNTIME_ABI self-report,
-    // which would follow whatever engine loads the module and make the
-    // factory's skew check compare that engine with itself.
-    compat: { artifactSchema: 3, runtimeAbi: 1 },
-    snapshotOptions: snapshotCodeOptions,
-    entryEvent: {
-        type: 'START_CODE',
-        textField: 'callerInput',
-        // `startCoding` copies the entry text here, so the failure-state retry
-        // reads it back from the persisted machine snapshot and survives a
-        // continued session (DR-034).
-        contextField: 'callerInput',
-    },
-    roleStates: {
-        runFirstPhase: {
-            role: 'coder',
-            label: 'Coder is running the first coding phase: a direct implementation, a new intent record, or an existing intent-record task.',
+    composePlayerPrompt,
+    ...{
+        "label": "CODE",
+        "compat": {
+            "artifactSchema": 3,
+            "runtimeAbi": 1
         },
-        runIrTask: {
-            role: 'coder',
-            label: 'Coder is implementing exactly one unfinished intent-record task.',
+        "entryEvent": {
+            "type": "START_CODE",
+            "textField": "callerInput",
+            "contextField": "callerInput"
         },
-    },
-    outcomeAuthority: {
-        governedPlayerStates: {
-            runFirstPhase: {
-                directCommit: {
-                    fields: {
-                        coderOutput: 'presentation',
-                        latestCommit: 'effect',
+        "bossEvents": [],
+        "roleStates": {
+            "firstPhase": {
+                "role": "coder",
+                "label": "Coder runs the first coding phase: a direct implementation, a new IR, or the next task of an existing IR."
+            },
+            "irTaskPhase": {
+                "role": "coder",
+                "label": "Coder implements the identified IR's next unfinished task."
+            }
+        },
+        "outcomeAuthority": {
+            "governedPlayerStates": {
+                "firstPhase": {
+                    "directCommit": {
+                        "fields": {
+                            "coderOutput": "presentation",
+                            "latestCommit": "effect"
+                        },
+                        "repositoryDisposition": "one-descendant-commit"
                     },
-                    repositoryDisposition: 'one-descendant-commit',
-                },
-                irCommit: {
-                    fields: {
-                        coderOutput: 'presentation',
-                        latestCommit: 'effect',
-                        irNumber: 'semantic',
+                    "irCommit": {
+                        "fields": {
+                            "coderOutput": "presentation",
+                            "latestCommit": "effect",
+                            "irNumber": "semantic"
+                        },
+                        "repositoryDisposition": "one-descendant-commit"
                     },
-                    repositoryDisposition: 'one-descendant-commit',
-                },
-                moreTasks: {
-                    fields: {
-                        coderOutput: 'presentation',
-                        latestCommit: 'effect',
-                        irNumber: 'semantic',
-                        irTask: 'semantic',
+                    "moreTasks": {
+                        "fields": {
+                            "coderOutput": "presentation",
+                            "latestCommit": "effect",
+                            "irNumber": "semantic",
+                            "irTask": "semantic"
+                        },
+                        "repositoryDisposition": "one-descendant-commit"
                     },
-                    repositoryDisposition: 'one-descendant-commit',
-                },
-                finalTask: {
-                    fields: {
-                        coderOutput: 'presentation',
-                        latestCommit: 'effect',
-                        irNumber: 'semantic',
-                        irTask: 'semantic',
+                    "finalTask": {
+                        "fields": {
+                            "coderOutput": "presentation",
+                            "latestCommit": "effect",
+                            "irNumber": "semantic",
+                            "irTask": "semantic"
+                        },
+                        "repositoryDisposition": "one-descendant-commit"
                     },
-                    repositoryDisposition: 'one-descendant-commit',
-                },
-                needsBossReply: {
-                    fields: { question: 'presentation' },
-                    repositoryDisposition: 'deferred',
+                    "needsBossReply": {
+                        "fields": {
+                            "question": "presentation"
+                        },
+                        "repositoryDisposition": "deferred"
+                    }
                 },
-            },
-            runIrTask: {
-                moreTasks: {
-                    fields: {
-                        coderOutput: 'presentation',
-                        latestCommit: 'effect',
-                        irNumber: 'semantic',
-                        irTask: 'semantic',
+                "irTaskPhase": {
+                    "moreTasks": {
+                        "fields": {
+                            "coderOutput": "presentation",
+                            "latestCommit": "effect",
+                            "irNumber": "semantic",
+                            "irTask": "semantic"
+                        },
+                        "repositoryDisposition": "one-descendant-commit"
                     },
-                    repositoryDisposition: 'one-descendant-commit',
-                },
-                finalTask: {
-                    fields: {
-                        coderOutput: 'presentation',
-                        latestCommit: 'effect',
-                        irNumber: 'semantic',
-                        irTask: 'semantic',
+                    "finalTask": {
+                        "fields": {
+                            "coderOutput": "presentation",
+                            "latestCommit": "effect",
+                            "irNumber": "semantic",
+                            "irTask": "semantic"
+                        },
+                        "repositoryDisposition": "one-descendant-commit"
                     },
-                    repositoryDisposition: 'one-descendant-commit',
-                },
-                needsBossReply: {
-                    fields: { question: 'presentation' },
-                    repositoryDisposition: 'deferred',
-                },
-            },
+                    "needsBossReply": {
+                        "fields": {
+                            "question": "presentation"
+                        },
+                        "repositoryDisposition": "deferred"
+                    }
+                }
+            }
         },
+        "placeholderFields": {},
+        "transitionEventFields": [
+            "callerInput",
+            "runResults",
+            "targetId",
+            "answer",
+            "questionId"
+        ],
+        "controlContextFields": [
+            "phaseOutcome",
+            "irNumber",
+            "codeCommit",
+            "evaluatedRevision"
+        ]
     },
-    composePlayerPrompt: (input, promptIdentity, resuming) => composePlayerPrompt(input, promptIdentity, resuming),
+    snapshotOptions: validateOptions,
+    machineInput: (options) => Object.fromEntries(Object.entries(INPUT_MAPPING).filter(([, key]) => options[key] !== undefined)
+        .map(([field, key]) => [field, options[key]])),
     verbatimPayloadFields: VERBATIM_PAYLOAD_FIELDS,
-    controlContextFields: ['phase'],
+    resumableStateIds: RESUMABLE_STATE_IDS,
     unfinishedFinalStateIds: UNFINISHED_FINAL_STATE_IDS,
-    transitionEventFields: ['callerInput', 'answer', 'questionId'],
 };
-const createPlaybookRuntime = createXStatePlaybookRuntime(codingMachine, runtimeSpec);
+export const _internal = {
+    composePlayerPrompt,
+    RESUMABLE_STATE_IDS,
+    UNFINISHED_FINAL_STATE_IDS,
+    VERBATIM_PAYLOAD_FIELDS,
+};
+const createPlaybookRuntime = createXStatePlaybookRuntime(machine, runtimeSpec);
 export default createPlaybookRuntime;