@petepetrash/circuit 0.1.0

package/dist/schemas/flow-block-definitions.js

@@ -0,0 +1,867 @@
+import { FlowBlockCatalog, } from './flow-blocks.js';
+import { CANONICAL_STAGES } from './stage.js';
+const BASE_REQUIRED_AUTHORING_FIELDS = [
+    'id',
+    'title',
+    'stage',
+    'input',
+    'routes',
+    'protocol',
+    'writes',
+    'check',
+];
+const EXECUTION_REQUIRED_AUTHORING_FIELDS = {
+    relay: ['relay_role'],
+    checkpoint: ['checkpoint_policy'],
+    fanout: ['fanout'],
+    'sub-run': ['sub_run_ref', 'sub_run_goal', 'sub_run_depth'],
+};
+function conservativeAuthoringPolicy(schematicPolicy) {
+    const executionKind = schematicPolicy.executionKinds.length === 1 ? schematicPolicy.executionKinds[0] : undefined;
+    return {
+        defaults: {
+            evidenceRequirements: 'block-produces-evidence',
+            output: 'block-output-contract',
+            ...(executionKind === undefined ? {} : { executionKind }),
+        },
+        required: {
+            always: BASE_REQUIRED_AUTHORING_FIELDS,
+            whenExecutionKind: EXECUTION_REQUIRED_AUTHORING_FIELDS,
+        },
+    };
+}
+function defineFlowBlockDefinition(definition) {
+    return {
+        ...definition,
+        authoringPolicy: conservativeAuthoringPolicy(definition.schematicPolicy),
+    };
+}
+const FLOW_BLOCK_DEFINITION_INPUTS = [
+    {
+        id: 'intake',
+        title: 'Intake',
+        purpose: "Capture the user's goal, requested mode, explicit flow choice, and immediate constraints.",
+        input_contracts: ['user.goal@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'task.intake@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['normalized goal', 'requested flow', 'operator constraints'],
+        check: {
+            kind: 'schema',
+            description: "The normalized task must preserve the user's goal and expose any explicit flow or mode choice.",
+        },
+        allowed_routes: ['continue', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['frame'],
+        },
+    },
+    {
+        id: 'route',
+        title: 'Route',
+        purpose: 'Choose the flow or schematic path from the normalized task.',
+        input_contracts: ['task.intake@v1', 'flow.catalog@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'route.decision@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['selected flow', 'selection reason', 'fallback reason when conservative'],
+        check: {
+            kind: 'schema',
+            description: 'The route decision must name one known flow or stop with an explicit reason.',
+        },
+        allowed_routes: ['continue', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['frame'],
+        },
+    },
+    {
+        id: 'frame',
+        title: 'Frame',
+        purpose: 'Define the work boundary, constraints, and proof needed for the selected path.',
+        input_contracts: ['task.intake@v1', 'route.decision@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'flow.brief@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['scope boundary', 'constraints', 'proof plan'],
+        check: {
+            kind: 'schema',
+            description: 'The brief must state what is in scope, what is out of scope, and how success will be proved.',
+        },
+        allowed_routes: ['continue', 'revise', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['frame'],
+        },
+    },
+    {
+        id: 'clarify',
+        title: 'Clarify',
+        purpose: 'Turn a rough operator request into a clear task for the selected flow.',
+        input_contracts: ['task.intake@v1', 'route.decision@v1'],
+        alternative_input_contracts: [['task.intake@v1']],
+        output_contract: 'clarified.task@v1',
+        action_surface: 'worker',
+        produces_evidence: [
+            'original request',
+            'clarified task',
+            'desired outcome',
+            'proof needed',
+            'constraints',
+            'scope',
+            'assumptions',
+            'missing information',
+            'stop conditions',
+        ],
+        check: {
+            kind: 'schema',
+            description: 'The clarified task must preserve the operator request, name the outcome, identify proof, and separate assumptions from missing information.',
+        },
+        allowed_routes: ['continue', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['relay'],
+            stages: ['frame'],
+        },
+    },
+    {
+        id: 'human-decision',
+        title: 'Human Decision',
+        purpose: 'Ask the operator a bounded question and record the answer as flow evidence.',
+        input_contracts: ['flow.question@v1', 'flow.evidence@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'decision.answer@v1',
+        action_surface: 'host',
+        produces_evidence: ['question', 'available options', 'selected option', 'answer source'],
+        check: {
+            kind: 'decision',
+            description: 'The selected option must be one of the declared options or the run must pause, stop, or fail clearly.',
+        },
+        allowed_routes: ['continue', 'revise', 'stop', 'handoff', 'escalate'],
+        human_interaction: 'mode-dependent',
+        host_capabilities: {
+            claude: ['AskUserQuestion or native user-question tool when available'],
+            codex: ['native interactive question mechanism when available'],
+            non_interactive: ['use declared default', 'pause', 'fail clearly'],
+        },
+        schematicPolicy: {
+            executionKinds: ['checkpoint'],
+            stages: CANONICAL_STAGES,
+        },
+    },
+    {
+        id: 'gather-context',
+        title: 'Gather Context',
+        purpose: 'Collect relevant facts, files, commands, or references before deciding or acting.',
+        input_contracts: ['flow.brief@v1', 'context.request@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'context.packet@v1',
+        action_surface: 'worker',
+        produces_evidence: ['source list', 'observations', 'confidence notes'],
+        check: {
+            kind: 'schema',
+            description: 'The context packet must cite its sources and separate observed facts from interpretation.',
+        },
+        allowed_routes: ['continue', 'retry', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['relay', 'compose', 'fanout'],
+            stages: ['analyze'],
+        },
+    },
+    {
+        id: 'diagnose',
+        title: 'Diagnose',
+        purpose: 'Explain what is broken, unknown, risky, or likely causing the observed behavior.',
+        input_contracts: ['flow.brief@v1', 'context.packet@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'diagnosis.result@v1',
+        action_surface: 'worker',
+        produces_evidence: ['cause hypothesis', 'confidence', 'reproduction status', 'diagnostic path'],
+        check: {
+            kind: 'schema',
+            description: 'The diagnosis must distinguish known facts, hypotheses, and unresolved questions.',
+        },
+        allowed_routes: ['continue', 'retry', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['relay', 'compose', 'fanout'],
+            stages: ['analyze'],
+        },
+    },
+    {
+        id: 'plan',
+        title: 'Plan',
+        purpose: 'Choose a bounded implementation, investigation, or migration path.',
+        input_contracts: ['flow.brief@v1', 'context.packet@v1', 'diagnosis.result@v1'],
+        alternative_input_contracts: [['flow.brief@v1'], ['flow.brief@v1', 'context.packet@v1']],
+        output_contract: 'plan.strategy@v1',
+        action_surface: 'worker',
+        produces_evidence: ['ordered steps', 'risk notes', 'proof strategy'],
+        check: {
+            kind: 'schema',
+            description: 'The plan must name concrete steps, expected proof, and known risks.',
+        },
+        allowed_routes: ['continue', 'revise', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['relay', 'compose', 'fanout'],
+            stages: ['plan'],
+        },
+    },
+    {
+        id: 'act',
+        title: 'Act',
+        purpose: 'Make or delegate the change within the declared scope.',
+        input_contracts: ['flow.brief@v1', 'diagnosis.result@v1'],
+        alternative_input_contracts: [
+            ['flow.brief@v1', 'plan.strategy@v1'],
+            ['flow.brief@v1', 'plan.strategy@v1', 'diagnosis.result@v1'],
+        ],
+        output_contract: 'change.evidence@v1',
+        action_surface: 'worker',
+        produces_evidence: ['changed files', 'change rationale', 'declared follow-up proof'],
+        check: {
+            kind: 'schema',
+            description: 'The action evidence must name what changed and why it stays inside scope.',
+        },
+        allowed_routes: ['continue', 'retry', 'ask', 'stop', 'handoff'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['relay', 'compose', 'fanout'],
+            // 'plan' is included because Explore runs its genuine implementer
+            // synthesis (synthesize-step) inside its canonical plan stage: Explore
+            // omits the act/verify/review canonical stages (EXPLORE-I1), so the act
+            // that composes the recommendation is runtime-locked to the plan stage.
+            // This mirrors the same widening already applied to the review block for
+            // Explore's review-step. See src/flows/explore/contract.md.
+            stages: ['act', 'plan'],
+        },
+    },
+    {
+        id: 'run-verification',
+        title: 'Run Verification',
+        purpose: 'Run declared proof commands or checks and capture their result.',
+        input_contracts: ['verification.plan@v1', 'change.evidence@v1'],
+        alternative_input_contracts: [['verification.plan@v1']],
+        output_contract: 'verification.result@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['command list', 'exit status', 'bounded output', 'pass or fail'],
+        check: {
+            kind: 'command',
+            description: 'Each verification command must have a captured exit status and bounded output.',
+        },
+        allowed_routes: ['continue', 'retry', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['verification'],
+            stages: ['verify'],
+        },
+    },
+    {
+        id: 'review',
+        title: 'Review',
+        purpose: 'Judge whether the result satisfies the brief and whether any fixes are required.',
+        input_contracts: ['flow.brief@v1', 'change.evidence@v1', 'verification.result@v1'],
+        alternative_input_contracts: [['flow.brief@v1'], ['flow.brief@v1', 'change.evidence@v1']],
+        output_contract: 'review.verdict@v1',
+        action_surface: 'worker',
+        produces_evidence: ['verdict', 'findings', 'confidence', 'required fixes'],
+        check: {
+            kind: 'review',
+            description: 'The verdict must be one of the declared review outcomes and must include findings when it blocks.',
+        },
+        allowed_routes: ['continue', 'connector-failed', 'retry', 'revise', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['relay', 'compose', 'fanout'],
+            // 'plan' is included because Explore runs a genuine reviewer pass
+            // (review-step) inside its canonical plan stage: Explore omits the
+            // act/verify/review canonical stages (EXPLORE-I1), so its adversarial
+            // review of the synthesized composition is runtime-locked to the plan
+            // stage. See src/flows/explore/contract.md.
+            stages: ['review', 'analyze', 'plan'],
+        },
+    },
+    {
+        id: 'goal',
+        title: 'Goal',
+        purpose: 'Turn a user objective into a bounded goal contract with proof, recovery, and safety-review policy.',
+        input_contracts: ['task.intake@v1', 'route.decision@v1'],
+        alternative_input_contracts: [['task.intake@v1']],
+        output_contract: 'goal.contract@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: [
+            'goal contract',
+            'done claims',
+            'proof requirements',
+            'allowed flow targets',
+            'recovery routes',
+            'safety review policy',
+        ],
+        check: {
+            kind: 'schema',
+            description: 'The goal contract must preserve the operator objective, declare proof requirements, constrain flow targets, and name recovery and close rules.',
+        },
+        allowed_routes: ['continue', 'ask', 'stop', 'fix', 'build', 'review', 'explore', 'pursue'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run'],
+            stages: ['frame'],
+        },
+    },
+    {
+        id: 'goal-child-run',
+        title: 'Goal Child Run',
+        purpose: 'Run the statically selected child flow for the goal contract and capture its result as a goal attempt input.',
+        input_contracts: ['goal.contract@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'goal.child-run@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['static child flow target', 'child result file', 'parent trace link'],
+        check: {
+            kind: 'schema',
+            description: 'The child run must record which static flow target ran and where its result and reports landed.',
+        },
+        allowed_routes: ['continue', 'stop'],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['sub-run'],
+            stages: ['act'],
+        },
+    },
+    {
+        id: 'goal-attempt',
+        title: 'Goal Attempt',
+        purpose: 'Summarize one child-flow attempt against the goal contract into a typed attempt record.',
+        input_contracts: ['goal.contract@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'goal.attempt@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['child result path', 'child report paths', 'attempt outcome'],
+        check: {
+            kind: 'schema',
+            description: 'The attempt must name the flow target, point at the child result, and state an outcome.',
+        },
+        allowed_routes: ['continue', 'stop'],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose'],
+            stages: ['act'],
+        },
+    },
+    {
+        id: 'goal-evaluate',
+        title: 'Goal Evaluate',
+        purpose: 'Compare attempt evidence to the goal contract done claims and choose the next typed route.',
+        input_contracts: ['goal.contract@v1', 'goal.attempt@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'goal.evidence-evaluation@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['claim results', 'evidence gaps', 'next typed route'],
+        check: {
+            kind: 'schema',
+            description: 'The evaluation must report each done-claim result, name remaining evidence gaps, and select one typed next route.',
+        },
+        allowed_routes: [
+            'continue',
+            'completion-gate',
+            'retry-selected-flow',
+            'run-fix',
+            'run-review',
+            'run-explore',
+            'split-to-pursue',
+            'checkpoint',
+            'handoff',
+            'blocked',
+            'stop',
+        ],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose'],
+            stages: ['verify'],
+        },
+    },
+    {
+        id: 'goal-recover',
+        title: 'Goal Recover',
+        purpose: 'Choose a typed recovery action when the goal attempt did not satisfy the contract.',
+        input_contracts: ['goal.evidence-evaluation@v1', 'goal.attempt@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'goal.recovery@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['recovery reason', 'selected route', 'operator input need'],
+        check: {
+            kind: 'schema',
+            description: 'The recovery must give a reason, select one typed route, and state whether operator input is needed.',
+        },
+        allowed_routes: [
+            'continue',
+            'retry-selected-flow',
+            'run-fix',
+            'run-review',
+            'run-explore',
+            'split-to-pursue',
+            'checkpoint',
+            'blocked',
+            'handoff',
+            'stop',
+        ],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose'],
+            stages: ['verify'],
+        },
+    },
+    {
+        id: 'goal-checkpoint',
+        title: 'Goal Checkpoint',
+        purpose: 'Pause for operator judgment on a goal recovery decision and record the chosen option.',
+        input_contracts: ['flow.question@v1', 'goal.recovery@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'goal.checkpoint@v1',
+        action_surface: 'host',
+        produces_evidence: ['question', 'available options', 'selected option', 'answer source'],
+        check: {
+            kind: 'decision',
+            description: 'The selected option must be one of the declared options or the run must pause, stop, or hand off clearly.',
+        },
+        allowed_routes: ['continue', 'blocked', 'handoff', 'stop'],
+        human_interaction: 'required',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['checkpoint'],
+            stages: ['verify'],
+        },
+    },
+    {
+        id: 'goal-gate-review',
+        title: 'Goal Gate Review',
+        purpose: 'Run one safety-review pass over the goal evaluation before the run is allowed to close.',
+        input_contracts: ['goal.contract@v1', 'goal.evidence-evaluation@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'goal.gate-review@v1',
+        action_surface: 'worker',
+        produces_evidence: ['safety review pass', 'review lens', 'evidence checked'],
+        check: {
+            kind: 'review',
+            description: 'Each gate pass must record the review lens applied and the evidence it checked.',
+        },
+        // The gate-pass items route from the reviewer's report: route_from_report
+        // reads `next_route`, whose schema enum (GoalGate.next_route) is exactly
+        // {run-next-gate-pass, recover, close}. So those three are the routes this
+        // block actually emits at runtime, plus retry/stop as the failed-check
+        // recovery and terminal fallbacks (continue survives as the compiled `pass`
+        // twin the relay returns on a clean check in tests). allowed_routes lists the
+        // full declared vocabulary so the catalog model matches the items instead of
+        // claiming routes the block never uses. recover and run-next-gate-pass are
+        // flow-specific (not NORMAL, not recovery-bound), so they must be listed
+        // explicitly; gate-recognition reconciliation already clears close (NORMAL),
+        // retry, and stop (recovery-bound).
+        allowed_routes: ['continue', 'run-next-gate-pass', 'recover', 'retry', 'close', 'stop'],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['relay'],
+            stages: ['review'],
+        },
+    },
+    {
+        id: 'goal-close',
+        title: 'Goal Close',
+        purpose: 'Emit the final goal result from the contract, attempt, and evaluation reports.',
+        input_contracts: ['goal.contract@v1', 'goal.attempt@v1', 'goal.evidence-evaluation@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'goal.result@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['outcome', 'evidence pointers', 'residual risks', 'follow-ups'],
+        check: {
+            kind: 'schema',
+            description: 'The goal result must state the outcome, point at evidence, and name residual risks and follow-ups.',
+        },
+        allowed_routes: ['complete', 'stop'],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose'],
+            stages: ['close'],
+        },
+    },
+    {
+        id: 'pursue',
+        title: 'Pursue',
+        purpose: 'Turn a rough operator idea into a bounded autonomous ownership contract.',
+        input_contracts: ['task.intake@v1', 'route.decision@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'pursuit.contract@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: [
+            'ownership contract',
+            'estimated touch set',
+            'proof plan',
+            'check-in triggers',
+        ],
+        check: {
+            kind: 'schema',
+            description: 'The pursuit contract must preserve the operator goal, declare scope, estimate likely touch points, and name when Circuit should check in.',
+        },
+        allowed_routes: ['continue', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['frame'],
+        },
+    },
+    {
+        id: 'coordinate-pursuits',
+        title: 'Coordinate Pursuits',
+        purpose: 'Prioritize multiple pursuit contracts by dependency, conflict risk, and safe composition.',
+        input_contracts: ['pursuit.contract@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'pursuit.graph@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: [
+            'dependency graph',
+            'conflict analysis',
+            'serial groups',
+            'parallel read-only groups',
+        ],
+        check: {
+            kind: 'coordination',
+            description: 'The graph must account for every pursuit and explain which work serializes, which discovery can run in parallel, and why.',
+        },
+        allowed_routes: ['continue', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['plan'],
+        },
+    },
+    {
+        id: 'queue',
+        title: 'Queue',
+        purpose: 'Turn broad work into ordered items with state and risk class.',
+        input_contracts: ['flow.brief@v1', 'context.packet@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'work.queue@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['ordered items', 'item state', 'risk class', 'selection rule'],
+        check: {
+            kind: 'queue',
+            description: 'Each queue item must have an identifier, state, and reason it belongs in the queue.',
+        },
+        allowed_routes: ['continue', 'ask', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['plan'],
+        },
+    },
+    {
+        id: 'batch',
+        title: 'Batch',
+        purpose: 'Process a bounded set of queue items and record what completed, skipped, blocked, or failed.',
+        input_contracts: ['work.queue@v1', 'flow.brief@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'batch.result@v1',
+        action_surface: 'mixed',
+        produces_evidence: ['completed items', 'skipped items', 'blocked items', 'failed items'],
+        check: {
+            kind: 'schema',
+            description: 'The batch result must account for every selected item exactly once.',
+        },
+        allowed_routes: ['continue', 'retry', 'ask', 'stop', 'handoff'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            // 'relay' is included because Pursue's batch-step delegates each work
+            // item to an implementer-role worker (a relay), which the pursue runtime
+            // wiring locks in. Batch already declares multiple kinds, so the
+            // single-kind authoring default stays undefined and the widening is
+            // runtime byte-identical.
+            executionKinds: ['compose', 'relay', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['act'],
+        },
+    },
+    {
+        id: 'risk-rollback-check',
+        title: 'Risk/Rollback Check',
+        purpose: 'Decide whether continuing is safe and what recovery path exists if it is not.',
+        input_contracts: ['change.evidence@v1', 'verification.result@v1', 'flow.brief@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'risk.decision@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['risk class', 'allowed next action', 'recovery option'],
+        check: {
+            kind: 'risk',
+            description: 'The decision must explicitly allow, split, stop, hand off, or escalate the next action.',
+        },
+        allowed_routes: ['continue', 'split', 'ask', 'stop', 'handoff', 'escalate'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'relay', 'verification', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['verify', 'close'],
+        },
+    },
+    {
+        id: 'close-with-evidence',
+        title: 'Close With Evidence',
+        purpose: 'End the run honestly with outcome, evidence pointers, and residual risks.',
+        input_contracts: ['flow.brief@v1', 'verification.result@v1', 'review.verdict@v1'],
+        alternative_input_contracts: [
+            ['flow.brief@v1', 'verification.result@v1'],
+            ['flow.brief@v1', 'review.verdict@v1'],
+            ['flow.brief@v1'],
+        ],
+        output_contract: 'flow.result@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['outcome', 'evidence pointers', 'residual risks', 'follow-ups'],
+        check: {
+            kind: 'schema',
+            description: 'The final result must align with the evidence and cannot report completion when a stop, handoff, or escalation route was selected.',
+        },
+        allowed_routes: ['complete', 'stop', 'handoff', 'escalate'],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['close'],
+        },
+    },
+    {
+        id: 'handoff',
+        title: 'Handoff',
+        purpose: 'Persist enough state for a later session to resume with context and next action.',
+        input_contracts: ['flow.state@v1', 'flow.brief@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'continuity.record@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['goal', 'completed moves', 'pending evidence', 'next action', 'known debt'],
+        check: {
+            kind: 'schema',
+            description: 'The handoff record must contain enough state for a later run to continue without relying on chat memory.',
+        },
+        allowed_routes: ['complete', 'stop'],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose', 'checkpoint', 'sub-run', 'fanout'],
+            stages: ['close'],
+        },
+    },
+    {
+        id: 'review-intake',
+        title: 'Review Intake',
+        purpose: 'Frame an independent review: fix the audit scope and capture the working-tree state to review against.',
+        input_contracts: ['task.intake@v1', 'route.decision@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'review.intake@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['scope boundary', 'working tree status', 'diff or unavailable reason'],
+        check: {
+            kind: 'schema',
+            description: 'The intake must state what is in scope for the review and record the working tree state, or why a diff is unavailable.',
+        },
+        allowed_routes: ['continue', 'stop'],
+        human_interaction: 'optional',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose'],
+            stages: ['frame'],
+        },
+    },
+    {
+        id: 'prototype-variant-evidence',
+        title: 'Prototype Variant Evidence',
+        purpose: 'Compose the provider evidence for the model-comparison variants before the variants are verified.',
+        input_contracts: ['flow.brief@v1', 'plan.strategy@v1', 'change.evidence@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'prototype.variant-provider-evidence@v1',
+        action_surface: 'orchestrator',
+        produces_evidence: ['captured variant count', 'per-variant provider evidence'],
+        check: {
+            kind: 'schema',
+            description: 'The provider evidence must record how many variants were captured and attribute the evidence to each variant.',
+        },
+        allowed_routes: ['complete', 'stop'],
+        human_interaction: 'never',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['compose'],
+            stages: ['verify'],
+        },
+    },
+    {
+        id: 'prototype-checkpoint',
+        title: 'Prototype Checkpoint',
+        purpose: 'Pause for the operator to decide what to do with a built and verified prototype artifact.',
+        input_contracts: ['change.evidence@v1', 'verification.result@v1'],
+        alternative_input_contracts: [],
+        output_contract: 'prototype.checkpoint@v1',
+        action_surface: 'host',
+        produces_evidence: ['question', 'available options', 'selected option', 'answer source'],
+        check: {
+            kind: 'decision',
+            description: 'The selected option must be one of the declared prototype dispositions or the run must pause or stop clearly.',
+        },
+        allowed_routes: ['continue', 'stop'],
+        human_interaction: 'mode-dependent',
+        host_capabilities: {
+            claude: [],
+            codex: [],
+            non_interactive: [],
+        },
+        schematicPolicy: {
+            executionKinds: ['checkpoint'],
+            stages: ['review'],
+        },
+    },
+];
+export const FLOW_BLOCK_DEFINITIONS = FLOW_BLOCK_DEFINITION_INPUTS.map(defineFlowBlockDefinition);
+function blockCatalogEntry(definition) {
+    const { authoringPolicy: _authoringPolicy, schematicPolicy: _schematicPolicy, ...block } = definition;
+    return block;
+}
+export const FLOW_BLOCK_CATALOG = FlowBlockCatalog.parse({
+    schema_version: '1',
+    blocks: FLOW_BLOCK_DEFINITIONS.map(blockCatalogEntry),
+});
+const flowBlockSchematicPolicy = {};
+const flowBlockAuthoringPolicy = {};
+for (const definition of FLOW_BLOCK_DEFINITIONS) {
+    flowBlockSchematicPolicy[definition.id] = definition.schematicPolicy;
+    flowBlockAuthoringPolicy[definition.id] = definition.authoringPolicy;
+}
+export const FLOW_BLOCK_SCHEMATIC_POLICY = flowBlockSchematicPolicy;
+export const FLOW_BLOCK_AUTHORING_POLICY = flowBlockAuthoringPolicy;
+//# sourceMappingURL=flow-block-definitions.js.map