@sublang/playbook 15.0.0 → 16.0.0

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

@@ -1,26 +1,30 @@
 <!-- SPDX-License-Identifier: Apache-2.0 -->
 <!-- SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai> -->
 
-# DEV: Development Planning Workflow
+# Dev
 
 Roles:
 
 - Analyst
 
+The caller supplies a development request including any desired outcome, scope, and context.
+
 `dev` is an optional repository-aware planner for a development request that needs more analysis before choosing a development path.
 It coordinates existing playbooks and owns no repository commit itself.
-Analyst chooses the path and states why in a short planning note; analysis, design, and implementation belong to the playbooks `dev` calls, and a question to Boss serves only the choice of path.
 
-## Analyst
+## Planning
 
 ### DEV-1
 
+Analyst chooses the path and states why in a short planning note; analysis, design, and implementation belong to the playbooks `dev` calls, and a question to Boss serves only the choice of path.
+The planning result has six semantic outcomes: needs Boss reply, discussion complete, code, decide then code, code via pull request, and decide then code via pull request.
+Each outcome requires affirmative support in Analyst's result; absence of a reason to choose another outcome is not support.
+No outcome depends on a fixed presentation format of Analyst's reply.
+`dev` shall act on the accepted outcome itself and shall not return to the session Captain for another routing decision.
+For needs Boss reply, `dev` shall use the standard Boss-question suspension with Analyst's complete response; the session Captain shall present that response to Boss and, after Boss replies, resume `dev` with the answer in the same Analyst conversation, including the previous question only when that conversation must start fresh.
+
 At the start of `dev` and after each Boss reply, Captain shall relay the development request, relevant discussion context, and any relevant run results to Analyst in quotes (`>`), along with the planning instruction:
 
-> > Original request: <development-request>
-> > Prior discussion: <discussion-context>
-> > Run results: <run-results>
->
 > Plan which playbooks run for this request; the playbooks do the work.
 > Read the request, then the specs and the repository only as far as choosing the path requires.
 > Do not change files or commit while planning or discussing the request.
@@ -39,55 +43,52 @@ At the start of `dev` and after each Boss reply, Captain shall relay the develop
 > A question or exploratory discussion is not by itself authorization to create a durable decision or implement changes.
 > Do not choose `decide then code` merely because the work is large, nor `code` merely because it is small.
 > Consult @specs/map.md for relevant context and @specs/meta.md for spec requirements, if needed.
+>
+> > Original request: <development-request>
+> > Prior discussion: <discussion-context>
+> > Run results: <run-results>
 
 Results:
-- `discussionComplete`: Analyst concluded the discussion after a Boss reply, with no repository work to follow.
-- `code`: Analyst chose `code`: the existing decisions and spec items settle how the work is done. Output shall include `planningResult: <verbatim final text>`.
-- `decideThenCode`: Analyst chose `decide then code`: the work turns on a point the specs leave open or contradict. Output shall include `planningResult: <verbatim final text>`.
-- `codeViaPullRequest`: Analyst chose `code via pull request`: the existing decisions settle the work, and the request names a GitHub issue or explicitly asks for pull-request delivery. Output shall include `planningResult: <verbatim final text>`.
-- `decideThenCodeViaPullRequest`: Analyst chose `decide then code via pull request`: the work turns on a point the specs leave open or contradict, and the request names a GitHub issue or explicitly asks for pull-request delivery. Output shall include `planningResult: <verbatim final text>`.
-
-Workflow outcomes:
-- The planning result has six semantic outcomes: needs Boss reply, discussion complete, code, decide then code, code via pull request, and decide then code via pull request.
-- Each outcome requires affirmative support in Analyst's result; absence of a reason to choose another outcome is not support, and no outcome depends on a fixed presentation format of Analyst's reply.
-- Needs Boss reply uses the standard Boss-question suspension with Analyst's complete response; after Boss replies, `dev` resumes with the answer in the same Analyst conversation; the previous question is included only when that conversation must start fresh.
-- Discussion complete is available only after a Boss reply, when that reply settles that no repository work should follow; it completes `dev` without a child call or repository change.
-- `dev` acts on the accepted outcome itself and does not return to the session Captain for another routing decision.
+- `discussionComplete`: After a Boss reply that settles that no repository work should follow, Analyst concluded the discussion; dev completes without a child call or repository change.
+- `code`: Analyst chose the code path because the existing decisions and spec items settle how the work is done. Output shall include `planningResult: <verbatim final text>`.
+- `decideThenCode`: Analyst chose the decide then code path because the work turns on a rule, concept, term, shape, or trade-off the specs leave open or contradict. Output shall include `planningResult: <verbatim final text>`.
+- `codeViaPullRequest`: Analyst chose the code via pull request path because the existing decisions and spec items settle how the work is done and the request names a GitHub issue or explicitly asks for pull-request delivery. Output shall include `planningResult: <verbatim final text>`.
+- `decideThenCodeViaPullRequest`: Analyst chose the decide then code via pull request path because the work turns on a rule, concept, term, shape, or trade-off the specs leave open or contradict and the request names a GitHub issue or explicitly asks for pull-request delivery. Output shall include `planningResult: <verbatim final text>`.
 
-## Nested development paths
+## Development paths
 
 ### DEV-2
 
-When the accepted planning result selects `code`, or `branch` succeeds for `code via pull request`, Captain shall call playbook `code`:
+When the accepted planning result is code, or when `branch` has succeeded on the code via pull request path, Captain shall call playbook `code`:
 
 > > Original request: <development-request>
 > > Prior discussion: <discussion-context>
 > > Planning result: <planning-result>
 
-Workflow outcomes:
-- On a plain path, `code` success completes `dev` with the successful `code` result.
-- On a pull-request path, `code` success provides the exact last `code`-owned commit and the exact final evaluated repository revision from `code`'s canonical structured result and continues with the `pr` call.
-- An authored `code` abort or failure, or a terminal `code` result that does not prove the success required for the selected path, terminates `dev` with that canonical result relayed and no later child call.
-- Any other nested-call error parks `dev` as failed and retains the control-plane error.
-- `dev` consumes commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.
+On the code path, `code` success completes `dev` with that successful `code` result; a plain request calls neither `branch` nor `pr`.
+On the code via pull request path, only after `code` succeeds shall `dev` call playbook `pr`.
+If `code` returns an authored abort or failure, or a terminal result that does not prove the success required for the selected path, `dev` shall start no later child and shall relay that canonical result.
+If the `code` call fails outside its authored result contract, `dev` shall park as failed and retain the control-plane error.
+`dev` shall consume commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.
 
 ### DEV-3
 
-When the accepted planning result selects `decide then code`, or `branch` succeeds for `decide then code via pull request`, Captain shall call playbook `decide`:
+When the accepted planning result is decide then code, or when `branch` has succeeded on the decide then code via pull request path, Captain shall call playbook `decide`:
 
 > > Original request: <development-request>
 > > Prior discussion: <discussion-context>
 > > Planning result: <planning-result>
 
-Workflow outcomes:
-- `decide` success provides the `decide`-owned commit and the exact evaluated repository revision from `decide`'s canonical structured result and continues with the `code` call.
-- An authored `decide` abort or failure, or a terminal `decide` result that does not prove that success, terminates `dev` with that canonical result relayed and no later child call.
-- Any other nested-call error parks `dev` as failed and retains the control-plane error.
-- `dev` does not separately call `review` for the design scope already reviewed by `decide`.
+Only after `decide` succeeds shall `dev` call playbook `code` with the `decide`-owned commit and exact evaluated repository revision from `decide`'s canonical structured result.
+`dev` shall not separately call `review` for the design scope already reviewed by `decide`.
+On the decide then code path, a plain request calls neither `branch` nor `pr`.
+If `decide` returns an authored abort or failure, or a terminal result that does not prove the success required for the selected path, `dev` shall start no later child and shall relay that canonical result.
+If the `decide` call fails outside its authored result contract, `dev` shall park as failed and retain the control-plane error.
+`dev` shall consume commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.
 
 ### DEV-4
 
-When `decide` succeeds, Captain shall call playbook `code`:
+When `decide` has succeeded on the decide then code path or the decide then code via pull request path, Captain shall call playbook `code`:
 
 > > Original request: <development-request>
 > > Prior discussion: <discussion-context>
@@ -95,32 +96,29 @@ When `decide` succeeds, Captain shall call playbook `code`:
 > > DECIDE commit: <decide-commit>
 > > Evaluated revision: <evaluated-revision>
 
-Workflow outcomes:
-- On a plain path, `code` success completes `dev` with the successful `code` result.
-- On a pull-request path, `code` success provides the exact last `code`-owned commit and the exact final evaluated repository revision from `code`'s canonical structured result and continues with the `pr` call.
-- An authored `code` abort or failure, or a terminal `code` result that does not prove the success required for the selected path, terminates `dev` with that canonical result relayed and no later child call.
-- Any other nested-call error parks `dev` as failed and retains the control-plane error.
-- `dev` consumes commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.
-
-## Pull-request delivery
+`dev` shall not separately call `review` for the design scope already reviewed by `decide`.
+On the decide then code path, `code` success completes `dev` with that successful `code` result; a plain request calls neither `branch` nor `pr`.
+On the decide then code via pull request path, only after `code` succeeds shall `dev` call playbook `pr`.
+If `code` returns an authored abort or failure, or a terminal result that does not prove the success required for the selected path, `dev` shall start no later child and shall relay that canonical result.
+If the `code` call fails outside its authored result contract, `dev` shall park as failed and retain the control-plane error.
+`dev` shall consume commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.
 
 ### DEV-5
 
-When the accepted planning result selects `code via pull request` or `decide then code via pull request`, Captain shall call playbook `branch`:
+When the accepted planning result is code via pull request or decide then code via pull request and no child call has started yet, Captain shall call playbook `branch`:
 
 > > Original request: <development-request>
 > > Prior discussion: <discussion-context>
 > > Planning result: <planning-result>
 
-Workflow outcomes:
-- `branch` success provides the exact branch name, the exact base revision, and the issue summary from `branch`'s canonical structured result and continues with the `code` call for code via pull request, or the `decide` call and then the `code` call for decide then code via pull request, each with the same input as its plain path.
-- An authored `branch` abort or failure, or a terminal `branch` result that does not prove that success, terminates `dev` with that canonical result relayed and no later child call.
-- Any other nested-call error parks `dev` as failed and retains the control-plane error.
-- A plain request calls neither `branch` nor `pr`.
+Only after `branch` succeeds shall `dev` continue with the `code` call for code via pull request, or the `decide` call and then the `code` call for decide then code via pull request, each with the same input as its plain path.
+If `branch` returns an authored abort or failure, or a terminal result that does not prove the success required for the selected path, `dev` shall start no later child and shall relay that canonical result; a `branch` failure ends `dev` under this rule.
+If the `branch` call fails outside its authored result contract, `dev` shall park as failed and retain the control-plane error.
+`dev` shall consume commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.
 
 ### DEV-6
 
-When `code` succeeds on a pull-request path, Captain shall call playbook `pr`:
+When `code` has succeeded on the code via pull request path or the decide then code via pull request path, Captain shall call playbook `pr`:
 
 > > Original request: <development-request>
 > > Issue summary: <issue-summary>
@@ -129,8 +127,8 @@ When `code` succeeds on a pull-request path, Captain shall call playbook `pr`:
 > > CODE commit: <last-code-commit>
 > > Evaluated revision: <final-evaluated-revision>
 
-Workflow outcomes:
-- `pr` success completes `dev` with the successful `pr` result.
-- An authored `pr` abort or failure, or a terminal `pr` result that does not prove the success required for the selected path, terminates `dev` with that canonical result relayed and no later child call.
-- Any other nested-call error parks `dev` as failed and retains the control-plane error.
-- `dev` consumes commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.
+The branch and base revision come from `branch`'s canonical structured result, and the last `code`-owned commit and exact final evaluated repository revision come from the successful `code` call's canonical structured result.
+`pr` success completes `dev` with that successful `pr` result.
+If `pr` returns an authored abort or failure, or a terminal result that does not prove the success required for the selected path, `dev` shall relay that canonical result; a `pr` failure ends `dev` under this rule.
+If the `pr` call fails outside its authored result contract, `dev` shall park as failed and retain the control-plane error.
+`dev` shall consume commit, revision, branch, and pull-request identities only from each child's canonical structured result, never from player prose.

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

@@ -1,14 +1,17 @@
-import { type PlaybookPlayerInput, type XStatePlaybookRuntimeFactory, type XStatePlaybookRuntimeConstruction } from '@sublang/playbook/xstate-runtime';
-import { type DevInput } from './dev.fsm.js';
-import type { PlaybookHostConstructionCapabilities } from '../code.playbook/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 DevPlaybookOptions = DevInput;
-export type DevPlaybookHostCapabilities = PlaybookHostConstructionCapabilities & XStatePlaybookRuntimeConstruction<DevPlaybookOptions, object>['hostCapabilities'];
+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: (input: PlaybookPlayerInput, _identity: import("@sublang/playbook/xstate-runtime").XStatePromptIdentity, resuming?: boolean) => string;
-    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<DevPlaybookOptions, DevPlaybookHostCapabilities>, 3>;
+declare const createPlaybookRuntime: XStatePlaybookRuntimeFactory<XStatePlaybookRuntimeConstruction<PlaybookRuntimeOptions, PlaybookHostCapabilities>, 3>;
 export default createPlaybookRuntime;

package/reference/sdlc/dev.playbook/dev.playbook.js

@@ -1,145 +1,153 @@
 // 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:    ./dev.fsm.ts
-// Role metadata: Analyst→analyst (canonical local role)
-// Boss event:    deterministic START_DEV entry; exact Boss text becomes
-//                developmentRequest; pending Analyst questions retain
-//                BOSS_REPLY
-// Adjudication:  LLM judge for the one Analyst state; planningResult is
-//                carried verbatim
-// Nested calls:  literal code, decide, branch, and pr targets through the
-//                shared bridge; branch, revision, commit, and pull-request
-//                identities enter only from canonical child results
-// Compat:        artifact schema 3 / runtime ABI 1
-import { createXStatePlaybookRuntime, composePlayerContinuation, snapshotJsonValue, } from '@sublang/playbook/xstate-runtime';
-import { devMachine, } from './dev.fsm.js';
-const OPTION_KEYS = new Set(['runResults']);
-const PLACEHOLDER = /<(#|[A-Za-z_$][A-Za-z0-9_$-]*)>/g;
-const VERBATIM_PAYLOAD_FIELDS = new Set([
-    'planningResult',
+// Generated by slc/materialize-link.mjs; governed by the complete slc/link.md.
+// FSM: "./dev.fsm.js"; export: devMachine; strategies: shared defaults with labelled string relays and nested actors.
+import { devMachine as machine } from "./dev.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([
+    "planAnalysis"
 ]);
 const UNFINISHED_FINAL_STATE_IDS = new Set([
-    'reportedChildFailure',
+    "reportedChildFailure"
 ]);
-function snapshotDevOptions(value) {
-    const captured = snapshotJsonValue(value, 'DEV runtime options');
-    if (captured === null ||
-        typeof captured !== 'object' ||
-        Array.isArray(captured)) {
-        throw new TypeError('DEV runtime options must be an object');
+const VERBATIM_PAYLOAD_FIELDS = new Set([
+    "planningResult"
+]);
+export function validateOptions(value) {
+    const captured = snapshotJsonValue(value === undefined ? {} : value, "DEV runtime options");
+    if (captured === null || typeof captured !== 'object' || Array.isArray(captured)) {
+        throw new TypeError("DEV 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("DEV 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(`DEV 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("DEV runtime options." + key + ' is required');
         }
-        if (typeof option !== 'string') {
-            throw new TypeError(`DEV runtime options.${key} must be a string`);
+        else if (typeof fields[key] !== schema.type || (schema.type === 'number' && !Number.isFinite(fields[key]))) {
+            throw new TypeError("DEV 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 quotedContinuation(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; DEV's
- * override additionally keeps a multiline value inside that quote and drops
- * the optional relays that have no value yet.
- */
-function composePlayerPrompt(input, resuming = false) {
+function renderPlayerPrompt(input, promptIdentity, resuming = false) {
     const fields = input;
-    const template = input.prompt
-        .split('\n')
-        .filter((line) => !(line === '> Prior discussion: <discussion-context>' &&
-        input.discussionContext.length === 0) &&
-        !(line === '> Run results: <run-results>' && input.runResults.length === 0))
-        .join('\n');
-    const body = template.replace(PLACEHOLDER, (match, token, offset, source) => {
-        const value = 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('> ') ? quotedContinuation(value) : value;
-    });
+    const mapping = {};
+    const identities = {};
+    const omitted = new Set(["> Prior discussion: <discussion-context>", "> 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);
 }
+const composePlayerPrompt = (input, promptIdentity, resuming) => renderPlayerPrompt(input, promptIdentity, resuming);
 const runtimeSpec = {
-    label: 'DEV',
-    // 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: snapshotDevOptions,
-    entryEvent: {
-        type: 'START_DEV',
-        textField: 'developmentRequest',
-        // `startDev` 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: 'developmentRequest',
-    },
-    roleStates: {
-        planAnalysis: {
-            role: 'analyst',
-            label: 'Analyst is choosing the development path.',
+    composePlayerPrompt,
+    ...{
+        "label": "DEV",
+        "compat": {
+            "artifactSchema": 3,
+            "runtimeAbi": 1
         },
-    },
-    // DR-044: DEV owns no repository commit — every Analyst outcome is
-    // governed with the `unchanged` repository disposition, so planning that
-    // mutates the repository fails authority instead of being adopted.
-    outcomeAuthority: {
-        governedPlayerStates: {
-            planAnalysis: {
-                discussionComplete: {
-                    fields: {},
-                    repositoryDisposition: 'unchanged',
-                },
-                code: {
-                    fields: { planningResult: 'presentation' },
-                    repositoryDisposition: 'unchanged',
-                },
-                decideThenCode: {
-                    fields: { planningResult: 'presentation' },
-                    repositoryDisposition: 'unchanged',
-                },
-                // DR-050: reading a GitHub issue during planning is not an effect, so
-                // the two pull-request outcomes stay `unchanged` like the plain ones.
-                codeViaPullRequest: {
-                    fields: { planningResult: 'presentation' },
-                    repositoryDisposition: 'unchanged',
-                },
-                decideThenCodeViaPullRequest: {
-                    fields: { planningResult: 'presentation' },
-                    repositoryDisposition: 'unchanged',
-                },
-                needsBossReply: {
-                    fields: { question: 'presentation' },
-                    repositoryDisposition: 'unchanged',
-                },
-            },
+        "entryEvent": {
+            "type": "START_DEV",
+            "textField": "developmentRequest",
+            "contextField": "developmentRequest"
         },
+        "bossEvents": [],
+        "roleStates": {
+            "planAnalysis": {
+                "role": "analyst",
+                "label": "Analyst chooses the development path in a short planning note."
+            }
+        },
+        "outcomeAuthority": {
+            "governedPlayerStates": {
+                "planAnalysis": {
+                    "discussionComplete": {
+                        "fields": {},
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "code": {
+                        "fields": {
+                            "planningResult": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "decideThenCode": {
+                        "fields": {
+                            "planningResult": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "codeViaPullRequest": {
+                        "fields": {
+                            "planningResult": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "decideThenCodeViaPullRequest": {
+                        "fields": {
+                            "planningResult": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "needsBossReply": {
+                        "fields": {
+                            "question": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    }
+                }
+            }
+        },
+        "placeholderFields": {},
+        "transitionEventFields": [
+            "developmentRequest",
+            "answer",
+            "questionId"
+        ],
+        "controlContextFields": []
     },
-    composePlayerPrompt: (input, _identity, resuming) => composePlayerPrompt(input, 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: [],
+    resumableStateIds: RESUMABLE_STATE_IDS,
     unfinishedFinalStateIds: UNFINISHED_FINAL_STATE_IDS,
-    transitionEventFields: ['developmentRequest', 'answer', 'questionId'],
 };
 export const _internal = {
-    composePlayerPrompt: runtimeSpec.composePlayerPrompt,
-    VERBATIM_PAYLOAD_FIELDS,
+    composePlayerPrompt,
+    RESUMABLE_STATE_IDS,
     UNFINISHED_FINAL_STATE_IDS,
+    VERBATIM_PAYLOAD_FIELDS,
 };
-const createPlaybookRuntime = createXStatePlaybookRuntime(devMachine, runtimeSpec);
+const createPlaybookRuntime = createXStatePlaybookRuntime(machine, runtimeSpec);
 export default createPlaybookRuntime;