@sublang/playbook 11.0.0 → 12.0.0

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

@@ -0,0 +1,723 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: 2026 SubLang International <https://sublang.ai>
+//
+// Generated by slc/gears2fsm.md from ./dev.gears.md.
+import { assign, fromPromise, setup } from 'xstate';
+const PLAN_ANALYSIS_PROMPT = [
+    '> <development-request>',
+    '> <discussion-context>',
+    '> <run-results>',
+    '',
+    'Inspect the request and the relevant repository and specs only as needed to determine the smallest sound next step.',
+    'Do not change files or commit while planning or discussing the request.',
+    '',
+    '- If useful analysis or clarification should be discussed before any repository work, give Boss the useful response and ask one material question that advances the decision.',
+    '- If the discussion has concluded after a Boss reply and no repository work should follow, choose `discussion complete`.',
+    '- If implementation can proceed under the existing decisions, choose `code`.',
+    '- If implementation first requires a new or amended durable decision that the existing specs do not settle, choose `decide then code`.',
+    '',
+    'A question or exploratory discussion is not by itself authorization to create a durable decision or implement changes.',
+    'Do not choose `decide then code` merely because the work is large.',
+    'Consult @specs/map.md for relevant context and @specs/meta.md for spec requirements, if needed.',
+].join('\n');
+const PLAN_ANALYSIS_RESULTS = {
+    discussionComplete: 'Analyst concluded the discussion after a Boss reply, with no repository work to follow.',
+    code: 'Analyst determined implementation can proceed under the existing decisions. Output shall include `planningResult: <verbatim final text>`.',
+    decideThenCode: 'Analyst determined implementation first requires a new or amended durable decision that the existing specs do not settle. Output shall include `planningResult: <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>`.",
+};
+const STATE_DESCRIPTIONS = {
+    ready: 'Waiting for a development request.',
+    planAnalysis: 'Analyst is analyzing the development request to choose the smallest sound next step.',
+    callCode: 'The CODE playbook is implementing the planned development path.',
+    callDecide: 'The DECIDE playbook is settling the durable decision the planned path requires.',
+    callCodeAfterDecide: 'The CODE playbook is implementing the decided development path.',
+    awaitBossReply: 'Waiting for Boss to answer Analyst.',
+    failed: 'The development planning workflow failed and is waiting for a new development request.',
+    discussionComplete: 'The planning discussion concluded after a Boss reply with no repository work to follow.',
+    done: "The selected development path completed with the final child playbook's successful result.",
+    reportedChildFailure: "The development workflow relayed a child playbook's authored abort, failure, or insufficient terminal result.",
+};
+function playbookMeta(stateId, role) {
+    return {
+        playbook: {
+            stateId,
+            description: STATE_DESCRIPTIONS[stateId],
+            ...(role === undefined ? {} : { role }),
+        },
+    };
+}
+function isRecord(value) {
+    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) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function playerOutput(event) {
+    if (!isRecord(event))
+        return undefined;
+    return isRecord(event.output) ? event.output : undefined;
+}
+function outputGuard(event, guard) {
+    return playerOutput(event)?.guard === guard;
+}
+function outputString(event, field) {
+    const value = playerOutput(event)?.[field];
+    return isNonEmptyString(value) ? value : undefined;
+}
+function isCodePath({ event }) {
+    return (outputGuard(event, 'code') &&
+        outputString(event, 'planningResult') !== undefined);
+}
+function isDecideThenCode({ event }) {
+    return (outputGuard(event, 'decideThenCode') &&
+        outputString(event, 'planningResult') !== undefined);
+}
+// Discussion complete is available only after a Boss reply: the round that
+// produced it must itself have been resumed with Boss's answer.
+function isDiscussionComplete({ context, event, }) {
+    return (outputGuard(event, 'discussionComplete') &&
+        isNonEmptyString(context.bossReply));
+}
+function needsBossReply({ event }) {
+    return (outputGuard(event, 'needsBossReply') &&
+        outputString(event, 'question') !== undefined);
+}
+function childOutputOf(event) {
+    return isRecord(event) ? event.output : undefined;
+}
+function isDecideSuccessValue(value) {
+    return (isRecord(value) &&
+        isNonEmptyString(value.decideCommit) &&
+        isNonEmptyString(value.evaluatedRevision) &&
+        value.noUnsettledFindings === true);
+}
+function isDecideSuccess({ event }) {
+    return isDecideSuccessValue(childOutputOf(event));
+}
+// CODE's canonical successful terminal output discriminates completion with
+// `status: 'complete'`, carries the exact last CODE-owned commit, and
+// affirms that every phase's review passed.
+function isCodeSuccessValue(value) {
+    return (isRecord(value) &&
+        value.status === 'complete' &&
+        isNonEmptyString(value.lastCodeCommit) &&
+        value.allReviewsPassed === true);
+}
+function isCodeSuccess({ event }) {
+    return isCodeSuccessValue(childOutputOf(event));
+}
+function isStateValue(value, ancestors = new Set()) {
+    if (typeof value === 'string')
+        return true;
+    if (!isRecord(value) || ancestors.has(value))
+        return false;
+    const next = new Set(ancestors).add(value);
+    return Reflect.ownKeys(value).every((key) => typeof key === 'string' &&
+        Object.prototype.propertyIsEnumerable.call(value, key) &&
+        isStateValue(value[key], next));
+}
+function isStringArray(value) {
+    return (Array.isArray(value) &&
+        Reflect.ownKeys(value).length === value.length + 1 &&
+        Reflect.ownKeys(value).every((key) => {
+            if (key === 'length')
+                return true;
+            return (typeof key === 'string' &&
+                /^(0|[1-9][0-9]*)$/.test(key) &&
+                Number(key) < value.length);
+        }) &&
+        value.every((entry) => isNonEmptyString(entry)) &&
+        new Set(value).size === value.length);
+}
+function isPlaybookState(value) {
+    if (!isRecord(value))
+        return false;
+    const allowed = new Set([
+        'value',
+        'activeStateIds',
+        'tags',
+        'status',
+        'quiescent',
+        'stateId',
+    ]);
+    if (Reflect.ownKeys(value).some((key) => typeof key !== 'string' || !allowed.has(key)) ||
+        !Object.prototype.hasOwnProperty.call(value, 'value') ||
+        !Object.prototype.hasOwnProperty.call(value, 'activeStateIds') ||
+        !Object.prototype.hasOwnProperty.call(value, 'tags') ||
+        !Object.prototype.hasOwnProperty.call(value, 'status') ||
+        !Object.prototype.hasOwnProperty.call(value, 'quiescent')) {
+        return false;
+    }
+    return (isStateValue(value.value) &&
+        isStringArray(value.activeStateIds) &&
+        isStringArray(value.tags) &&
+        (value.status === 'active' ||
+            value.status === 'done' ||
+            value.status === 'error' ||
+            value.status === 'stopped') &&
+        typeof value.quiescent === 'boolean' &&
+        (!Object.prototype.hasOwnProperty.call(value, 'stateId') ||
+            (isNonEmptyString(value.stateId) &&
+                value.activeStateIds.length === 1 &&
+                value.activeStateIds[0] === value.stateId)));
+}
+function nestedResultFromError(error) {
+    if (!(error instanceof Error))
+        return undefined;
+    const result = error.result;
+    return isRecord(result) ? result : undefined;
+}
+function normalizedChildFailure(error, playbookId) {
+    const result = nestedResultFromError(error);
+    if (result === undefined)
+        return undefined;
+    const allowed = new Set([
+        'status',
+        'playbookId',
+        'childSessionId',
+        'state',
+        'error',
+    ]);
+    if (Reflect.ownKeys(result).some((key) => typeof key !== 'string' || !allowed.has(key)) ||
+        (result.status !== 'aborted' && result.status !== 'error') ||
+        result.playbookId !== playbookId) {
+        return undefined;
+    }
+    if (Object.prototype.hasOwnProperty.call(result, 'childSessionId') &&
+        !isNonEmptyString(result.childSessionId)) {
+        return undefined;
+    }
+    if (Object.prototype.hasOwnProperty.call(result, 'state') &&
+        !isPlaybookState(result.state)) {
+        return undefined;
+    }
+    let normalizedError;
+    if (Object.prototype.hasOwnProperty.call(result, 'error')) {
+        if (!isRecord(result.error))
+            return undefined;
+        const errorKeys = Reflect.ownKeys(result.error);
+        if (errorKeys.some((key) => typeof key !== 'string' ||
+            (key !== 'name' && key !== 'message' && key !== 'stack')) ||
+            !Object.prototype.hasOwnProperty.call(result.error, 'name') ||
+            !Object.prototype.hasOwnProperty.call(result.error, 'message') ||
+            !isNonEmptyString(result.error.name) ||
+            typeof result.error.message !== 'string' ||
+            (Object.prototype.hasOwnProperty.call(result.error, 'stack') &&
+                typeof result.error.stack !== 'string')) {
+            return undefined;
+        }
+        normalizedError = {
+            name: result.error.name,
+            message: result.error.message,
+        };
+    }
+    else if (result.status === 'error') {
+        return undefined;
+    }
+    return {
+        status: result.status,
+        ...(normalizedError === undefined ? {} : { error: normalizedError }),
+    };
+}
+function authoredChildFailureGuard(playbookId) {
+    return ({ event }) => {
+        const error = isRecord(event) ? event.error : undefined;
+        return normalizedChildFailure(error, playbookId) !== undefined;
+    };
+}
+function authoredChildError(event, playbookId) {
+    const outer = isRecord(event) ? event.error : undefined;
+    const failure = normalizedChildFailure(outer, playbookId);
+    if (failure?.error !== undefined)
+        return failure.error;
+    if (failure?.status === 'aborted') {
+        return {
+            name: 'AbortError',
+            message: `${playbookId.toUpperCase()} was aborted.`,
+        };
+    }
+    if (outer instanceof Error) {
+        return { name: outer.name || 'Error', message: outer.message };
+    }
+    return { name: 'Error', message: String(outer) };
+}
+function relayedChildFailure(event, playbookId) {
+    const outer = isRecord(event) ? event.error : undefined;
+    const failure = normalizedChildFailure(outer, playbookId);
+    return {
+        playbookId,
+        status: failure?.status ?? 'error',
+        error: authoredChildError(event, playbookId),
+    };
+}
+function insufficientChildResult(event, playbookId) {
+    const output = childOutputOf(event);
+    return {
+        playbookId,
+        status: 'ok',
+        ...(output === undefined ? {} : { output: output }),
+    };
+}
+/** Consumed planning Q&A rendered for later relayed discussion context. */
+export function renderDiscussionContext(exchanges) {
+    return exchanges
+        .map((exchange) => `Analyst question: ${exchange.question}\nBoss reply: ${exchange.answer}`)
+        .join('\n\n');
+}
+function archivedExchanges(context) {
+    if (context.pendingBossQuestion === undefined ||
+        !isNonEmptyString(context.bossReply)) {
+        return context.discussionExchanges;
+    }
+    return [
+        ...context.discussionExchanges,
+        {
+            question: context.pendingBossQuestion.question,
+            answer: context.bossReply,
+        },
+    ];
+}
+function quotedRelay(values) {
+    return values
+        .filter((value) => value.length > 0)
+        .map((value) => value
+        .split('\n')
+        .map((line) => `> ${line}`)
+        .join('\n'))
+        .join('\n');
+}
+function planningRelayValues(context) {
+    return [
+        context.developmentRequest ?? '',
+        renderDiscussionContext(context.discussionExchanges),
+        context.planningResult ?? '',
+    ];
+}
+function codeCallText(context) {
+    return quotedRelay(planningRelayValues(context));
+}
+function decideCallText(context) {
+    return quotedRelay(planningRelayValues(context));
+}
+function codeAfterDecideCallText(context) {
+    return quotedRelay([
+        ...planningRelayValues(context),
+        context.decideCommit ?? '',
+        context.evaluatedRevision ?? '',
+    ]);
+}
+const machineSetup = setup({
+    types: {},
+    actors: {
+        player: fromPromise(async () => {
+            throw new Error('player actor must be provided by the runner');
+        }),
+        playbook: fromPromise(async () => {
+            throw new Error('playbook actor must be provided by the runner');
+        }),
+    },
+    guards: {
+        isDiscussionComplete,
+        isCodePath,
+        isDecideThenCode,
+        needsBossReply,
+        isCodeSuccess,
+        isDecideSuccess,
+        authoredCodeFailure: authoredChildFailureGuard('code'),
+        authoredDecideFailure: authoredChildFailureGuard('decide'),
+        emptyBossReply: ({ event }) => event.type === 'BOSS_REPLY' && event.answer.trim().length === 0,
+        resumesPlanAnalysis: ({ context, event }) => event.type === 'BOSS_REPLY' &&
+            event.answer.trim().length > 0 &&
+            context.pendingBossQuestion?.resumeStateId === 'planAnalysis' &&
+            (event.questionId === undefined || event.questionId === 'planAnalysis'),
+    },
+    actions: {
+        'playbook.acceptedOutcome': (_args, _params) => undefined,
+        startDev: assign(({ context, event }) => {
+            if (event.type !== 'START_DEV')
+                return {};
+            return {
+                runResults: context.runResults,
+                developmentRequest: event.developmentRequest,
+                discussionExchanges: [],
+                planningResult: undefined,
+                decideCommit: undefined,
+                evaluatedRevision: undefined,
+                completion: undefined,
+                childOutput: undefined,
+                childFailure: undefined,
+                lastError: undefined,
+                pendingBossQuestion: undefined,
+                bossReply: undefined,
+            };
+        }),
+        completeDiscussion: assign(({ context }) => ({
+            discussionExchanges: archivedExchanges(context),
+            completion: 'discussion-complete',
+            pendingBossQuestion: undefined,
+            bossReply: undefined,
+        })),
+        rememberCodePath: assign(({ context, event }) => ({
+            planningResult: outputString(event, 'planningResult'),
+            discussionExchanges: archivedExchanges(context),
+            pendingBossQuestion: undefined,
+            bossReply: undefined,
+        })),
+        rememberDecidePath: assign(({ context, event }) => ({
+            planningResult: outputString(event, 'planningResult'),
+            discussionExchanges: archivedExchanges(context),
+            pendingBossQuestion: undefined,
+            bossReply: undefined,
+        })),
+        rememberPendingQuestion: assign(({ context, event }) => {
+            const question = outputString(event, 'question');
+            if (question === undefined || !outputGuard(event, 'needsBossReply')) {
+                return { lastError: new Error('Analyst question output was malformed') };
+            }
+            return {
+                discussionExchanges: archivedExchanges(context),
+                pendingBossQuestion: {
+                    questionId: 'planAnalysis',
+                    resumeStateId: 'planAnalysis',
+                    sourceItem: 'DEV-1',
+                    asker: { kind: 'role', roleId: 'analyst' },
+                    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,
+        }),
+        rememberDecideResult: assign(({ event }) => {
+            const output = childOutputOf(event);
+            if (!isDecideSuccessValue(output))
+                return {};
+            return {
+                decideCommit: output.decideCommit,
+                evaluatedRevision: output.evaluatedRevision,
+            };
+        }),
+        completeWithChildSuccess: assign(({ event }) => {
+            const output = childOutputOf(event);
+            return {
+                completion: 'complete',
+                ...(output === undefined ? {} : { childOutput: output }),
+            };
+        }),
+        completeWithInsufficientCodeResult: assign(({ event }) => ({
+            completion: 'child-failed',
+            childFailure: insufficientChildResult(event, 'code'),
+        })),
+        completeWithInsufficientDecideResult: assign(({ event }) => ({
+            completion: 'child-failed',
+            childFailure: insufficientChildResult(event, 'decide'),
+        })),
+        completeWithCodeFailure: assign(({ event }) => ({
+            completion: 'child-failed',
+            childFailure: relayedChildFailure(event, 'code'),
+        })),
+        completeWithDecideFailure: assign(({ event }) => ({
+            completion: 'child-failed',
+            childFailure: relayedChildFailure(event, 'decide'),
+        })),
+        rememberActorError: assign(({ event }) => ({
+            lastError: event.error,
+        })),
+        rememberMalformedPlayerOutput: assign({
+            lastError: () => new Error('Analyst result for DEV-1 did not match an available outcome.'),
+        }),
+    },
+});
+export const devMachine = machineSetup.createMachine({
+    id: 'dev',
+    initial: 'ready',
+    context: ({ input }) => ({
+        runResults: typeof input.runResults === 'string' ? input.runResults : '',
+        discussionExchanges: [],
+    }),
+    output: ({ context }) => {
+        if (context.completion === 'discussion-complete') {
+            return { status: 'discussion-complete' };
+        }
+        if (context.completion === 'complete') {
+            return {
+                status: 'complete',
+                childPlaybookId: 'code',
+                ...(context.childOutput === undefined
+                    ? {}
+                    : { childOutput: context.childOutput }),
+            };
+        }
+        if (context.completion === 'child-failed') {
+            if (context.childFailure === undefined) {
+                throw new Error('DEV reached a final state without a child result');
+            }
+            return { status: 'child-failed', childResult: context.childFailure };
+        }
+        throw new Error('DEV reached a final state without a recorded completion');
+    },
+    states: {
+        ready: {
+            id: 'ready',
+            description: STATE_DESCRIPTIONS.ready,
+            meta: playbookMeta('ready'),
+            tags: ['playbook.parked'],
+            on: {
+                START_DEV: { target: 'planAnalysis', actions: 'startDev' },
+            },
+        },
+        planAnalysis: {
+            id: 'planAnalysis',
+            description: STATE_DESCRIPTIONS.planAnalysis,
+            meta: playbookMeta('planAnalysis', 'analyst'),
+            tags: ['playbook.busy'],
+            invoke: {
+                src: 'player',
+                input: ({ context }) => ({
+                    stateId: 'planAnalysis',
+                    role: 'analyst',
+                    sourceItem: 'DEV-1',
+                    prompt: PLAN_ANALYSIS_PROMPT,
+                    result: PLAN_ANALYSIS_RESULTS,
+                    developmentRequest: context.developmentRequest ?? '',
+                    discussionContext: renderDiscussionContext(context.discussionExchanges),
+                    runResults: context.runResults,
+                    ...(context.pendingBossQuestion === undefined
+                        ? {}
+                        : { pendingBossQuestion: context.pendingBossQuestion }),
+                    ...(context.bossReply === undefined
+                        ? {}
+                        : { bossReply: context.bossReply }),
+                }),
+                onDone: [
+                    {
+                        guard: 'isDiscussionComplete',
+                        target: 'discussionComplete',
+                        actions: [
+                            {
+                                type: 'playbook.acceptedOutcome',
+                                params: {
+                                    source: 'planAnalysis',
+                                    target: 'discussionComplete',
+                                    acceptedOutcome: 'discussionComplete',
+                                },
+                            },
+                            'completeDiscussion',
+                        ],
+                    },
+                    {
+                        guard: 'isCodePath',
+                        target: 'callCode',
+                        actions: [
+                            {
+                                type: 'playbook.acceptedOutcome',
+                                params: {
+                                    source: 'planAnalysis',
+                                    target: 'callCode',
+                                    acceptedOutcome: 'code',
+                                },
+                            },
+                            'rememberCodePath',
+                        ],
+                    },
+                    {
+                        guard: 'isDecideThenCode',
+                        target: 'callDecide',
+                        actions: [
+                            {
+                                type: 'playbook.acceptedOutcome',
+                                params: {
+                                    source: 'planAnalysis',
+                                    target: 'callDecide',
+                                    acceptedOutcome: 'decideThenCode',
+                                },
+                            },
+                            'rememberDecidePath',
+                        ],
+                    },
+                    {
+                        guard: 'needsBossReply',
+                        target: 'awaitBossReply',
+                        actions: [
+                            {
+                                type: 'playbook.acceptedOutcome',
+                                params: {
+                                    source: 'planAnalysis',
+                                    target: 'awaitBossReply',
+                                    acceptedOutcome: 'needsBossReply',
+                                },
+                            },
+                            'rememberPendingQuestion',
+                        ],
+                    },
+                    {
+                        target: 'failed',
+                        actions: 'rememberMalformedPlayerOutput',
+                    },
+                ],
+                onError: { target: 'failed', actions: 'rememberActorError' },
+            },
+        },
+        callCode: {
+            id: 'callCode',
+            description: STATE_DESCRIPTIONS.callCode,
+            meta: playbookMeta('callCode'),
+            tags: ['playbook.suspended'],
+            invoke: {
+                src: 'playbook',
+                input: ({ context }) => ({
+                    stateId: 'callCode',
+                    sourceItem: 'DEV-2',
+                    playbookId: 'code',
+                    text: codeCallText(context),
+                }),
+                onDone: [
+                    {
+                        guard: 'isCodeSuccess',
+                        target: 'done',
+                        actions: 'completeWithChildSuccess',
+                    },
+                    {
+                        target: 'reportedChildFailure',
+                        actions: 'completeWithInsufficientCodeResult',
+                    },
+                ],
+                onError: [
+                    {
+                        guard: 'authoredCodeFailure',
+                        target: 'reportedChildFailure',
+                        actions: 'completeWithCodeFailure',
+                    },
+                    { target: 'failed', actions: 'rememberActorError' },
+                ],
+            },
+        },
+        callDecide: {
+            id: 'callDecide',
+            description: STATE_DESCRIPTIONS.callDecide,
+            meta: playbookMeta('callDecide'),
+            tags: ['playbook.suspended'],
+            invoke: {
+                src: 'playbook',
+                input: ({ context }) => ({
+                    stateId: 'callDecide',
+                    sourceItem: 'DEV-3',
+                    playbookId: 'decide',
+                    text: decideCallText(context),
+                }),
+                onDone: [
+                    {
+                        guard: 'isDecideSuccess',
+                        target: 'callCodeAfterDecide',
+                        actions: 'rememberDecideResult',
+                    },
+                    {
+                        target: 'reportedChildFailure',
+                        actions: 'completeWithInsufficientDecideResult',
+                    },
+                ],
+                onError: [
+                    {
+                        guard: 'authoredDecideFailure',
+                        target: 'reportedChildFailure',
+                        actions: 'completeWithDecideFailure',
+                    },
+                    { target: 'failed', actions: 'rememberActorError' },
+                ],
+            },
+        },
+        callCodeAfterDecide: {
+            id: 'callCodeAfterDecide',
+            description: STATE_DESCRIPTIONS.callCodeAfterDecide,
+            meta: playbookMeta('callCodeAfterDecide'),
+            tags: ['playbook.suspended'],
+            invoke: {
+                src: 'playbook',
+                input: ({ context }) => ({
+                    stateId: 'callCodeAfterDecide',
+                    sourceItem: 'DEV-4',
+                    playbookId: 'code',
+                    text: codeAfterDecideCallText(context),
+                }),
+                onDone: [
+                    {
+                        guard: 'isCodeSuccess',
+                        target: 'done',
+                        actions: 'completeWithChildSuccess',
+                    },
+                    {
+                        target: 'reportedChildFailure',
+                        actions: 'completeWithInsufficientCodeResult',
+                    },
+                ],
+                onError: [
+                    {
+                        guard: 'authoredCodeFailure',
+                        target: 'reportedChildFailure',
+                        actions: 'completeWithCodeFailure',
+                    },
+                    { 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: 'resumesPlanAnalysis',
+                        target: '#planAnalysis',
+                        reenter: true,
+                        actions: 'rememberBossReply',
+                    },
+                ],
+                START_DEV: { target: 'planAnalysis', actions: 'startDev' },
+            },
+        },
+        failed: {
+            id: 'failed',
+            description: STATE_DESCRIPTIONS.failed,
+            meta: playbookMeta('failed'),
+            tags: ['playbook.parked'],
+            on: {
+                START_DEV: { target: 'planAnalysis', actions: 'startDev' },
+            },
+        },
+        discussionComplete: {
+            id: 'discussionComplete',
+            description: STATE_DESCRIPTIONS.discussionComplete,
+            meta: playbookMeta('discussionComplete'),
+            type: 'final',
+        },
+        done: {
+            id: 'done',
+            description: STATE_DESCRIPTIONS.done,
+            meta: playbookMeta('done'),
+            type: 'final',
+        },
+        reportedChildFailure: {
+            id: 'reportedChildFailure',
+            description: STATE_DESCRIPTIONS.reportedChildFailure,
+            meta: playbookMeta('reportedChildFailure'),
+            type: 'final',
+        },
+    },
+});
+export default devMachine;