@sublang/playbook 13.1.0 → 13.2.0

package/reference/sdlc/branch.playbook/branch.fsm.ts

@@ -0,0 +1,458 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+//
+// Generated by slc/gears2fsm.md from ./branch.gears.md.
+
+import { assign, fromPromise, setup } from 'xstate';
+
+export type BranchStateId = 'createBranch';
+
+export type BranchSourceItem = 'BRANCH-1';
+
+export type PendingBossQuestion = {
+  readonly questionId: 'createBranch';
+  readonly resumeStateId: 'createBranch';
+  readonly sourceItem: 'BRANCH-1';
+  readonly asker: { readonly kind: 'role'; readonly roleId: 'coder' };
+  readonly question: string;
+};
+
+export type PlayerInput = {
+  readonly stateId: 'createBranch';
+  readonly role: 'coder';
+  readonly sourceItem: 'BRANCH-1';
+  readonly prompt: string;
+  readonly result: Readonly<Record<string, string>>;
+  readonly callerInput: string;
+  readonly pendingBossQuestion?: PendingBossQuestion;
+  readonly bossReply?: string;
+};
+
+export type PlayerOutput =
+  | {
+      readonly guard: 'branched';
+      readonly branch: string;
+      /**
+       * Receipt-owned effect evidence (DR-045): the branching call's
+       * `unchanged` receipt observes the commit the branch was created from
+       * as HEAD, so the linked runtime injects it and never takes it from
+       * Coder's prose.
+       */
+      readonly baseRevision: string;
+      readonly issueSummary: string;
+    }
+  | { readonly guard: 'refused'; readonly coderOutput: string }
+  | { readonly guard: 'needsBossReply'; readonly question: string };
+
+export type BranchPlaybookOutput =
+  | {
+      readonly status: 'branched';
+      /** Exact name of the new branch now checked out. */
+      readonly branch: string;
+      /** Exact receipt-observed revision the branch was created from. */
+      readonly baseRevision: string;
+      /** Coder's concise summary of the issue and its comments, or of the request. */
+      readonly issueSummary: string;
+    }
+  | {
+      readonly status: 'refused';
+      /** Coder's complete report carrying the reason no branch was created. */
+      readonly coderOutput: string;
+    };
+
+export type BranchInput = Readonly<Record<string, never>>;
+
+export type BranchContext = {
+  readonly callerInput?: string;
+  readonly branch?: string;
+  /** Observed HEAD of the branching call's unchanged receipt (DR-045). */
+  readonly baseRevision?: string;
+  readonly issueSummary?: string;
+  readonly coderOutput?: string;
+  readonly completion?: 'branched' | 'refused';
+  readonly lastError?: unknown;
+  readonly pendingBossQuestion?: PendingBossQuestion;
+  readonly bossReply?: string;
+};
+
+export type BranchEvent =
+  | { readonly type: 'START_BRANCH'; readonly callerInput: string }
+  | {
+      readonly type: 'BOSS_REPLY';
+      readonly answer: string;
+      readonly questionId?: 'createBranch';
+    };
+
+const CREATE_BRANCH_PROMPT = [
+  '> Original request: <caller-input>',
+  '',
+  'Prepare a new branch for this work without changing any file or making any commit.',
+  'Identify the GitHub issue the request names, if any, and read it with its comments (`gh issue view --comments` with the issue number).',
+  'If the request could refer to more than one issue, or does not say which work to branch for, ask Boss before creating anything.',
+  "Confirm that the working tree is clean and that `gh` is authenticated for the repository's GitHub remote.",
+  'Name the branch `issue-N-short-kebab-slug` for issue number N, otherwise a short kebab-case slug of the request.',
+  'Create the branch from the current commit and check it out; do not pull, reset, stash, or move HEAD to another commit.',
+  'Report the exact branch name, the commit it was created from, and a concise summary of the issue and its comments, or of the request when no issue is named.',
+  'If the working tree is not clean, `gh` is not authenticated, the named issue does not exist or cannot be read, or a branch with that name already exists locally or on the remote, create nothing and report the failure with its reason.',
+].join('\n');
+
+const CREATE_BRANCH_RESULTS = {
+  branched:
+    'Coder created the new branch from the current commit and checked it out, reporting its exact name and a concise summary of the issue and its comments, or of the request when no issue is named; the absence of a reported obstacle is not support. Output shall include `branch: <exact branch name>`, `baseRevision: <repository revision>`, and `issueSummary: <concise summary>`.',
+  refused:
+    'Coder created nothing and reported the failure with its reason: the working tree is not clean, `gh` is not authenticated, the named issue does not exist or cannot be read, or a branch with that name already exists locally or on the remote. Output shall include `coderOutput: <verbatim final text>`.',
+  needsBossReply:
+    "The acting agent's prose surfaces a clarifying question for Boss that the agent cannot answer alone. Output shall include `question: <verbatim question text from the acting agent's prose>`.",
+} as const;
+
+const STATE_DESCRIPTIONS = {
+  ready: 'Waiting for a development request to branch for.',
+  createBranch:
+    'Coder is reading the named issue and creating and checking out a new branch at the current commit.',
+  awaitBossReply: 'Waiting for Boss to answer Coder.',
+  failed:
+    'The branch workflow failed and is waiting for a new development request.',
+  branched:
+    "A new branch for the request is checked out at the caller's current commit; no file changed and no commit was made.",
+  refused:
+    'No branch was created: Coder reported the obstacle with its reason — a dirty working tree, an unauthenticated `gh`, an unreadable issue, or a branch-name collision.',
+} as const;
+
+function playbookMeta<StateId extends keyof typeof STATE_DESCRIPTIONS>(
+  stateId: StateId,
+  role?: 'coder',
+) {
+  return {
+    playbook: {
+      stateId,
+      description: STATE_DESCRIPTIONS[stateId],
+      ...(role === undefined ? {} : { role }),
+    },
+  };
+}
+
+// DR-048: a final state additionally declares whether its outcome means the
+// workflow succeeded or failed, so BRANCH's own caller learns that from the
+// machine rather than from BRANCH's output fields.
+function terminalMeta<StateId extends keyof typeof STATE_DESCRIPTIONS>(
+  stateId: StateId,
+  terminal: 'success' | 'failure',
+) {
+  return {
+    playbook: {
+      stateId,
+      description: STATE_DESCRIPTIONS[stateId],
+      terminal,
+    },
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function playerOutput(event: unknown): Record<string, unknown> | undefined {
+  if (!isRecord(event)) return undefined;
+  return isRecord(event.output) ? event.output : undefined;
+}
+
+function outputGuard(event: unknown, guard: PlayerOutput['guard']): boolean {
+  return playerOutput(event)?.guard === guard;
+}
+
+function outputString(event: unknown, field: string): string | undefined {
+  const value = playerOutput(event)?.[field];
+  return isNonEmptyString(value) ? value : undefined;
+}
+
+// DR-045: the branched outcome is accepted only with the receipt-observed
+// base revision the linked runtime injects; Coder's prose never supplies it.
+function isBranched({ event }: { event: unknown }): boolean {
+  return (
+    outputGuard(event, 'branched') &&
+    outputString(event, 'branch') !== undefined &&
+    outputString(event, 'baseRevision') !== undefined &&
+    outputString(event, 'issueSummary') !== undefined
+  );
+}
+
+function isRefused({ event }: { event: unknown }): boolean {
+  return (
+    outputGuard(event, 'refused') &&
+    outputString(event, 'coderOutput') !== undefined
+  );
+}
+
+function needsBossReply({ event }: { event: unknown }): boolean {
+  return (
+    outputGuard(event, 'needsBossReply') &&
+    outputString(event, 'question') !== undefined
+  );
+}
+
+const machineSetup = setup({
+  types: {} as {
+    context: BranchContext;
+    events: BranchEvent;
+    input: BranchInput;
+    output: BranchPlaybookOutput;
+  },
+  actors: {
+    player: fromPromise<PlayerOutput, PlayerInput>(async () => {
+      throw new Error('player actor must be provided by the runner');
+    }),
+  },
+  guards: {
+    isBranched,
+    isRefused,
+    needsBossReply,
+    emptyBossReply: ({ event }) =>
+      event.type === 'BOSS_REPLY' && event.answer.trim().length === 0,
+    resumesCreateBranch: ({ context, event }) =>
+      event.type === 'BOSS_REPLY' &&
+      event.answer.trim().length > 0 &&
+      context.pendingBossQuestion?.resumeStateId === 'createBranch' &&
+      (event.questionId === undefined || event.questionId === 'createBranch'),
+  },
+  actions: {
+    'playbook.acceptedOutcome': (
+      _args,
+      _params: {
+        readonly source: string;
+        readonly target: string;
+        readonly acceptedOutcome: string;
+      },
+    ) => undefined,
+    startBranch: assign(({ event }) => {
+      if (event.type !== 'START_BRANCH') return {};
+      return {
+        callerInput: event.callerInput,
+        branch: undefined,
+        baseRevision: undefined,
+        issueSummary: undefined,
+        coderOutput: undefined,
+        completion: undefined,
+        lastError: undefined,
+        pendingBossQuestion: undefined,
+        bossReply: undefined,
+      };
+    }),
+    rememberBranched: assign(({ event }) => ({
+      branch: outputString(event, 'branch'),
+      // DR-045: the receipt-observed HEAD the branch was created from.
+      baseRevision: outputString(event, 'baseRevision'),
+      issueSummary: outputString(event, 'issueSummary'),
+      completion: 'branched' as const,
+      pendingBossQuestion: undefined,
+      bossReply: undefined,
+    })),
+    rememberRefused: assign(({ event }) => ({
+      coderOutput: outputString(event, 'coderOutput'),
+      completion: 'refused' as const,
+      pendingBossQuestion: undefined,
+      bossReply: undefined,
+    })),
+    rememberPendingQuestion: assign(({ event }) => {
+      const question = outputString(event, 'question');
+      if (question === undefined || !outputGuard(event, 'needsBossReply')) {
+        return { lastError: new Error('Coder question output was malformed') };
+      }
+      return {
+        pendingBossQuestion: {
+          questionId: 'createBranch' as const,
+          resumeStateId: 'createBranch' as const,
+          sourceItem: 'BRANCH-1' as const,
+          asker: { kind: 'role' as const, roleId: 'coder' as const },
+          question,
+        },
+        bossReply: undefined,
+      };
+    }),
+    rememberBossReply: assign(({ event }) =>
+      event.type === 'BOSS_REPLY' ? { bossReply: event.answer } : {},
+    ),
+    rememberEmptyBossReplyError: assign({
+      lastError: () => new Error('BOSS_REPLY received an empty answer'),
+      pendingBossQuestion: undefined,
+      bossReply: undefined,
+    }),
+    rememberActorError: assign(({ event }) => ({
+      lastError: (event as unknown as { readonly error?: unknown }).error,
+    })),
+    rememberMalformedPlayerOutput: assign({
+      lastError: () =>
+        new Error('Coder result for BRANCH-1 did not match an available outcome.'),
+    }),
+  },
+});
+
+export const branchMachine = machineSetup.createMachine({
+  id: 'branch',
+  initial: 'ready',
+  context: {},
+  output: ({ context }): BranchPlaybookOutput => {
+    if (context.completion === 'branched') {
+      if (
+        !isNonEmptyString(context.branch) ||
+        !isNonEmptyString(context.baseRevision) ||
+        !isNonEmptyString(context.issueSummary)
+      ) {
+        throw new Error(
+          'BRANCH reached branched without the exact branch name, a receipt-observed base revision, and an issue summary',
+        );
+      }
+      return {
+        status: 'branched',
+        branch: context.branch,
+        baseRevision: context.baseRevision,
+        issueSummary: context.issueSummary,
+      };
+    }
+    if (context.completion === 'refused') {
+      if (!isNonEmptyString(context.coderOutput)) {
+        throw new Error("BRANCH reached refused without Coder's report");
+      }
+      return { status: 'refused', coderOutput: context.coderOutput };
+    }
+    throw new Error('BRANCH reached a final state without a recorded completion');
+  },
+  states: {
+    ready: {
+      id: 'ready',
+      description: STATE_DESCRIPTIONS.ready,
+      meta: playbookMeta('ready'),
+      tags: ['playbook.parked'],
+      on: {
+        START_BRANCH: { target: 'createBranch', actions: 'startBranch' },
+      },
+    },
+    createBranch: {
+      id: 'createBranch',
+      description: STATE_DESCRIPTIONS.createBranch,
+      meta: playbookMeta('createBranch', 'coder'),
+      tags: ['playbook.busy'],
+      invoke: {
+        src: 'player',
+        input: ({ context }): PlayerInput => ({
+          stateId: 'createBranch',
+          role: 'coder',
+          sourceItem: 'BRANCH-1',
+          prompt: CREATE_BRANCH_PROMPT,
+          result: CREATE_BRANCH_RESULTS,
+          callerInput: context.callerInput ?? '',
+          ...(context.pendingBossQuestion === undefined
+            ? {}
+            : { pendingBossQuestion: context.pendingBossQuestion }),
+          ...(context.bossReply === undefined
+            ? {}
+            : { bossReply: context.bossReply }),
+        }),
+        onDone: [
+          {
+            guard: 'isBranched',
+            target: 'branched',
+            actions: [
+              {
+                type: 'playbook.acceptedOutcome',
+                params: {
+                  source: 'createBranch',
+                  target: 'branched',
+                  acceptedOutcome: 'branched',
+                },
+              },
+              'rememberBranched',
+            ],
+          },
+          {
+            guard: 'isRefused',
+            target: 'refused',
+            actions: [
+              {
+                type: 'playbook.acceptedOutcome',
+                params: {
+                  source: 'createBranch',
+                  target: 'refused',
+                  acceptedOutcome: 'refused',
+                },
+              },
+              'rememberRefused',
+            ],
+          },
+          {
+            guard: 'needsBossReply',
+            target: 'awaitBossReply',
+            actions: [
+              {
+                type: 'playbook.acceptedOutcome',
+                params: {
+                  source: 'createBranch',
+                  target: 'awaitBossReply',
+                  acceptedOutcome: 'needsBossReply',
+                },
+              },
+              'rememberPendingQuestion',
+            ],
+          },
+          {
+            target: 'failed',
+            actions: 'rememberMalformedPlayerOutput',
+          },
+        ],
+        onError: { target: 'failed', actions: 'rememberActorError' },
+      },
+    },
+    awaitBossReply: {
+      id: 'awaitBossReply',
+      description: STATE_DESCRIPTIONS.awaitBossReply,
+      meta: playbookMeta('awaitBossReply'),
+      tags: ['playbook.parked'],
+      on: {
+        BOSS_REPLY: [
+          {
+            guard: 'emptyBossReply',
+            target: '#failed',
+            actions: 'rememberEmptyBossReplyError',
+          },
+          {
+            guard: 'resumesCreateBranch',
+            target: '#createBranch',
+            reenter: true,
+            actions: 'rememberBossReply',
+          },
+        ],
+        START_BRANCH: { target: 'createBranch', actions: 'startBranch' },
+      },
+    },
+    failed: {
+      id: 'failed',
+      description: STATE_DESCRIPTIONS.failed,
+      meta: playbookMeta('failed'),
+      tags: ['playbook.parked'],
+      on: {
+        START_BRANCH: { target: 'createBranch', actions: 'startBranch' },
+      },
+    },
+    branched: {
+      id: 'branched',
+      description: STATE_DESCRIPTIONS.branched,
+      meta: terminalMeta('branched', 'success'),
+      type: 'final',
+    },
+    refused: {
+      id: 'refused',
+      description: STATE_DESCRIPTIONS.refused,
+      meta: terminalMeta('refused', 'failure'),
+      type: 'final',
+    },
+  },
+});
+
+export default branchMachine;

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

@@ -0,0 +1,44 @@
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+<!-- SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai> -->
+
+# BRANCH: Pull-Request Branch Preparation Workflow
+
+Roles:
+
+- Coder
+
+The caller supplies a development request that names a GitHub issue (number or URL) or, when no issue is named, describes the work, together with any relevant context.
+
+`branch` prepares pull-request delivery of one development request: it creates and checks out a new branch at the current commit.
+It changes no files and owns no repository commit.
+Captain takes the base revision from repository authority, not from Coder's prose: the `unchanged` repository-effect receipt of the branching call proves the observed HEAD the branch was created from.
+
+## Coder
+
+### BRANCH-1
+
+When the caller gives the request, Captain shall relay the complete caller input in quotes (`>`) to Coder, along with the branching instruction:
+
+> > Original request: <caller-input>
+>
+> Prepare a new branch for this work without changing any file or making any commit.
+> Identify the GitHub issue the request names, if any, and read it with its comments (`gh issue view --comments` with the issue number).
+> If the request could refer to more than one issue, or does not say which work to branch for, ask Boss before creating anything.
+> Confirm that the working tree is clean and that `gh` is authenticated for the repository's GitHub remote.
+> Name the branch `issue-N-short-kebab-slug` for issue number N, otherwise a short kebab-case slug of the request.
+> Create the branch from the current commit and check it out; do not pull, reset, stash, or move HEAD to another commit.
+> Report the exact branch name, the commit it was created from, and a concise summary of the issue and its comments, or of the request when no issue is named.
+> If the working tree is not clean, `gh` is not authenticated, the named issue does not exist or cannot be read, or a branch with that name already exists locally or on the remote, create nothing and report the failure with its reason.
+
+Results:
+- `branched`: Coder created the new branch from the current commit and checked it out, reporting its exact name and a concise summary of the issue and its comments, or of the request when no issue is named; the absence of a reported obstacle is not support. Output shall include `branch: <exact branch name>`, `baseRevision: <repository revision>`, and `issueSummary: <concise summary>`.
+- `refused`: Coder created nothing and reported the failure with its reason: the working tree is not clean, `gh` is not authenticated, the named issue does not exist or cannot be read, or a branch with that name already exists locally or on the remote. Output shall include `coderOutput: <verbatim final text>`.
+
+Workflow outcomes:
+- The result has two semantic outcomes: branched and refused, plus the Boss question when the request is ambiguous about the issue or work it means.
+- Each outcome requires affirmative support in Coder's result; the absence of a reported obstacle is not support for branched, and no outcome depends on a fixed presentation format of Coder's reply.
+- Every outcome keeps the repository exact: a new branch at the current commit changes neither HEAD's commit nor the working tree.
+- Captain takes the base revision from repository authority, not from Coder's prose.
+- The Boss question uses the standard Boss-question suspension with Coder's complete response; after Boss replies, `branch` resumes with the answer in the same Coder conversation, and the previous question is included only when that conversation must start fresh.
+- For branched, `branch` is complete and returns the exact branch name, the exact base revision, and the issue summary to its caller.
+- For refused, `branch` fails and reports Coder's complete result with its reason to its caller; no branch was created.

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

@@ -0,0 +1,20 @@
+import { type XStatePlaybookRuntimeFactory, type XStatePlaybookRuntimeConstruction } from '@sublang/playbook/xstate-runtime';
+import { type BranchInput, type PlayerInput } from './branch.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 BranchPlaybookOptions = BranchInput;
+export type BranchPlaybookHostCapabilities = PlaybookHostConstructionCapabilities & XStatePlaybookRuntimeConstruction<BranchPlaybookOptions, object>['hostCapabilities'];
+/**
+ * Preserve authored Markdown quote markers around every line of relayed
+ * runtime text. The generic composer preserves the marker itself; BRANCH's
+ * override additionally keeps a multiline caller input inside that quote.
+ */
+declare function composePlayerPrompt(input: PlayerInput, resuming?: boolean): string;
+export declare const _internal: {
+    composePlayerPrompt: typeof composePlayerPrompt;
+    VERBATIM_PAYLOAD_FIELDS: ReadonlySet<string>;
+    UNFINISHED_FINAL_STATE_IDS: ReadonlySet<string>;
+};
+declare const createPlaybookRuntime: XStatePlaybookRuntimeFactory<XStatePlaybookRuntimeConstruction<BranchPlaybookOptions, BranchPlaybookHostCapabilities>, 3>;
+export default createPlaybookRuntime;

package/reference/sdlc/branch.playbook/branch.playbook.js

@@ -0,0 +1,121 @@
+// 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:    ./branch.fsm.ts
+// Role metadata: Coder→coder (canonical local role)
+// Boss event:    deterministic START_BRANCH entry; exact Boss text becomes
+//                callerInput; pending Coder questions retain BOSS_REPLY
+// Adjudication:  LLM judge for the one Coder state; coderOutput is carried
+//                verbatim; baseRevision is receipt-owned effect evidence —
+//                the unchanged receipt's observed HEAD — never taken from
+//                Coder's prose
+// Compat:        artifact schema 3 / runtime ABI 1
+import { createXStatePlaybookRuntime, composePlayerContinuation, snapshotJsonValue, } from '@sublang/playbook/xstate-runtime';
+import { branchMachine, } from './branch.fsm.js';
+const PLACEHOLDER = /<(#|[A-Za-z_$][A-Za-z0-9_$-]*)>/g;
+const VERBATIM_PAYLOAD_FIELDS = new Set([
+    'coderOutput',
+]);
+const UNFINISHED_FINAL_STATE_IDS = new Set(['refused']);
+function snapshotBranchOptions(value) {
+    const captured = snapshotJsonValue(value, 'BRANCH runtime options');
+    if (captured === null ||
+        typeof captured !== 'object' ||
+        Array.isArray(captured)) {
+        throw new TypeError('BRANCH runtime options must be an object');
+    }
+    const record = captured;
+    for (const key of Object.keys(record)) {
+        throw new TypeError(`BRANCH runtime options.${key} is not declared`);
+    }
+    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; BRANCH's
+ * override additionally keeps a multiline caller input inside that quote.
+ */
+function composePlayerPrompt(input, 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;
+        const literal = source.slice(lineStart, offset);
+        return literal.startsWith('> ') ? quotedContinuation(value) : value;
+    });
+    return composePlayerContinuation(input, body, resuming);
+}
+export const _internal = {
+    composePlayerPrompt,
+    VERBATIM_PAYLOAD_FIELDS,
+    UNFINISHED_FINAL_STATE_IDS,
+};
+const runtimeSpec = {
+    label: 'BRANCH',
+    // 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: snapshotBranchOptions,
+    entryEvent: {
+        type: 'START_BRANCH',
+        textField: 'callerInput',
+        // `startBranch` 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: {
+        createBranch: {
+            role: 'coder',
+            label: 'Coder is reading the named issue and creating and checking out a new branch at the current commit.',
+        },
+    },
+    // DR-050: BRANCH owns no repository commit — every Coder outcome, including
+    // the Boss question for an ambiguous request, is governed with the
+    // `unchanged` repository disposition, because a new branch at the current
+    // commit changes neither HEAD's OID nor the worktree projection.
+    outcomeAuthority: {
+        governedPlayerStates: {
+            createBranch: {
+                branched: {
+                    fields: {
+                        branch: 'semantic',
+                        // DR-045: the unchanged receipt observes the commit the branch
+                        // was created from as HEAD; the reconciler injects it here.
+                        baseRevision: 'effect',
+                        issueSummary: 'semantic',
+                    },
+                    repositoryDisposition: 'unchanged',
+                },
+                refused: {
+                    fields: { coderOutput: 'presentation' },
+                    repositoryDisposition: 'unchanged',
+                },
+                needsBossReply: {
+                    fields: { question: 'presentation' },
+                    repositoryDisposition: 'unchanged',
+                },
+            },
+        },
+    },
+    composePlayerPrompt: (input, _identity, resuming) => composePlayerPrompt(input, resuming),
+    verbatimPayloadFields: VERBATIM_PAYLOAD_FIELDS,
+    controlContextFields: [],
+    unfinishedFinalStateIds: UNFINISHED_FINAL_STATE_IDS,
+    transitionEventFields: ['callerInput', 'answer', 'questionId'],
+};
+const createPlaybookRuntime = createXStatePlaybookRuntime(branchMachine, runtimeSpec);
+export default createPlaybookRuntime;