@sublang/playbook 15.0.0 → 16.0.0

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

@@ -1,28 +1,23 @@
 <!-- SPDX-License-Identifier: Apache-2.0 -->
 <!-- SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai> -->
 
-# PR: Pull-Request Delivery Workflow
+# PR
 
 Roles:
 
 - Coder
 
-The caller supplies the original request including the issue it names, if any; the issue summary; the branch to deliver and the base revision it was created from; the last `code`-owned commit and the exact evaluated repository revision; and optional relevant context.
-`pr` delivers a reviewed branch into the repository default branch through a GitHub pull request: it publishes the branch, waits for the pull request's checks, fixes red checks through playbook `code` no more than once, and merges.
-It changes no files and owns no repository commit; the one fix it may request is owned by `code`.
-The check waits, the fix publication, the merge, and the local update are mechanical steps: each runs one fixed command whose exit status alone decides its two outcomes, reads no conversation, and produces no prose.
-`gh` infers the pull request from the checked-out branch, which the run does not own: the nested `code` call suspends across Boss turns, so the checkout can change before the fix is published or the merge runs.
-The two steps that act on the pull request itself therefore carry one runtime value — the pull request `pr` published — and refuse unless the checkout still infers exactly it.
-That identity is reported text, so it binds as a single-quoted shell literal: the command compares it as data and never executes it as shell syntax.
-
-## Coder
+## Workflow
 
 ### PR-1
 
+The caller supplies the original request, including the issue it names, if any; the issue summary; the branch to deliver and the base revision it was created from; the last `code`-owned commit and the exact evaluated repository revision; and optional relevant context.
+`pr` delivers a reviewed branch into the repository default branch through a GitHub pull request; it changes no files and owns no repository commit.
+Each outcome requires affirmative support in Coder's result, and no outcome depends on a fixed presentation format of Coder's reply.
+Every outcome keeps the repository exact: pushing a branch and opening a pull request change neither HEAD's commit nor the working tree.
+
 When the caller gives its input, Captain shall relay the complete caller input in quotes (`>`) to Coder, along with the following instruction:
 
-> > Original request: <caller-input>
->
 > Publish the branch and open its pull request without changing any file or making any commit.
 > Confirm that the working tree is clean and that the checked-out branch is the branch to deliver, not the repository default branch.
 > Push the branch to the repository's GitHub remote with its upstream set; never force-push.
@@ -30,21 +25,17 @@ When the caller gives its input, Captain shall relay the complete caller input i
 > Give the pull request a title naming the change and a body with a summary of what changed and why from the base revision to the last commit, the verification the commits report, and a `Closes #N` line for issue number N when the request names one.
 > Report the pull request number and URL exactly.
 > If the working tree is not clean, the checked-out branch is wrong, the push is rejected, or the pull request cannot be opened, open nothing further and report the failure with its reason.
+>
+> > Original request: <caller-input>
 
 Results:
-- `opened`: Coder pushed the branch with its upstream set and reported the open pull request for it. Output shall include `pullRequest: <pull request number>` and `pullRequestUrl: <pull request URL>`.
-- `notPublished`: Coder reported that the branch could not be published or its pull request could not be opened, with the reason. Output shall include `coderOutput: <verbatim final text>`.
-
-Workflow outcomes:
-- The result has two semantic outcomes: opened and not published.
-- Each outcome requires affirmative support in Coder's result, and no outcome depends on a fixed presentation format of Coder's reply.
-- Every outcome keeps the repository exact: pushing a branch and opening a pull request change neither HEAD's commit nor the working tree.
-- For not published, `pr` fails and reports Coder's complete result with its reason to its caller.
-
-## Checks, the one fix, and the merge
+- `opened`: Coder's result affirmatively supports that the pull request is open. Output shall include `pullRequest: <exact pull request number as reported>` and `pullRequestUrl: <exact pull request URL as reported>`.
+- `notPublished`: Coder's result affirmatively supports that the branch or its pull request was not published; the workflow fails and returns Coder's complete result with its reason to its caller. Output shall include `coderOutput: <verbatim final text>`.
 
 ### PR-2
 
+The check wait is a mechanical step: it runs one fixed command whose exit status alone decides its two outcomes, reads no conversation, and produces no prose.
+
 When the pull request is open and no fix has been attempted, Captain shall run:
 
 > n=0
@@ -56,30 +47,32 @@ When the pull request is open and no fix has been attempted, Captain shall run:
 > gh pr checks --watch --fail-fast >/dev/null 2>&1
 
 Results:
-- `checksPassed`: The command exited with status zero: the pull request's checks passed, or the repository still reported no checks after a brief wait for them to register.
-- `checksFailed`: The command exited with a nonzero status: the pull request's checks failed.
-
-Workflow outcomes:
-- The wait has exactly two outcomes decided by the command's exit status alone: checks passed on status zero and checks failed otherwise.
-- A pull request whose repository still reports no checks after a brief wait for them to register counts as passed.
-- Checks passed continues with the merge; checks failed continues with the one `code` fix attempt.
+- `checksPassed`: The command exited with status zero: the checks passed; a pull request whose repository still reports no checks after a brief wait for them to register counts as passed.
+- `checksFailed`: The command exited with a nonzero status: the checks failed.
 
 ### PR-3
 
+`pr` makes no more than one fix attempt, and the one fix it may request is owned by `code`.
+The call input carries the original request, the pull request, and the coding request in quotes (`>`).
+
 When the checks fail before any fix attempt, Captain shall call playbook `code`:
 
 > > Original request: <caller-input>
 > > Pull request: <pull-request-url>
 > > Coding request: The pull request's checks are red on the checked-out branch. Inspect the failing checks with `gh pr checks` and `gh run view --log-failed`, fix their cause on this branch with a minimal change, and make the checks pass.
 
-Workflow outcomes:
-- `pr` makes no more than one fix attempt.
-- Only after `code` succeeds does `pr` publish the fix and wait for the checks again.
-- An authored `code` abort or failure, or a terminal `code` result that does not prove its success, terminates `pr` with that canonical result relayed and the pull request left open.
-- Any other nested-call error parks `pr` as failed and retains the control-plane error.
+Only after `code` succeeds shall `pr` publish the fix and wait for the checks again.
+When `code` returns an authored abort or failure, or a terminal result that does not prove its success, `pr` shall fail relaying that canonical result and shall leave the pull request open.
+When the nested `code` call fails outside that authored result contract, `pr` shall park as failed and retain the control-plane error instead of reporting an authored outcome.
 
 ### PR-4
 
+The fix publication is a mechanical step: it runs one fixed command whose exit status alone decides its two outcomes, reads no conversation, and produces no prose.
+`gh` infers the pull request from the checked-out branch, which the run does not own: the nested `code` call suspends across Boss turns, so the checkout can change before the fix is published.
+This step therefore carries one runtime value — the pull request `pr` published — and refuses unless the checkout still infers exactly it.
+That identity is reported text, so it binds as a single-quoted shell literal: the command compares it as data and never executes it as shell syntax.
+The command pushes nothing until the checked-out branch infers the pull request `pr` published, so a checkout that changed while `code` ran publishes to no other branch.
+
 When `code` succeeds, Captain shall run:
 
 > [ "$(gh pr view --json url --jq .url)" = '<pull-request-url>' ] || exit 1
@@ -92,16 +85,13 @@ When `code` succeeds, Captain shall run:
 > done
 
 Results:
-- `fixPublished`: The command exited with status zero: the fix is pushed and the pull request's head is the pushed commit.
-- `fixNotPublished`: The command exited with a nonzero status: the checkout no longer infers the published pull request, the push was rejected, or the pull request's head did not advance to the pushed commit.
-
-Workflow outcomes:
-- The publication has exactly two outcomes decided by the exit status alone: fix published on status zero, once the pull request's head is the pushed commit, and fix not published otherwise.
-- The command pushes nothing until the checked-out branch infers the pull request `pr` published, so a checkout that changed while `code` ran publishes to no other branch.
-- Fix not published is an authored failure that leaves the pull request open.
+- `fixPublished`: The command exited with status zero, once the pull request's head is the pushed commit: the fix is published.
+- `fixNotPublished`: The command exited with a nonzero status: the fix is not published, an authored failure of the workflow that leaves the pull request open.
 
 ### PR-5
 
+The second check wait is a mechanical step: it runs one fixed command whose exit status alone decides its two outcomes, reads no conversation, and produces no prose.
+
 When the fix is published, Captain shall run:
 
 > n=0
@@ -113,15 +103,19 @@ When the fix is published, Captain shall run:
 > gh pr checks --watch --fail-fast >/dev/null 2>&1
 
 Results:
-- `checksPassed`: The command exited with status zero: the pull request's checks passed after the fix, or the repository still reported no checks after a brief wait for them to register.
-- `checksStillFailing`: The command exited with a nonzero status: the pull request's checks are still failing after the one fix attempt.
-
-Workflow outcomes:
-- This wait has exactly two outcomes decided by the exit status alone: checks passed on status zero and checks still failing otherwise.
-- Checks still failing is an authored failure that leaves the pull request open; there is no second fix attempt.
+- `checksPassed`: The command exited with status zero: the checks passed.
+- `checksStillFailing`: The command exited with a nonzero status: the checks are still failing, an authored failure of the workflow that leaves the pull request open; there is no second fix attempt.
 
 ### PR-6
 
+The merge is a mechanical step: it runs one fixed command whose exit status alone decides its two outcomes, reads no conversation, and produces no prose.
+`gh` infers the pull request from the checked-out branch, which the run does not own: the nested `code` call suspends across Boss turns, so the checkout can change before the merge runs.
+This step therefore carries one runtime value — the pull request `pr` published — and refuses unless the checkout still infers exactly it.
+That identity is reported text, so it binds as a single-quoted shell literal: the command compares it as data and never executes it as shell syntax.
+The merge creates a merge commit on the repository default branch, requests deletion of the remote and local branch, and checks out the local default branch; GitHub closes the linked issue on merge.
+The command requires the inferred pull request to be the one `pr` published and to target the repository default branch before the irreversible merge, and confirms that same pull request's merged state and the default-branch checkout after the merge command succeeds; a queued pull request is not a merged result.
+No outcome claims a branch was deleted, because `gh` skips the remote deletion for a pull request from another repository or one already merged and exits zero anyway.
+
 When the checks pass, before or after the one fix attempt, Captain shall run:
 
 > pr=$(gh pr view --json url --jq .url) || exit 1
@@ -134,30 +128,20 @@ When the checks pass, before or after the one fix attempt, Captain shall run:
 > [ "$(git branch --show-current)" = "$base" ]
 
 Results:
-- `merged`: The command exited with status zero: the pull request targeted the repository default branch and is merged into it with a merge commit, deletion of the remote and local branch was requested, and the local default branch is checked out.
-- `mergeRefused`: The command exited with a nonzero status: the checkout no longer infers the published pull request, the pull request does not target the repository default branch, GitHub refused the merge, its merged state could not be confirmed, or the local switch to the default branch or the branch deletion failed.
-
-Workflow outcomes:
-- The merge creates a merge commit on the repository default branch, requests deletion of the remote and local branch, and checks out the local default branch; GitHub closes the linked issue on merge.
-- The merge has exactly two outcomes decided by the exit status alone: merged on status zero and merge refused otherwise.
-- The command requires the inferred pull request to be the one `pr` published and to target the repository default branch before the irreversible merge, and confirms that same pull request's merged state and the default-branch checkout after the merge command succeeds; a queued pull request is not a merged result.
-- Merge refused is an authored failure that leaves the pull request in the state GitHub reports: the checkout no longer infers the published pull request, the pull request targets another branch, GitHub refused the merge for a conflict, a branch protection, a forbidden merge method, or a head that moved, or the merge may have landed while its confirmation, the local switch to the default branch, or the branch deletion failed.
-- A refused merge does not establish that the pull request is unmerged, so `pr` reports it as an unconfirmed merge rather than as not merged, and no outcome claims a branch was deleted, because `gh` skips the remote deletion for a pull request from another repository or one already merged and exits zero anyway.
+- `merged`: The command exited with status zero: the pull request is merged.
+- `mergeRefused`: The command exited with a nonzero status: the merge is refused, an authored failure of the workflow that leaves the pull request in the state GitHub reports, because the checkout no longer infers the published pull request, the pull request targets another branch, GitHub refused the merge for a conflict, a branch protection, a forbidden merge method, or a head that moved, or the merge may have landed while its confirmation, the local switch to the default branch, or the branch deletion failed; a refused merge does not establish that the pull request is unmerged, so the workflow reports it as an unconfirmed merge rather than as not merged.
 
 ### PR-7
 
+The local update is a mechanical step: it runs one fixed command whose exit status alone decides its two outcomes, reads no conversation, and produces no prose.
+
 When the pull request is merged, Captain shall run:
 
 > git pull --ff-only
 
 Results:
-- `localDefaultUpdated`: The command exited with status zero: the local default branch is fast-forwarded to the merged head.
-- `localDefaultNotUpdated`: The command exited with a nonzero status: the local default branch was not fast-forwarded to the merged head.
-
-Workflow outcomes:
-- The update has exactly two outcomes decided by the exit status alone: local default updated on status zero and local default not updated otherwise.
-- Both complete `pr`: the pull request is merged either way, and the result states whether the local default branch was fast-forwarded to the merged head.
-- On completion, `pr` returns the pull request number and URL, the fact that the pull request is merged, and whether the local default branch was fast-forwarded to the merged head.
+- `localDefaultUpdated`: The command exited with status zero: the local default branch is updated; the workflow completes, returning the pull request number and URL, the fact that the pull request is merged, and that the local default branch was fast-forwarded to the merged head.
+- `localDefaultNotUpdated`: The command exited with a nonzero status: the local default branch is not updated; the workflow completes, since the pull request is merged either way, returning the pull request number and URL, the fact that the pull request is merged, and that the local default branch was not fast-forwarded to the merged head.
 
 ## Optimizations
 

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

@@ -1,27 +1,17 @@
-import { type XStatePlaybookRuntimeFactory, type XStatePlaybookRuntimeConstruction } from '@sublang/playbook/xstate-runtime';
-import { type PlayerInput, type PrInput } from './pr.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, };
-/**
- * PR's per-run options. The machine reads no input of its own; the one
- * linker-owned option is the working directory its five script states run
- * in (slc/link.md §Script execution). Absent, the process working directory.
- */
-export type PrPlaybookOptions = PrInput & {
-    readonly cwd?: string;
-};
-export type PrPlaybookHostCapabilities = PlaybookHostConstructionCapabilities & XStatePlaybookRuntimeConstruction<PrPlaybookOptions, object>['hostCapabilities'];
-/**
- * Preserve the authored Markdown quote marker around every line of the
- * relayed caller input. The generic composer preserves the marker itself;
- * PR's override additionally keeps a multiline value inside that quote.
- */
-declare function composePlayerPrompt(input: PlayerInput, 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 "cwd"?: 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<PrPlaybookOptions, PrPlaybookHostCapabilities>, 3>;
+declare const createPlaybookRuntime: XStatePlaybookRuntimeFactory<XStatePlaybookRuntimeConstruction<PlaybookRuntimeOptions, PlaybookHostCapabilities>, 3>;
 export default createPlaybookRuntime;

package/reference/sdlc/pr.playbook/pr.playbook.js

@@ -1,134 +1,140 @@
 // 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:    ./pr.fsm.ts
-// Role metadata: Coder→coder (canonical local role)
-// Boss event:    deterministic START_PR entry; exact Boss text becomes
-//                callerInput; pending Coder questions retain BOSS_REPLY
-// Adjudication:  LLM judge for the one Coder state; coderOutput is carried
-//                verbatim; pullRequest and pullRequestUrl are judge-authored
-//                semantic fields; every arm is governed `unchanged`
-// Scripts:       five DR-016 script states run through the shared factory's
-//                `sh -c` actor in the optional `cwd` option
-// Nested calls:  literal code target through the shared bridge
-// Compat:        artifact schema 3 / runtime ABI 1
-import { createXStatePlaybookRuntime, composePlayerContinuation, snapshotJsonValue, } from '@sublang/playbook/xstate-runtime';
-import { prMachine, } from './pr.fsm.js';
-const OPTION_KEYS = new Set(['cwd']);
-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: "./pr.fsm.js"; export: prMachine; strategies: shared defaults with labelled string relays and nested actors.
+import { prMachine as machine } from "./pr.fsm.js";
+import { createXStatePlaybookRuntime, snapshotJsonValue, composePlayerContinuation, } from '@sublang/playbook/xstate-runtime';
+const OPTION_SCHEMA = {
+    "cwd": {
+        "type": "string",
+        "required": false
+    }
+};
+const INPUT_MAPPING = {};
+const RESUMABLE_STATE_IDS = new Set([
+    "openPullRequest"
 ]);
-// Every failure terminal leaves the delivery unfinished: no pull request is
-// guaranteed to exist after notPublished, the three fix terminals leave it
-// open, and mergeRefused leaves it in the state GitHub reports.
 const UNFINISHED_FINAL_STATE_IDS = new Set([
-    'notPublished',
-    'fixFailed',
-    'fixNotPublished',
-    'checksStillFailing',
-    'mergeRefused',
+    "notPublished",
+    "fixFailed",
+    "fixNotPublished",
+    "checksFailed",
+    "mergeUnconfirmed"
 ]);
-function snapshotPrOptions(value) {
-    const captured = snapshotJsonValue(value, 'PR runtime options');
-    if (captured === null ||
-        typeof captured !== 'object' ||
-        Array.isArray(captured)) {
-        throw new TypeError('PR runtime options must be an object');
+const VERBATIM_PAYLOAD_FIELDS = new Set([
+    "coderOutput"
+]);
+export function validateOptions(value) {
+    const captured = snapshotJsonValue(value === undefined ? {} : value, "PR runtime options");
+    if (captured === null || typeof captured !== 'object' || Array.isArray(captured)) {
+        throw new TypeError("PR 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("PR 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(`PR 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("PR runtime options." + key + ' is required');
         }
-        if (typeof option !== 'string' || option.length === 0) {
-            throw new TypeError(`PR runtime options.${key} must be a non-empty string`);
+        else if (typeof fields[key] !== schema.type || (schema.type === 'number' && !Number.isFinite(fields[key]))) {
+            throw new TypeError("PR 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 the authored Markdown quote marker around every line of the
- * relayed caller input. The generic composer preserves the marker itself;
- * PR's override additionally keeps a multiline value inside that quote.
- */
-function composePlayerPrompt(input, resuming = false) {
+function renderPlayerPrompt(input, promptIdentity, resuming = false) {
     const fields = input;
-    const body = input.prompt.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;
-        return source.slice(lineStart, offset).startsWith('> ')
-            ? quotedContinuation(value)
-            : value;
-    });
+    const mapping = {};
+    const identities = {};
+    const omitted = new Set([]);
+    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: 'PR',
-    // 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: snapshotPrOptions,
-    entryEvent: {
-        type: 'START_PR',
-        textField: 'callerInput',
-        // `startPr` 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: {
-        openPullRequest: {
-            role: 'coder',
-            label: 'Coder is publishing the branch and opening its pull request.',
+    composePlayerPrompt,
+    ...{
+        "label": "PR",
+        "compat": {
+            "artifactSchema": 3,
+            "runtimeAbi": 1
         },
-    },
-    // DR-050: PR owns no repository commit — pushing a branch and opening a
-    // pull request move only remote-tracking refs and forge state, so every
-    // Coder outcome is governed with the `unchanged` repository disposition.
-    // The pull request number and URL are judge-authored semantic fields; the
-    // Coder's report on a refused publication is carried verbatim.
-    outcomeAuthority: {
-        governedPlayerStates: {
-            openPullRequest: {
-                opened: {
-                    fields: { pullRequest: 'semantic', pullRequestUrl: 'semantic' },
-                    repositoryDisposition: 'unchanged',
-                },
-                notPublished: {
-                    fields: { coderOutput: 'presentation' },
-                    repositoryDisposition: 'unchanged',
-                },
-                needsBossReply: {
-                    fields: { question: 'presentation' },
-                    repositoryDisposition: 'unchanged',
-                },
-            },
+        "entryEvent": {
+            "type": "START_PR",
+            "textField": "callerInput",
+            "contextField": "callerInput"
+        },
+        "bossEvents": [],
+        "roleStates": {
+            "openPullRequest": {
+                "role": "coder",
+                "label": "Coder is publishing the branch and opening its pull request without changing any file or making any commit."
+            }
         },
+        "outcomeAuthority": {
+            "governedPlayerStates": {
+                "openPullRequest": {
+                    "opened": {
+                        "fields": {
+                            "pullRequest": "semantic",
+                            "pullRequestUrl": "semantic"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "notPublished": {
+                        "fields": {
+                            "coderOutput": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "needsBossReply": {
+                        "fields": {
+                            "question": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    }
+                }
+            }
+        },
+        "placeholderFields": {},
+        "transitionEventFields": [
+            "callerInput",
+            "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: ['callerInput', 'answer', 'questionId'],
 };
-const createPlaybookRuntime = createXStatePlaybookRuntime(prMachine, runtimeSpec);
+export const _internal = {
+    composePlayerPrompt,
+    RESUMABLE_STATE_IDS,
+    UNFINISHED_FINAL_STATE_IDS,
+    VERBATIM_PAYLOAD_FIELDS,
+};
+const createPlaybookRuntime = createXStatePlaybookRuntime(machine, runtimeSpec);
 export default createPlaybookRuntime;