@petepetrash/circuit 0.1.0

package/dist/flows/converge-proof/data.d.ts

@@ -0,0 +1,412 @@
+export declare const convergeProofFlowData: {
+    id: string;
+    visibility: "internal";
+    paths: {
+        schematic: string;
+    };
+    schematic: {
+        schema_version: "2";
+        id: string & import("zod").$brand<"CompiledFlowId">;
+        title: string;
+        purpose: string;
+        status: "deprecated" | "candidate" | "active";
+        starts_at: string & import("zod").$brand<"StepId">;
+        initial_contracts: string[];
+        contract_aliases: {
+            generic: string;
+            actual: string;
+        }[];
+        items: {
+            id: string & import("zod").$brand<"StepId">;
+            block: "handoff" | "goal" | "route" | "review" | "frame" | "plan" | "act" | "intake" | "clarify" | "human-decision" | "gather-context" | "diagnose" | "run-verification" | "goal-child-run" | "goal-attempt" | "goal-evaluate" | "goal-recover" | "goal-checkpoint" | "goal-gate-review" | "goal-close" | "pursue" | "coordinate-pursuits" | "queue" | "batch" | "risk-rollback-check" | "close-with-evidence" | "review-intake" | "prototype-variant-evidence" | "prototype-checkpoint";
+            title: string;
+            stage: "review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close";
+            input: Record<string, string>;
+            optional_inputs: string[];
+            output: string;
+            evidence_requirements: string[];
+            execution: {
+                kind: "compose";
+            } | {
+                kind: "relay";
+                role: "researcher" | "implementer" | "reviewer";
+                connector?: string | undefined;
+            } | {
+                kind: "verification";
+            } | {
+                kind: "checkpoint";
+            } | {
+                kind: "sub-run";
+                flow_ref: {
+                    flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                    entry_mode: string;
+                    version?: string | undefined;
+                };
+                goal: string;
+                depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+            } | {
+                kind: "fanout";
+            };
+            skill_slots: {
+                id: string & import("zod").$brand<"SkillSlotId">;
+                description: string;
+            }[];
+            routes: Record<string, (string & import("zod").$brand<"StepId">) | "@complete" | "@stop" | "@handoff" | "@escalate">;
+            route_overrides: Record<string, Partial<Record<"low" | "medium" | "high" | "tournament" | "autonomous", (string & import("zod").$brand<"StepId">) | "@complete" | "@stop" | "@handoff" | "@escalate">>>;
+            selection?: {
+                skills: {
+                    mode: "inherit";
+                } | {
+                    mode: "replace";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                } | {
+                    mode: "append";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                } | {
+                    mode: "remove";
+                    skills: (string & import("zod").$brand<"SkillId">)[];
+                };
+                invocation_options: import("../../index.js").JsonObject;
+                model?: {
+                    provider: "custom" | "openai" | "anthropic" | "gemini";
+                    model: string;
+                } | undefined;
+                effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+            } | undefined;
+            equipment_scope?: {
+                tools: {
+                    allow: string[];
+                } | "full";
+                enforcement: "trusted" | "enforced";
+            } | undefined;
+            route_from_report?: {
+                path: string[];
+            } | undefined;
+            protocol?: (string & import("zod").$brand<"ProtocolId">) | undefined;
+            writes?: {
+                report_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                request_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                receipt_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                result_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                branches_dir_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                checkpoint_request_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+                checkpoint_response_path?: (string & import("zod").$brand<"RunRelativePath">) | undefined;
+            } | undefined;
+            check?: {
+                required?: string[] | undefined;
+                allow?: string[] | undefined;
+                allow_from?: {
+                    kind: "policy_choices";
+                } | undefined;
+                pass?: string[] | undefined;
+            } | undefined;
+            acceptance_criteria?: {
+                checks: ({
+                    kind: "command";
+                    id: string;
+                    command: {
+                        id: string;
+                        cwd: string;
+                        argv: string[];
+                        timeout_ms: number;
+                        max_output_bytes: number;
+                        env: Record<string, string>;
+                    };
+                    expected_status: "passed";
+                } | {
+                    kind: "report_field";
+                    id: string;
+                    path: string[];
+                    predicate: "present" | "non_empty" | "changed_on_disk";
+                })[];
+                on_failure: {
+                    mode: "hard-fail";
+                } | {
+                    mode: "retry-with-feedback";
+                };
+            } | undefined;
+            checkpoint_policy?: {
+                prompt: string;
+                choices?: {
+                    id: string;
+                    label?: string | undefined;
+                    description?: string | undefined;
+                }[] | undefined;
+                choices_from?: {
+                    kind: "report_items";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    items_path: string;
+                    id_path: string;
+                    filter?: {
+                        kind: "path_equals";
+                        path: string;
+                        value: string | number | boolean | null;
+                    } | undefined;
+                    required_count?: {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    } | undefined;
+                    label_path?: string | undefined;
+                    description_path?: string | undefined;
+                } | undefined;
+                safe_default_choice?: string | undefined;
+                auto_resolution?: {
+                    policy: "highest-score";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    branches_path: string;
+                    id_path: string;
+                    rubric_result_path: string;
+                } | undefined;
+                auto_continuable_when_nested?: boolean | undefined;
+                report_template?: import("../../index.js").JsonObject | undefined;
+            } | undefined;
+            fanout?: {
+                branches: {
+                    kind: "static";
+                    branches: ({
+                        branch_id: string;
+                        flow_ref: {
+                            flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                            entry_mode: string;
+                            version?: string | undefined;
+                        };
+                        goal: string;
+                        depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+                        selection?: {
+                            skills: {
+                                mode: "inherit";
+                            } | {
+                                mode: "replace";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "append";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "remove";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            };
+                            invocation_options: import("../../index.js").JsonObject;
+                            model?: {
+                                provider: "custom" | "openai" | "anthropic" | "gemini";
+                                model: string;
+                            } | undefined;
+                            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+                        } | undefined;
+                    } | {
+                        branch_id: string;
+                        execution: {
+                            kind: "relay";
+                            role: "researcher" | "implementer" | "reviewer";
+                            goal: string;
+                            report_schema: string;
+                            provenance_field?: string | undefined;
+                        };
+                        connector?: string | undefined;
+                        selection?: {
+                            skills: {
+                                mode: "inherit";
+                            } | {
+                                mode: "replace";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "append";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            } | {
+                                mode: "remove";
+                                skills: (string & import("zod").$brand<"SkillId">)[];
+                            };
+                            invocation_options: import("../../index.js").JsonObject;
+                            model?: {
+                                provider: "custom" | "openai" | "anthropic" | "gemini";
+                                model: string;
+                            } | undefined;
+                            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+                            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+                        } | undefined;
+                    })[];
+                } | {
+                    kind: "dynamic";
+                    source_report: string & import("zod").$brand<"RunRelativePath">;
+                    items_path: string;
+                    template: {
+                        branch_id: string;
+                        flow_ref: {
+                            flow_id: string & import("zod").$brand<"CompiledFlowId">;
+                            entry_mode: string;
+                            version?: string | undefined;
+                        };
+                        goal: string;
+                        depth: "low" | "medium" | "high" | "tournament" | "autonomous";
+                        selection?: unknown;
+                    } | {
+                        branch_id: string;
+                        execution: {
+                            kind: "relay";
+                            role: "researcher" | "implementer" | "reviewer";
+                            goal: string;
+                            report_schema: string;
+                            provenance_field?: string | undefined;
+                        };
+                        connector?: string | undefined;
+                        selection?: unknown;
+                    };
+                    max_branches: number | {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    };
+                    required_count?: {
+                        kind: "constant";
+                        value: number;
+                    } | {
+                        kind: "axis";
+                        axis: "tournament_n";
+                    } | undefined;
+                };
+                join: {
+                    policy: "pick-winner";
+                } | {
+                    policy: "disjoint-merge";
+                } | {
+                    policy: "aggregate-only";
+                } | {
+                    policy: "aggregate-survivors";
+                };
+                concurrency?: {
+                    kind: "unbounded";
+                } | {
+                    kind: "bounded";
+                    max: number;
+                } | undefined;
+                on_child_failure?: "abort-all" | "continue-others" | undefined;
+                rubric?: {
+                    model_judgments_path: string;
+                    ordered_dims: string[];
+                    runtime_signals: Record<string, {
+                        kind: "constant";
+                        signal: "met" | "missing" | "n/a";
+                    } | {
+                        kind: "non_empty_array";
+                        path: string;
+                    } | {
+                        kind: "non_empty_string";
+                        path: string;
+                    }>;
+                } | undefined;
+            } | undefined;
+        }[];
+        version?: string | undefined;
+        axes?: {
+            allowed_depths: ("low" | "medium" | "high")[];
+            supports_tournament: boolean;
+            supports_autonomous: boolean;
+            default: {
+                depth: "low" | "medium" | "high";
+                tournament: boolean;
+                tournament_n: number;
+                autonomous: boolean;
+            };
+            tournament_fan_out_stage?: (string & import("zod").$brand<"StageId">) | undefined;
+        } | undefined;
+        stage_path_policy?: {
+            mode: "strict";
+        } | {
+            mode: "partial";
+            omits: ("review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close")[];
+            rationale: string;
+        } | undefined;
+        stages?: {
+            canonical: "review" | "frame" | "analyze" | "plan" | "act" | "verify" | "close";
+            id: string & import("zod").$brand<"StageId">;
+            title: string;
+        }[] | undefined;
+        default_selection?: {
+            skills: {
+                mode: "inherit";
+            } | {
+                mode: "replace";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            } | {
+                mode: "append";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            } | {
+                mode: "remove";
+                skills: (string & import("zod").$brand<"SkillId">)[];
+            };
+            invocation_options: import("../../index.js").JsonObject;
+            model?: {
+                provider: "custom" | "openai" | "anthropic" | "gemini";
+                model: string;
+            } | undefined;
+            effort?: "low" | "medium" | "high" | "none" | "minimal" | "xhigh" | "max" | undefined;
+            depth?: "low" | "medium" | "high" | "tournament" | "autonomous" | undefined;
+        } | undefined;
+        engine_flags?: {
+            binds_execution_depth_to_relay_selection?: boolean | undefined;
+            binds_terminal_outcome_to_primary_result?: boolean | undefined;
+            iterates_slice_loop?: {
+                head_step: string;
+                tail_step: string;
+                advance_route: string;
+                slices_from: {
+                    report: string;
+                    items_path: string;
+                };
+                max_slices: number;
+                activate_when_depth_at_least: "high";
+            } | undefined;
+            iterates_until_condition?: {
+                head_step: string;
+                tail_step: string;
+                body_steps: string[];
+                reenter_route: string;
+                max_iterations: number;
+                activate_when_depth_at_least: "autonomous";
+                stop_judge?: {
+                    report: string;
+                    goal_met_path: string;
+                    lesson_path?: string | undefined;
+                    progress_path?: string | undefined;
+                } | undefined;
+                needs_attention_route?: string | undefined;
+                carried_notes?: {
+                    report: string;
+                    max_entries?: number | undefined;
+                } | undefined;
+                cumulative_usd_cap?: number | undefined;
+                cumulative_token_cap?: number | undefined;
+                no_progress_ceiling?: number | undefined;
+                iteration_commit_containment?: {
+                    branch_prefix: string;
+                } | undefined;
+                frozen_paths?: string[] | undefined;
+            } | undefined;
+        } | undefined;
+        report_file_surfaces?: Record<string, {
+            timing: "before" | "after";
+            extractor: {
+                kind: "string-array-field";
+                field: string;
+            } | {
+                kind: "build-plan-and-slices-anticipated-file-extensions";
+            };
+        }> | undefined;
+        required_config?: {
+            axis: "tournament" | "autonomous";
+            path: string;
+            message: string;
+        }[] | undefined;
+    };
+    canonicalStagePolicy: {
+        kind: "exempt";
+        reason: string;
+    };
+};
+//# sourceMappingURL=data.d.ts.map

package/dist/flows/converge-proof/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/flows/converge-proof/data.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMd,CAAC"}

package/dist/flows/converge-proof/data.js

@@ -0,0 +1,23 @@
+import { assembleFlowSchematic } from '../assemble-flow-schematic.js';
+import { convergeProofAssemblySpec } from './assembly-spec.js';
+const convergeProofPaths = {
+    schematic: 'src/flows/converge-proof/schematic.json',
+};
+// First-class composition: converge-proof is an assembler customer. Its block
+// sequence and engine flags live in ./assembly-spec.ts; `assembleFlowSchematic`
+// derives starts_at / stages / stage_path_policy and carries the until-loop flag
+// through to the returned FlowSchematic. The flow is all-relay (plan, act,
+// review) with no compose writers, so data.ts declares no reports.
+const convergeProofSchematic = assembleFlowSchematic(convergeProofAssemblySpec);
+const convergeProofCanonicalStagePolicy = {
+    kind: 'exempt',
+    reason: 'partial-stage path, recorded',
+};
+export const convergeProofFlowData = {
+    id: 'converge-proof',
+    visibility: 'internal',
+    paths: convergeProofPaths,
+    schematic: convergeProofSchematic,
+    canonicalStagePolicy: convergeProofCanonicalStagePolicy,
+};
+//# sourceMappingURL=data.js.map

package/dist/flows/converge-proof/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","sourceRoot":"","sources":["../../../src/flows/converge-proof/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAE/D,MAAM,kBAAkB,GAAG;IACzB,SAAS,EAAE,yCAAyC;CACzB,CAAC;AAE9B,8EAA8E;AAC9E,gFAAgF;AAChF,iFAAiF;AACjF,2EAA2E;AAC3E,mEAAmE;AACnE,MAAM,sBAAsB,GAAG,qBAAqB,CAClD,yBAAyB,CACM,CAAC;AAElC,MAAM,iCAAiC,GAAG;IACxC,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,8BAA8B;CACI,CAAC;AAE7C,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,EAAE,EAAE,gBAAgB;IACpB,UAAU,EAAE,UAAU;IACtB,KAAK,EAAE,kBAAkB;IACzB,SAAS,EAAE,sBAAsB;IACjC,oBAAoB,EAAE,iCAAiC;CACrC,CAAC"}

package/dist/flows/converge-proof/flow.d.ts

@@ -0,0 +1,2 @@
+export declare const convergeProofFlowDefinition: import("../flow-definition.js").FlowDefinition;
+//# sourceMappingURL=flow.d.ts.map

package/dist/flows/converge-proof/flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../src/flows/converge-proof/flow.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,2BAA2B,gDAAwC,CAAC"}

package/dist/flows/converge-proof/flow.js

@@ -0,0 +1,4 @@
+import { defineFlowData } from '../flow-definition.js';
+import { convergeProofFlowData } from './data.js';
+export const convergeProofFlowDefinition = defineFlowData(convergeProofFlowData);
+//# sourceMappingURL=flow.js.map

package/dist/flows/converge-proof/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sourceRoot":"","sources":["../../../src/flows/converge-proof/flow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAElD,MAAM,CAAC,MAAM,2BAA2B,GAAG,cAAc,CAAC,qBAAqB,CAAC,CAAC"}

package/dist/flows/cross-tool-build/assembly-spec.d.ts

@@ -0,0 +1,5 @@
+import type { FlowSchematicAssemblySpec } from '../assemble-flow-schematic.js';
+import type { BlockStepUse } from '../block-step-expansion.js';
+export declare const crossToolBuildBlockItems: readonly BlockStepUse[];
+export declare const crossToolBuildAssemblySpec: FlowSchematicAssemblySpec;
+//# sourceMappingURL=assembly-spec.d.ts.map

package/dist/flows/cross-tool-build/assembly-spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembly-spec.d.ts","sourceRoot":"","sources":["../../../src/flows/cross-tool-build/assembly-spec.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAAE,yBAAyB,EAAiB,MAAM,+BAA+B,CAAC;AAC9F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAU/D,eAAO,MAAM,wBAAwB,EAAE,SAAS,YAAY,EA8I3D,CAAC;AAUF,eAAO,MAAM,0BAA0B,EAAE,yBA2BxC,CAAC"}

package/dist/flows/cross-tool-build/assembly-spec.js

@@ -0,0 +1,183 @@
+// The doer and reviewer connectors. Named once so the intent reads clearly and a
+// re-pin (e.g. swapping which tool reviews) is a one-line change.
+const DOER = 'codex';
+const REVIEWER = 'claude-code';
+const CROSS_TOOL_BUILD_STAGE_PATH_RATIONALE = 'Cross-Tool Build is a linear propose/review/spec/review/implement/verify pipeline; plan, review, act, verify, and close are the canonical stages it uses. Frame and analyze are omitted: the goal is the brief, and the doer reads the codebase as part of proposing.';
+export const crossToolBuildBlockItems = [
+    {
+        id: 'plan-step',
+        title: 'Plan the verification',
+        stage: 'plan',
+        block: 'plan',
+        input: { brief: 'flow.brief@v1' },
+        output: 'cross-tool-build.plan@v1',
+        execution: { kind: 'compose' },
+        protocol: 'cross-tool-build-plan@v1',
+        reportPath: 'reports/cross-tool-build/plan.json',
+        required: ['objective', 'verification'],
+        routes: { continue: 'propose-step', stop: '@stop' },
+    },
+    {
+        id: 'propose-step',
+        title: 'Propose how to implement the feature',
+        stage: 'plan',
+        block: 'plan',
+        input: { brief: 'flow.brief@v1' },
+        output: 'cross-tool-build.proposal@v1',
+        execution: { kind: 'relay', role: 'researcher', connector: DOER },
+        protocol: 'cross-tool-build-propose@v1',
+        reportPath: 'reports/cross-tool-build/proposal.json',
+        requestPath: 'reports/relay/cross-tool-build-propose.request.json',
+        receiptPath: 'reports/relay/cross-tool-build-propose.receipt.txt',
+        resultPath: 'reports/relay/cross-tool-build-propose.result.json',
+        pass: ['accept'],
+        routes: { continue: 'review-proposal-step', retry: 'propose-step', stop: '@stop' },
+    },
+    {
+        id: 'review-proposal-step',
+        title: 'Adversarially review the proposal',
+        stage: 'review',
+        block: 'review',
+        input: { brief: 'flow.brief@v1', proposal: 'cross-tool-build.proposal@v1' },
+        output: 'cross-tool-build.proposal-review@v1',
+        execution: { kind: 'relay', role: 'reviewer', connector: REVIEWER },
+        protocol: 'cross-tool-build-review-proposal@v1',
+        reportPath: 'reports/cross-tool-build/proposal-review.json',
+        requestPath: 'reports/relay/cross-tool-build-review-proposal.request.json',
+        receiptPath: 'reports/relay/cross-tool-build-review-proposal.receipt.txt',
+        resultPath: 'reports/relay/cross-tool-build-review-proposal.result.json',
+        // Both verdicts pass: the review is forward-carry, not a blocking gate. The
+        // verdict + findings ride forward as a typed input to spec-step.
+        pass: ['accept', 'revise'],
+        routes: { continue: 'spec-step', retry: 'review-proposal-step', stop: '@stop' },
+    },
+    {
+        id: 'spec-step',
+        title: 'Revise the proposal and write the implementation spec',
+        stage: 'plan',
+        block: 'plan',
+        input: {
+            brief: 'flow.brief@v1',
+            proposal: 'cross-tool-build.proposal@v1',
+            proposal_review: 'cross-tool-build.proposal-review@v1',
+        },
+        output: 'cross-tool-build.spec@v1',
+        execution: { kind: 'relay', role: 'researcher', connector: DOER },
+        protocol: 'cross-tool-build-spec@v1',
+        reportPath: 'reports/cross-tool-build/spec.json',
+        requestPath: 'reports/relay/cross-tool-build-spec.request.json',
+        receiptPath: 'reports/relay/cross-tool-build-spec.receipt.txt',
+        resultPath: 'reports/relay/cross-tool-build-spec.result.json',
+        pass: ['accept'],
+        routes: { continue: 'review-spec-step', retry: 'spec-step', stop: '@stop' },
+    },
+    {
+        id: 'review-spec-step',
+        title: 'Adversarially review the spec',
+        stage: 'review',
+        block: 'review',
+        input: { brief: 'flow.brief@v1', spec: 'cross-tool-build.spec@v1' },
+        output: 'cross-tool-build.spec-review@v1',
+        execution: { kind: 'relay', role: 'reviewer', connector: REVIEWER },
+        protocol: 'cross-tool-build-review-spec@v1',
+        reportPath: 'reports/cross-tool-build/spec-review.json',
+        requestPath: 'reports/relay/cross-tool-build-review-spec.request.json',
+        receiptPath: 'reports/relay/cross-tool-build-review-spec.receipt.txt',
+        resultPath: 'reports/relay/cross-tool-build-review-spec.result.json',
+        pass: ['accept', 'revise'],
+        routes: { continue: 'implement-step', retry: 'review-spec-step', stop: '@stop' },
+    },
+    {
+        id: 'implement-step',
+        title: 'Implement the spec end-to-end and manually test',
+        stage: 'act',
+        block: 'act',
+        input: {
+            brief: 'flow.brief@v1',
+            spec: 'cross-tool-build.spec@v1',
+            spec_review: 'cross-tool-build.spec-review@v1',
+        },
+        output: 'cross-tool-build.implementation@v1',
+        execution: { kind: 'relay', role: 'implementer', connector: DOER },
+        protocol: 'cross-tool-build-implement@v1',
+        reportPath: 'reports/cross-tool-build/implementation.json',
+        requestPath: 'reports/relay/cross-tool-build-implement.request.json',
+        receiptPath: 'reports/relay/cross-tool-build-implement.receipt.txt',
+        resultPath: 'reports/relay/cross-tool-build-implement.result.json',
+        pass: ['accept'],
+        routes: { continue: 'verify-step', retry: 'implement-step', stop: '@stop' },
+    },
+    {
+        id: 'verify-step',
+        title: 'Run the verification',
+        stage: 'verify',
+        block: 'run-verification',
+        input: {
+            proof: 'verification.plan@v1',
+            plan: 'cross-tool-build.plan@v1',
+            change: 'cross-tool-build.implementation@v1',
+        },
+        output: 'cross-tool-build.verification@v1',
+        protocol: 'cross-tool-build-verify@v1',
+        reportPath: 'reports/cross-tool-build/verification.json',
+        required: ['overall_status', 'commands'],
+        // continue on a green verify. A red verify routes back to implement-step so
+        // the doer addresses the failures; the loop is bounded by the step's
+        // max_attempts_per_step, after which the run stops without claiming complete.
+        routes: { continue: 'close-step', retry: 'implement-step', stop: '@stop' },
+    },
+    {
+        id: 'close-step',
+        title: 'Emit the result',
+        stage: 'close',
+        block: 'close-with-evidence',
+        input: {
+            brief: 'flow.brief@v1',
+            implementation: 'cross-tool-build.implementation@v1',
+            verification: 'cross-tool-build.verification@v1',
+            proposal_review: 'cross-tool-build.proposal-review@v1',
+            spec_review: 'cross-tool-build.spec-review@v1',
+        },
+        output: 'cross-tool-build.result@v1',
+        execution: { kind: 'compose' },
+        protocol: 'cross-tool-build-close@v1',
+        reportPath: 'reports/cross-tool-build-result.json',
+        required: ['summary', 'outcome', 'verification_status', 'evidence_links'],
+        routes: { complete: '@complete', stop: '@stop' },
+    },
+];
+const crossToolBuildStageLabels = {
+    plan: { id: 'plan-stage', title: 'Plan' },
+    review: { id: 'review-stage', title: 'Review' },
+    act: { id: 'act-stage', title: 'Act' },
+    verify: { id: 'verify-stage', title: 'Verify' },
+    close: { id: 'close-stage', title: 'Close' },
+};
+export const crossToolBuildAssemblySpec = {
+    id: 'cross-tool-build',
+    title: 'Cross-Tool Build Schematic',
+    purpose: 'Cross-Tool Build flow: one connector proposes a feature implementation, a second adversarially reviews it, the first revises it into a spec, the second reviews the spec, and the first implements it end-to-end and verifies. The per-step worker pin routes the doer steps and the review steps to different connectors, so the two-tool split is a property of the flow.',
+    status: 'active',
+    version: '0.1.0',
+    initial_contracts: ['flow.brief@v1', 'verification.plan@v1'],
+    contract_aliases: [
+        { generic: 'plan.strategy@v1', actual: 'cross-tool-build.plan@v1' },
+        { generic: 'plan.strategy@v1', actual: 'cross-tool-build.proposal@v1' },
+        { generic: 'plan.strategy@v1', actual: 'cross-tool-build.spec@v1' },
+        { generic: 'review.verdict@v1', actual: 'cross-tool-build.proposal-review@v1' },
+        { generic: 'review.verdict@v1', actual: 'cross-tool-build.spec-review@v1' },
+        { generic: 'change.evidence@v1', actual: 'cross-tool-build.implementation@v1' },
+        { generic: 'verification.result@v1', actual: 'cross-tool-build.verification@v1' },
+        { generic: 'flow.result@v1', actual: 'cross-tool-build.result@v1' },
+    ],
+    axes: {
+        allowed_depths: ['low', 'medium', 'high'],
+        supports_tournament: false,
+        supports_autonomous: true,
+        default: { depth: 'medium', tournament: false, tournament_n: 3, autonomous: false },
+    },
+    items: crossToolBuildBlockItems,
+    stageLabels: crossToolBuildStageLabels,
+    stagePathRationale: CROSS_TOOL_BUILD_STAGE_PATH_RATIONALE,
+};
+//# sourceMappingURL=assembly-spec.js.map