@sublang/playbook 17.2.0 → 17.4.0

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

@@ -0,0 +1,455 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+
+import { setup, fromPromise, assign } from 'xstate';
+
+// ---------------------------------------------------------------------------
+// Exported boundary types (the linked runtime provides the actor implementation
+// and imports these exact types).
+// ---------------------------------------------------------------------------
+
+/**
+ * Machine construction input. The caller-supplied inspection request and any
+ * relevant discussion context are delivered through the Boss entry event; an
+ * optional seed may ride along at construction. No agent call runs before the
+ * first Boss-originated event.
+ */
+export interface InspectInput {
+    inspectionRequest?: string;
+    discussionContext?: string;
+}
+
+/**
+ * Terminal workflow output returned to the caller. Source declares two terminal
+ * returns: `{ status: 'complete', report }` and `{ status: 'unavailable', report }`.
+ */
+export type MachineOutput =
+    | { status: 'complete'; report: string }
+    | { status: 'unavailable'; report: string };
+
+/** Standard suspended-question record carried while awaiting a Boss reply. */
+export interface PendingBossQuestion {
+    questionId: string;
+    resumeStateId: string;
+    sourceItem: string;
+    asker: { kind: 'captain' } | { kind: 'role'; roleId: string };
+    question: string;
+}
+
+/** Typed input for the delegated `player` (Inspector) actor. */
+export interface PlayerInput {
+    stateId: string;
+    role: 'inspector';
+    sourceItem: string;
+    prompt: string;
+    inspectionRequest: string;
+    discussionContext: string;
+    pendingBossQuestion?: PendingBossQuestion;
+    bossReply?: string;
+    result: Record<'completed' | 'unavailable' | 'needsBossReply', string>;
+}
+
+/** Discriminated result contract the Inspector actor returns. */
+export type PlayerOutput =
+    | { guard: 'completed'; status: string; report: string }
+    | { guard: 'unavailable'; status: string; report: string }
+    | { guard: 'needsBossReply'; question: string };
+
+// ---------------------------------------------------------------------------
+// Internal machine types.
+// ---------------------------------------------------------------------------
+
+interface LastError {
+    name: string;
+    message: string;
+    stack?: string;
+}
+
+interface InspectContext {
+    inspectionRequest: string;
+    discussionContext: string;
+    report: string;
+    status: 'complete' | 'unavailable' | null;
+    lastError: LastError | null;
+    pendingBossQuestion: PendingBossQuestion | null;
+    bossReply: string | null;
+}
+
+type InspectEvent =
+    | { type: 'START'; inspectionRequest: string; discussionContext?: string }
+    | { type: 'BOSS_REPLY'; answer: string; questionId?: string };
+
+interface AcceptedOutcomeParams {
+    source: string;
+    target: string;
+    acceptedOutcome: string;
+}
+
+// ---------------------------------------------------------------------------
+// Source-derived constants.
+// ---------------------------------------------------------------------------
+
+// INSPECT-1 full final prompt, verbatim from the GEARS blockquote. The literal
+// leading `>` on the quoted-context lines is prompt content and is preserved.
+const INSPECT_1_PROMPT = [
+    'Inspect the requested material and give an evidence-based explanation.',
+    'Use the attachments actually supplied to this call. Attachment names and metadata alone do not prove what their bytes show.',
+    'For a request about a running interface, use the available browser tools to open the requested location, inspect it, and capture a screenshot when needed to support the explanation. Request screenshots as native image content by omitting an explicit filename when the tool supports that form.',
+    'Reason from the images or tool results you actually receive, and explain the concrete observations that support your conclusions. Distinguish observed behavior from inference. Never claim to have opened, captured, or viewed something that the available evidence does not establish.',
+    'Do not edit repository files, create commits, implement changes, or make unrelated changes to the inspected application. Browser interaction remains within the inspection Boss requested.',
+    'If a missing choice or target prevents a useful inspection, ask Boss one concise question carrying every detail needed to answer. Do not invent the missing target.',
+    'If required evidence or tools are unavailable, explain exactly what is unavailable and what that prevents you from concluding. Do not substitute a promise to inspect later for a result.',
+    "Otherwise, complete the requested inspection and explain the findings, answering Boss's request directly. Make clear which captured figures support the findings without inventing a file path or asset identifier.",
+    '',
+    '> Inspection request: <inspection-request>',
+    '> Discussion context: <discussion-context>',
+].join('\n');
+
+// INSPECT-1 local result contract, guard names and descriptions preserved
+// verbatim in declared order, with the universal needsBossReply appended.
+const INSPECT_1_RESULT: Record<'completed' | 'unavailable' | 'needsBossReply', string> = {
+    completed:
+        "Inspector's response affirmatively supports a completed inspection, not depending on any fixed presentation format. `inspect` terminates successfully and returns `{ status: 'complete', report }` to the caller, and its terminal description states that the inspection is complete without a repository change. Output shall include `status` (the string complete) and `report: <verbatim final text>`, where report is Inspector's complete explanation.",
+    unavailable:
+        "Inspector's response affirmatively supports that required evidence or tools are unavailable, not depending on any fixed presentation format. `inspect` terminates as an authored failure and returns `{ status: 'unavailable', report }` to the caller, and its terminal description states that the requested inspection could not be completed. Output shall include `status` (the string unavailable) and `report: <verbatim final text>`, where report is Inspector's complete explanation of the missing evidence or tools.",
+    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>`.",
+};
+
+// Role-id arrays per parallel group; this machine has no parallel group.
+export const concurrentRoleSets = [] as const;
+
+// ---------------------------------------------------------------------------
+// Structural narrowing helpers (accept unknown event output and narrow to the
+// declared contract before reading fields).
+// ---------------------------------------------------------------------------
+
+function playerOutputOf(event: unknown): PlayerOutput | null {
+    if (typeof event !== 'object' || event === null) return null;
+    const output = (event as { output?: unknown }).output;
+    if (typeof output !== 'object' || output === null) return null;
+    const guard = (output as { guard?: unknown }).guard;
+    if (guard === 'completed' || guard === 'unavailable') {
+        const status = (output as { status?: unknown }).status;
+        const report = (output as { report?: unknown }).report;
+        if (typeof status === 'string' && typeof report === 'string' && report.trim().length > 0) {
+            return guard === 'completed'
+                ? { guard: 'completed', status, report }
+                : { guard: 'unavailable', status, report };
+        }
+        return null;
+    }
+    if (guard === 'needsBossReply') {
+        const question = (output as { question?: unknown }).question;
+        if (typeof question === 'string') return { guard: 'needsBossReply', question };
+        return null;
+    }
+    return null;
+}
+
+function reportOf(event: unknown): string {
+    const output = playerOutputOf(event);
+    return output && (output.guard === 'completed' || output.guard === 'unavailable')
+        ? output.report
+        : '';
+}
+
+function normalizeError(error: unknown): LastError {
+    if (error instanceof Error) {
+        return error.stack !== undefined
+            ? { name: error.name, message: error.message, stack: error.stack }
+            : { name: error.name, message: error.message };
+    }
+    return { name: 'Error', message: typeof error === 'string' ? error : 'Unknown error' };
+}
+
+function nonEmptyString(value: unknown): boolean {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+
+// ---------------------------------------------------------------------------
+// Machine.
+// ---------------------------------------------------------------------------
+
+export const inspectMachine = setup({
+    types: {
+        context: {} as InspectContext,
+        events: {} as InspectEvent,
+        input: {} as InspectInput,
+        output: {} as MachineOutput,
+    },
+    actors: {
+        // Delegated Inspector work; the runner supplies the implementation.
+        player: fromPromise<PlayerOutput, PlayerInput>(async () => {
+            throw new Error('player actor must be provided by the runner');
+        }),
+    },
+    actions: {
+        // No-op accepted-outcome marker; the linked runtime consumes these
+        // three string params to publish the accepted-outcome trace.
+        'playbook.acceptedOutcome': (_args: unknown, _params: AcceptedOutcomeParams) => {},
+        applyEntry: assign({
+            inspectionRequest: ({ event }) => {
+                const value = (event as { inspectionRequest?: unknown }).inspectionRequest;
+                return typeof value === 'string' ? value : '';
+            },
+            discussionContext: ({ context, event }) => {
+                const value = (event as { discussionContext?: unknown }).discussionContext;
+                return typeof value === 'string' ? value : context.discussionContext;
+            },
+            report: () => '',
+            status: () => null,
+            lastError: () => null,
+            pendingBossQuestion: () => null,
+            bossReply: () => null,
+        }),
+        recordCompleted: assign({
+            report: ({ event }) => reportOf(event),
+            status: () => 'complete' as const,
+        }),
+        recordUnavailable: assign({
+            report: ({ event }) => reportOf(event),
+            status: () => 'unavailable' as const,
+        }),
+        setPendingBossQuestion: assign({
+            pendingBossQuestion: ({ event }): PendingBossQuestion => {
+                const output = playerOutputOf(event);
+                const question = output && output.guard === 'needsBossReply' ? output.question : '';
+                return {
+                    questionId: 'inspecting',
+                    resumeStateId: 'inspecting',
+                    sourceItem: 'INSPECT-1',
+                    asker: { kind: 'role' as const, roleId: 'inspector' },
+                    question,
+                };
+            },
+        }),
+        storeBossReply: assign({
+            bossReply: ({ event }) => {
+                const answer = (event as { answer?: unknown }).answer;
+                return typeof answer === 'string' ? answer : '';
+            },
+        }),
+        clearBossReplyContext: assign({
+            pendingBossQuestion: () => null,
+            bossReply: () => null,
+        }),
+        rememberError: assign({
+            lastError: ({ event }) => normalizeError((event as { error?: unknown }).error),
+        }),
+        rememberMalformedOutput: assign({
+            lastError: () => ({
+                name: 'MalformedActorOutput',
+                message: 'Inspector returned an unrecognized result.',
+            }),
+        }),
+        rememberEmptyReply: assign({
+            lastError: () => ({
+                name: 'InvalidBossReply',
+                message: 'BOSS_REPLY carried an empty or whitespace-only answer.',
+            }),
+        }),
+    },
+    guards: {
+        hasInspectionRequest: ({ event }) =>
+            nonEmptyString((event as { inspectionRequest?: unknown }).inspectionRequest),
+        hasBossReply: ({ event }) => nonEmptyString((event as { answer?: unknown }).answer),
+        playerCompleted: ({ event }) => playerOutputOf(event)?.guard === 'completed',
+        playerUnavailable: ({ event }) => playerOutputOf(event)?.guard === 'unavailable',
+        playerNeedsBossReply: ({ event }) => playerOutputOf(event)?.guard === 'needsBossReply',
+    },
+}).createMachine({
+    id: 'inspect',
+    description:
+        'Investigate and explain existing material or a running interface without changing the repository.',
+    initial: 'ready',
+    context: ({ input }) => ({
+        inspectionRequest: input.inspectionRequest ?? '',
+        discussionContext: input.discussionContext ?? '',
+        report: '',
+        status: null,
+        lastError: null,
+        pendingBossQuestion: null,
+        bossReply: null,
+    }),
+    output: ({ context }): MachineOutput =>
+        context.status === 'complete'
+            ? { status: 'complete', report: context.report }
+            : { status: 'unavailable', report: context.report },
+    states: {
+        ready: {
+            id: 'ready',
+            description: 'Idle hub awaiting a Boss inspection request.',
+            tags: ['playbook.parked'],
+            meta: {
+                playbook: {
+                    stateId: 'ready',
+                    description: 'Idle hub awaiting a Boss inspection request.',
+                },
+            },
+            on: {
+                START: {
+                    guard: 'hasInspectionRequest',
+                    target: 'inspecting',
+                    actions: 'applyEntry',
+                },
+            },
+        },
+        inspecting: {
+            id: 'inspecting',
+            description:
+                'Inspector investigates the requested material and gives an evidence-based explanation.',
+            tags: ['playbook.busy'],
+            meta: {
+                playbook: {
+                    stateId: 'inspecting',
+                    description:
+                        'Inspector investigates the requested material and gives an evidence-based explanation.',
+                    role: 'inspector',
+                },
+            },
+            invoke: {
+                src: 'player',
+                input: ({ context }): PlayerInput => ({
+                    stateId: 'inspecting',
+                    role: 'inspector',
+                    sourceItem: 'INSPECT-1',
+                    prompt: INSPECT_1_PROMPT,
+                    inspectionRequest: context.inspectionRequest,
+                    discussionContext: context.discussionContext,
+                    ...(context.pendingBossQuestion
+                        ? { pendingBossQuestion: context.pendingBossQuestion }
+                        : {}),
+                    ...(context.bossReply ? { bossReply: context.bossReply } : {}),
+                    result: INSPECT_1_RESULT,
+                }),
+                onDone: [
+                    {
+                        guard: 'playerCompleted',
+                        target: 'complete',
+                        actions: [
+                            {
+                                type: 'playbook.acceptedOutcome',
+                                params: {
+                                    source: 'inspecting',
+                                    target: 'complete',
+                                    acceptedOutcome: 'completed',
+                                },
+                            },
+                            'recordCompleted',
+                            'clearBossReplyContext',
+                        ],
+                    },
+                    {
+                        guard: 'playerUnavailable',
+                        target: 'unavailable',
+                        actions: [
+                            {
+                                type: 'playbook.acceptedOutcome',
+                                params: {
+                                    source: 'inspecting',
+                                    target: 'unavailable',
+                                    acceptedOutcome: 'unavailable',
+                                },
+                            },
+                            'recordUnavailable',
+                            'clearBossReplyContext',
+                        ],
+                    },
+                    {
+                        guard: 'playerNeedsBossReply',
+                        target: 'awaitBossReply',
+                        actions: [
+                            {
+                                type: 'playbook.acceptedOutcome',
+                                params: {
+                                    source: 'inspecting',
+                                    target: 'awaitBossReply',
+                                    acceptedOutcome: 'needsBossReply',
+                                },
+                            },
+                            'setPendingBossQuestion',
+                        ],
+                    },
+                    {
+                        target: 'failed',
+                        actions: ['rememberMalformedOutput', 'clearBossReplyContext'],
+                    },
+                ],
+                onError: {
+                    target: 'failed',
+                    actions: ['rememberError', 'clearBossReplyContext'],
+                },
+            },
+        },
+        awaitBossReply: {
+            id: 'awaitBossReply',
+            description: "Waiting for Boss to answer the acting agent's question.",
+            tags: ['playbook.parked'],
+            meta: {
+                playbook: {
+                    stateId: 'awaitBossReply',
+                    description: "Waiting for Boss to answer the acting agent's question.",
+                },
+            },
+            on: {
+                BOSS_REPLY: [
+                    {
+                        guard: 'hasBossReply',
+                        target: '#inspecting',
+                        reenter: true,
+                        actions: 'storeBossReply',
+                    },
+                    {
+                        target: '#failed',
+                        actions: ['rememberEmptyReply', 'clearBossReplyContext'],
+                    },
+                ],
+            },
+        },
+        complete: {
+            id: 'complete',
+            type: 'final',
+            description: 'The inspection is complete without a repository change.',
+            meta: {
+                playbook: {
+                    stateId: 'complete',
+                    description: 'The inspection is complete without a repository change.',
+                    terminal: 'success',
+                },
+            },
+        },
+        unavailable: {
+            id: 'unavailable',
+            type: 'final',
+            description: 'The requested inspection could not be completed.',
+            meta: {
+                playbook: {
+                    stateId: 'unavailable',
+                    description: 'The requested inspection could not be completed.',
+                    terminal: 'failure',
+                },
+            },
+        },
+        failed: {
+            id: 'failed',
+            description:
+                'A control error or malformed result interrupted the inspection; awaiting Boss recovery.',
+            tags: ['playbook.parked'],
+            meta: {
+                playbook: {
+                    stateId: 'failed',
+                    description:
+                        'A control error or malformed result interrupted the inspection; awaiting Boss recovery.',
+                },
+            },
+            on: {
+                START: {
+                    guard: 'hasInspectionRequest',
+                    target: 'inspecting',
+                    actions: 'applyEntry',
+                },
+            },
+        },
+    },
+});

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

@@ -0,0 +1,36 @@
+<!-- SPDX-License-Identifier: Apache-2.0 -->
+<!-- SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai> -->
+
+# Inspect
+
+Roles:
+
+- Inspector
+
+The caller supplies an inspection request, including the subject, any requested comparison or explanation, and relevant context.
+The host supplies only the attachments selected for this engagement and any explicitly enabled browser tools.
+`inspect` investigates and explains existing material or a running interface without changing the repository, implementing a fix, or making a commit.
+
+### INSPECT-1
+
+Every Inspector call requires the repository to remain unchanged.
+For a needs-Boss-reply outcome, `inspect` uses the standard Boss-question suspension with Inspector's complete response; after Boss replies, it resumes Inspector in the same conversation with the answer and the original request, including the previous question when the conversation starts fresh.
+A failed or interrupted agent call follows the standard failure or abort path and never establishes a completed inspection.
+
+At the start of `inspect` and after each Boss reply, Captain shall relay the inspection request and relevant discussion context to Inspector in quotes (`>`):
+
+> Inspect the requested material and give an evidence-based explanation.
+> Use the attachments actually supplied to this call. Attachment names and metadata alone do not prove what their bytes show.
+> For a request about a running interface, use the available browser tools to open the requested location, inspect it, and capture a screenshot when needed to support the explanation. Request screenshots as native image content by omitting an explicit filename when the tool supports that form.
+> Reason from the images or tool results you actually receive, and explain the concrete observations that support your conclusions. Distinguish observed behavior from inference. Never claim to have opened, captured, or viewed something that the available evidence does not establish.
+> Do not edit repository files, create commits, implement changes, or make unrelated changes to the inspected application. Browser interaction remains within the inspection Boss requested.
+> If a missing choice or target prevents a useful inspection, ask Boss one concise question carrying every detail needed to answer. Do not invent the missing target.
+> If required evidence or tools are unavailable, explain exactly what is unavailable and what that prevents you from concluding. Do not substitute a promise to inspect later for a result.
+> Otherwise, complete the requested inspection and explain the findings, answering Boss's request directly. Make clear which captured figures support the findings without inventing a file path or asset identifier.
+>
+> > Inspection request: <inspection-request>
+> > Discussion context: <discussion-context>
+
+Results:
+- `completed`: Inspector's response affirmatively supports a completed inspection, not depending on any fixed presentation format. `inspect` terminates successfully and returns `{ status: 'complete', report }` to the caller, and its terminal description states that the inspection is complete without a repository change. Output shall include `status` (the string complete) and `report: <verbatim final text>`, where report is Inspector's complete explanation.
+- `unavailable`: Inspector's response affirmatively supports that required evidence or tools are unavailable, not depending on any fixed presentation format. `inspect` terminates as an authored failure and returns `{ status: 'unavailable', report }` to the caller, and its terminal description states that the requested inspection could not be completed. Output shall include `status` (the string unavailable) and `report: <verbatim final text>`, where report is Inspector's complete explanation of the missing evidence or tools.

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

@@ -0,0 +1,17 @@
+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 "discussionContext"?: string;
+}
+export type PlaybookHostCapabilities = XStatePlaybookRuntimeConstruction<PlaybookRuntimeOptions, {
+    readonly authority: object;
+}>['hostCapabilities'];
+export declare function validateOptions(value: unknown): PlaybookRuntimeOptions;
+export declare const _internal: {
+    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<PlaybookRuntimeOptions, PlaybookHostCapabilities>, 3>;
+export default createPlaybookRuntime;

package/reference/sdlc/inspect.playbook/inspect.playbook.js

@@ -0,0 +1,142 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+// Generated by slc/materialize-link.mjs; governed by the complete slc/link.md.
+// FSM: "./inspect.fsm.js"; export: inspectMachine; strategies: shared defaults with labelled string relays and nested actors.
+import { inspectMachine as machine } from "./inspect.fsm.js";
+import { createXStatePlaybookRuntime, snapshotJsonValue, composePlayerContinuation, } from '@sublang/playbook/xstate-runtime';
+const OPTION_SCHEMA = {
+    "discussionContext": {
+        "type": "string",
+        "required": false
+    }
+};
+const INPUT_MAPPING = {
+    "discussionContext": "discussionContext"
+};
+const RESUMABLE_STATE_IDS = new Set([
+    "inspecting"
+]);
+const UNFINISHED_FINAL_STATE_IDS = new Set([
+    "unavailable"
+]);
+const VERBATIM_PAYLOAD_FIELDS = new Set([
+    "report"
+]);
+export function validateOptions(value) {
+    const captured = snapshotJsonValue(value === undefined ? {} : value, "INSPECT runtime options");
+    if (captured === null || typeof captured !== 'object' || Array.isArray(captured)) {
+        throw new TypeError("INSPECT 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("INSPECT 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("INSPECT runtime options." + key + ' is required');
+        }
+        else if (typeof fields[key] !== schema.type || (schema.type === 'number' && !Number.isFinite(fields[key]))) {
+            throw new TypeError("INSPECT runtime options." + key + ' must be a ' + schema.type);
+        }
+    }
+    return captured;
+}
+function renderPlayerPrompt(input, promptIdentity, resuming = false) {
+    const fields = input;
+    const mapping = {};
+    const identities = {};
+    const omitted = new Set(["> Discussion context: <discussion-context>"]);
+    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 = {
+    composePlayerPrompt,
+    ...{
+        "label": "INSPECT",
+        "compat": {
+            "artifactSchema": 3,
+            "runtimeAbi": 1
+        },
+        "entryEvent": {
+            "type": "START",
+            "textField": "inspectionRequest",
+            "contextField": "inspectionRequest"
+        },
+        "bossEvents": [],
+        "roleStates": {
+            "inspecting": {
+                "role": "inspector",
+                "label": "Inspector investigates the requested material and gives an evidence-based explanation."
+            }
+        },
+        "outcomeAuthority": {
+            "governedPlayerStates": {
+                "inspecting": {
+                    "completed": {
+                        "fields": {
+                            "status": "semantic",
+                            "report": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "unavailable": {
+                        "fields": {
+                            "status": "semantic",
+                            "report": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    },
+                    "needsBossReply": {
+                        "fields": {
+                            "question": "presentation"
+                        },
+                        "repositoryDisposition": "unchanged"
+                    }
+                }
+            }
+        },
+        "placeholderFields": {},
+        "transitionEventFields": [
+            "inspectionRequest",
+            "discussionContext",
+            "answer",
+            "questionId"
+        ],
+        "controlContextFields": [
+            "inspectionRequest"
+        ]
+    },
+    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,
+    resumableStateIds: RESUMABLE_STATE_IDS,
+    unfinishedFinalStateIds: UNFINISHED_FINAL_STATE_IDS,
+};
+export const _internal = {
+    composePlayerPrompt,
+    RESUMABLE_STATE_IDS,
+    UNFINISHED_FINAL_STATE_IDS,
+    VERBATIM_PAYLOAD_FIELDS,
+};
+const createPlaybookRuntime = createXStatePlaybookRuntime(machine, runtimeSpec);
+export default createPlaybookRuntime;