@petepetrash/circuit 0.1.0

package/dist/flows/fix-until-green/data.d.ts

@@ -0,0 +1,462 @@
+export declare const fixUntilGreenFlowData: {
+    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;
+    };
+    reports: ({
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            objective: import("zod").ZodString;
+            approach: import("zod").ZodString;
+            verification: import("zod").ZodObject<{
+                commands: import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    cwd: import("zod").ZodString;
+                    argv: import("zod").ZodArray<import("zod").ZodString>;
+                    timeout_ms: import("zod").ZodNumber;
+                    max_output_bytes: import("zod").ZodNumber;
+                    env: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+                }, import("zod/v4/core").$strict>>;
+            }, import("zod/v4/core").$strict>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            compose: import("../registries/compose-writers/types.js").ComposeBuilder[];
+            verification?: never;
+        };
+    } | {
+        schemaName: string;
+        channel: "report";
+        schema: import("zod").ZodObject<{
+            overall_status: import("zod").ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>;
+            commands: import("zod").ZodArray<import("zod").ZodObject<{
+                command_id: import("zod").ZodString;
+                argv: import("zod").ZodArray<import("zod").ZodString>;
+                cwd: import("zod").ZodString;
+                exit_code: import("zod").ZodNumber;
+                status: import("zod").ZodEnum<{
+                    passed: "passed";
+                    failed: "failed";
+                }>;
+                duration_ms: import("zod").ZodNumber;
+                stdout_summary: import("zod").ZodString;
+                stderr_summary: import("zod").ZodString;
+                timed_out: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            }, import("zod/v4/core").$strict>>;
+        }, import("zod/v4/core").$strict>;
+        writers: {
+            verification: import("../registries/verification-writers/types.js").VerificationBuilder[];
+            compose?: never;
+        };
+    })[];
+    structuralHints: import("../registries/shape-hints/types.js").StructuralShapeHint[];
+};
+//# sourceMappingURL=data.d.ts.map

package/dist/flows/fix-until-green/data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.d.ts","sourceRoot":"","sources":["../../../src/flows/fix-until-green/data.ts"],"names":[],"mappings":"AA4CA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWd,CAAC"}

package/dist/flows/fix-until-green/data.js

@@ -0,0 +1,49 @@
+import { assembleFlowSchematic } from '../assemble-flow-schematic.js';
+import { fixUntilGreenAssemblySpec } from './assembly-spec.js';
+import { convergeJudgmentRelayShapeHint } from './relay-hints.js';
+import { FixUntilGreenPlan, FixUntilGreenVerification } from './reports.js';
+import { fixUntilGreenPlanComposeBuilder } from './writers/plan.js';
+import { fixUntilGreenVerificationWriter } from './writers/verification.js';
+const fixUntilGreenPaths = {
+    schematic: 'src/flows/fix-until-green/schematic.json',
+};
+// First-class composition: fix-until-green is an assembler customer. Its block
+// sequence and the until-loop engine flag live in ./assembly-spec.ts;
+// `assembleFlowSchematic` derives starts_at / stages / stage_path_policy and
+// carries the until flag through to the returned FlowSchematic.
+const fixUntilGreenSchematic = assembleFlowSchematic(fixUntilGreenAssemblySpec);
+const fixUntilGreenCanonicalStagePolicy = {
+    kind: 'exempt',
+    reason: 'partial-stage path, recorded',
+};
+// fix-until-green owns its own plan and verification schema names so its writers
+// do not collide with build's / fix's on the global compose, verification, and
+// report-schema registries. The act and judge relays are bare (no typed report),
+// so the loop body's only typed report is the verification result.
+const fixUntilGreenReports = [
+    {
+        schemaName: 'fix-until-green.plan@v1',
+        channel: 'report',
+        schema: FixUntilGreenPlan,
+        writers: { compose: [fixUntilGreenPlanComposeBuilder] },
+    },
+    {
+        schemaName: 'fix-until-green.verification@v1',
+        channel: 'report',
+        schema: FixUntilGreenVerification,
+        writers: { verification: [fixUntilGreenVerificationWriter] },
+    },
+];
+export const fixUntilGreenFlowData = {
+    id: 'fix-until-green',
+    visibility: 'internal',
+    paths: fixUntilGreenPaths,
+    schematic: fixUntilGreenSchematic,
+    canonicalStagePolicy: fixUntilGreenCanonicalStagePolicy,
+    reports: fixUntilGreenReports,
+    // The composed-Converge stop-judge shape hint. It keys on the bound
+    // converge.judgment@v1 contract, not on this flow id, so it serves any generated
+    // Converge tail; it lives here because fix-until-green is the canonical Converge.
+    structuralHints: [convergeJudgmentRelayShapeHint],
+};
+//# sourceMappingURL=data.js.map

package/dist/flows/fix-until-green/data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"data.js","sourceRoot":"","sources":["../../../src/flows/fix-until-green/data.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,8BAA8B,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAC5E,OAAO,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAC;AAE5E,MAAM,kBAAkB,GAAG;IACzB,SAAS,EAAE,0CAA0C;CAC1B,CAAC;AAE9B,+EAA+E;AAC/E,sEAAsE;AACtE,6EAA6E;AAC7E,gEAAgE;AAChE,MAAM,sBAAsB,GAAG,qBAAqB,CAClD,yBAAyB,CACM,CAAC;AAElC,MAAM,iCAAiC,GAAG;IACxC,IAAI,EAAE,QAAQ;IACd,MAAM,EAAE,8BAA8B;CACI,CAAC;AAE7C,iFAAiF;AACjF,+EAA+E;AAC/E,iFAAiF;AACjF,mEAAmE;AACnE,MAAM,oBAAoB,GAAG;IAC3B;QACE,UAAU,EAAE,yBAAyB;QACrC,OAAO,EAAE,QAAQ;QACjB,MAAM,EAAE,iBAAiB;QACzB,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,+BAA+B,CAAC,EAAE;KACxD;IACD;QACE,UAAU,EAAE,iCAAiC;QAC7C,OAAO,EAAE,QAAQ;QACjB,MAAM,EAAE,yBAAyB;QACjC,OAAO,EAAE,EAAE,YAAY,EAAE,CAAC,+BAA+B,CAAC,EAAE;KAC7D;CACyC,CAAC;AAE7C,MAAM,CAAC,MAAM,qBAAqB,GAAG;IACnC,EAAE,EAAE,iBAAiB;IACrB,UAAU,EAAE,UAAU;IACtB,KAAK,EAAE,kBAAkB;IACzB,SAAS,EAAE,sBAAsB;IACjC,oBAAoB,EAAE,iCAAiC;IACvD,OAAO,EAAE,oBAAoB;IAC7B,oEAAoE;IACpE,iFAAiF;IACjF,kFAAkF;IAClF,eAAe,EAAE,CAAC,8BAA8B,CAAC;CAC/B,CAAC"}

package/dist/flows/fix-until-green/flow.d.ts

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

package/dist/flows/fix-until-green/flow.d.ts.map

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

package/dist/flows/fix-until-green/flow.js

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

package/dist/flows/fix-until-green/flow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow.js","sourceRoot":"","sources":["../../../src/flows/fix-until-green/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/fix-until-green/relay-hints.d.ts

@@ -0,0 +1,3 @@
+import type { StructuralShapeHint } from '../registries/shape-hints/types.js';
+export declare const convergeJudgmentRelayShapeHint: StructuralShapeHint;
+//# sourceMappingURL=relay-hints.d.ts.map

package/dist/flows/fix-until-green/relay-hints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.d.ts","sourceRoot":"","sources":["../../../src/flows/fix-until-green/relay-hints.ts"],"names":[],"mappings":"AAmBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,eAAO,MAAM,8BAA8B,EAAE,mBAiB5C,CAAC"}

package/dist/flows/fix-until-green/relay-hints.js

@@ -0,0 +1,37 @@
+// Composed-Converge stop-judge relay shape hint.
+//
+// A generated Converge's reviewer tail is bound to the dedicated
+// `converge.judgment@v1` contract (CONVERGE_JUDGMENT_CONTRACT) by the composer, not
+// to a flow's typed report — so the hint cannot ride on a `relayReports[].relayHint`
+// the way per-flow relay reports do. It matches by the step's bound output schema
+// instead: any reviewer relay whose `writes.report.schema` is the judgment contract.
+// This is the only step the composer ever binds to that contract, so the match is
+// exact. It is registered on the fix-until-green package (the canonical Converge
+// flow) but applies to any composed Converge tail, since the match keys on the bound
+// contract, not on a flow id.
+//
+// Without this hint a worker driving the composed tail receives only the generic
+// "respond with a verdict" instruction and produces an acknowledgment-style body that
+// omits goal_met/lesson/summary — which the strict judgment schema then rejects. The
+// hint tells the worker exactly what to emit so a REAL run's judge actually produces
+// goal_met, the field the until-loop's evidence floor reads.
+import { CONVERGE_JUDGMENT_CONTRACT } from '../../schemas/builtin-report-schemas.js';
+export const convergeJudgmentRelayShapeHint = {
+    kind: 'structural',
+    id: 'converge.judgment@v1@structural',
+    match(step) {
+        return step.role === 'reviewer' && step.writes.report?.schema === CONVERGE_JUDGMENT_CONTRACT;
+    },
+    instruction: [
+        'You are the stop-judge of a converge loop: each pass you decide whether the goal is met, backed by the verification this iteration ran.',
+        'Respond with a single raw JSON object whose top-level shape is exactly:',
+        '{ "verdict": "<accept|accept-with-fixes|reject>", "goal_met": <true|false>, "lesson": "<what the next attempt should do differently>", "summary": "<one plain-language line for the operator>" }',
+        'goal_met is the load-bearing field: set it true ONLY when the goal is fully met AND the verification you can see actually backs it. If the verification is red, incomplete, or does not cover the claim, goal_met MUST be false — the loop will re-enter and try again. Never claim the goal is met on evidence you cannot point to.',
+        'lesson is carried verbatim into the next attempt: name the single most useful change the next pass should make. When the goal is genuinely met and there is nothing left to do, set it to "none".',
+        'summary is one human-facing sentence stating what you judged and why.',
+        'Choose verdict to match: "accept" for a clean pass, "accept-with-fixes" for a pass with minor follow-ups, "reject" when the goal is not met.',
+        'Do not include extra top-level keys. Do not wrap the JSON in Markdown code fences. Do not include any prose before or after the JSON object.',
+        'The runtime parses your response with JSON.parse and validates it against the converge.judgment@v1 schema; an extra key or a missing field is rejected. The engine reads goal_met to decide whether to stop or loop, and never reads the goal text or interprets the lesson as instructions.',
+    ].join(' '),
+};
+//# sourceMappingURL=relay-hints.js.map

package/dist/flows/fix-until-green/relay-hints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-hints.js","sourceRoot":"","sources":["../../../src/flows/fix-until-green/relay-hints.ts"],"names":[],"mappings":"AAAA,iDAAiD;AACjD,EAAE;AACF,iEAAiE;AACjE,oFAAoF;AACpF,qFAAqF;AACrF,kFAAkF;AAClF,qFAAqF;AACrF,kFAAkF;AAClF,iFAAiF;AACjF,qFAAqF;AACrF,8BAA8B;AAC9B,EAAE;AACF,iFAAiF;AACjF,sFAAsF;AACtF,qFAAqF;AACrF,qFAAqF;AACrF,6DAA6D;AAE7D,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AAGrF,MAAM,CAAC,MAAM,8BAA8B,GAAwB;IACjE,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,iCAAiC;IACrC,KAAK,CAAC,IAAI;QACR,OAAO,IAAI,CAAC,IAAI,KAAK,UAAU,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,KAAK,0BAA0B,CAAC;IAC/F,CAAC;IACD,WAAW,EAAE;QACX,yIAAyI;QACzI,yEAAyE;QACzE,kMAAkM;QAClM,sUAAsU;QACtU,mMAAmM;QACnM,uEAAuE;QACvE,8IAA8I;QAC9I,8IAA8I;QAC9I,8RAA8R;KAC/R,CAAC,IAAI,CAAC,GAAG,CAAC;CACZ,CAAC"}

package/dist/flows/fix-until-green/reports.d.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+export declare const FixUntilGreenPlan: z.ZodObject<{
+    objective: z.ZodString;
+    approach: z.ZodString;
+    verification: z.ZodObject<{
+        commands: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            cwd: z.ZodString;
+            argv: z.ZodArray<z.ZodString>;
+            timeout_ms: z.ZodNumber;
+            max_output_bytes: z.ZodNumber;
+            env: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type FixUntilGreenPlan = z.infer<typeof FixUntilGreenPlan>;
+export declare const FixUntilGreenVerification: z.ZodObject<{
+    overall_status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    commands: z.ZodArray<z.ZodObject<{
+        command_id: z.ZodString;
+        argv: z.ZodArray<z.ZodString>;
+        cwd: z.ZodString;
+        exit_code: z.ZodNumber;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        duration_ms: z.ZodNumber;
+        stdout_summary: z.ZodString;
+        stderr_summary: z.ZodString;
+        timed_out: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FixUntilGreenVerification = z.infer<typeof FixUntilGreenVerification>;
+//# sourceMappingURL=reports.d.ts.map

package/dist/flows/fix-until-green/reports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reports.d.ts","sourceRoot":"","sources":["../../../src/flows/fix-until-green/reports.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;kBAUnB,CAAC;AACZ,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;kBAAqB,CAAC;AAC5D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}