@kernloop/workflows 0.1.0

package/dist/state.d.ts

@@ -0,0 +1,1078 @@
+/**
+ * Run state, checkpoint record shape, and typed engine errors. The state is
+ * deliberately a plain JSON-serializable object validated by zod: a resume
+ * trusts nothing it reads back from storage [CLM-0044] — a checkpoint that
+ * does not parse is a typed failure, never a silent partial resume.
+ */
+import { z } from 'zod';
+import { type Finding, type Outcome } from '@kernloop/contracts';
+/**
+ * Where the run is. `main` points at the NEXT main-chain node to execute;
+ * `fanout` points at the next (child, sub-node) pair; `done` is terminal.
+ * The cursor always names work not yet performed, so resuming from a
+ * checkpoint never re-runs a completed node [CLM-0044].
+ */
+export declare const CursorSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    phase: z.ZodLiteral<"main">;
+    node: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"fanout">;
+    childIndex: z.ZodNumber;
+    sub: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    phase: z.ZodLiteral<"done">;
+}, z.core.$strict>], "phase">;
+export type Cursor = z.infer<typeof CursorSchema>;
+/** Metered spend attributed to one fan-out child (tokens + usd), #56. */
+export declare const ChildSpendSchema: z.ZodObject<{
+    tokens: z.ZodNumber;
+    usd: z.ZodNumber;
+}, z.core.$strict>;
+export type ChildSpend = z.infer<typeof ChildSpendSchema>;
+/**
+ * One fan-out child's honest result. A child that fails mid-implement gets
+ * `error` and no verdict; a child whose quality gate ran gets its Verdict
+ * (pass or fail — a failing verdict is a result, not an engine error). The
+ * `reviewVerdict` is the advisory review gate's verdict (recorded, never
+ * blocking). All shapes aggregate into integrate's input unfiltered.
+ *
+ * `iteration` and `findings` carry the per-child actor-critic loop [CLM-0043]:
+ * a quality reject re-runs implement, folding the gate's findings into the
+ * coder's next attempt, bounded by Kc (and the run budget). They mirror the
+ * run-level `iteration`/`findings` but scope to one child, and are
+ * checkpointed so a resume mid-child-iteration re-runs nothing finished.
+ * `escalated` marks a child that hit the Kc/budget bound still failing — it is
+ * recorded, never re-attempted, and does NOT sink its siblings or the run.
+ */
+export declare const ChildResultSchema: z.ZodObject<{
+    child: z.ZodObject<{
+        id: z.ZodString;
+        parent: z.ZodOptional<z.ZodString>;
+        goal: z.ZodString;
+        constraints: z.ZodArray<z.ZodString>;
+        budget: z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+            wallClockMin: z.ZodNumber;
+        }, z.core.$strict>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                test: "test";
+                ci: "ci";
+                doc: "doc";
+                eval: "eval";
+            }>;
+            ref: z.ZodString;
+        }, z.core.$strict>>;
+        definitionOfDone: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+        }, z.core.$strict>>;
+        authorityCeiling: z.ZodEnum<{
+            observe: "observe";
+            suggest: "suggest";
+            advisory: "advisory";
+            enforce: "enforce";
+        }>;
+        overlay: z.ZodString;
+    }, z.core.$strict>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    verdict: z.ZodOptional<z.ZodObject<{
+        taskId: z.ZodString;
+        gate: z.ZodString;
+        result: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            abstain: "abstain";
+            pass: "pass";
+            fail: "fail";
+            escalate: "escalate";
+        }>;
+        confidence: z.ZodNumber;
+        findings: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warn: "warn";
+                blocker: "blocker";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            voter: z.ZodString;
+            vote: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                abstain: "abstain";
+                pass: "pass";
+                fail: "fail";
+                escalate: "escalate";
+            }>;
+            reasoning: z.ZodString;
+            served: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                family: z.ZodString;
+                generation: z.ZodString;
+                variant: z.ZodNullable<z.ZodString>;
+                tier: z.ZodEnum<{
+                    frontier: "frontier";
+                    large: "large";
+                    medium: "medium";
+                    small: "small";
+                }>;
+                raw: z.ZodString;
+                resolvedBy: z.ZodEnum<{
+                    unknown: "unknown";
+                    table: "table";
+                    rule: "rule";
+                }>;
+                contextWindow: z.ZodNullable<z.ZodNumber>;
+                inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        cost: z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+            wallClockMs: z.ZodOptional<z.ZodNumber>;
+            byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    reviewVerdict: z.ZodOptional<z.ZodObject<{
+        taskId: z.ZodString;
+        gate: z.ZodString;
+        result: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            abstain: "abstain";
+            pass: "pass";
+            fail: "fail";
+            escalate: "escalate";
+        }>;
+        confidence: z.ZodNumber;
+        findings: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warn: "warn";
+                blocker: "blocker";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            voter: z.ZodString;
+            vote: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                abstain: "abstain";
+                pass: "pass";
+                fail: "fail";
+                escalate: "escalate";
+            }>;
+            reasoning: z.ZodString;
+            served: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                family: z.ZodString;
+                generation: z.ZodString;
+                variant: z.ZodNullable<z.ZodString>;
+                tier: z.ZodEnum<{
+                    frontier: "frontier";
+                    large: "large";
+                    medium: "medium";
+                    small: "small";
+                }>;
+                raw: z.ZodString;
+                resolvedBy: z.ZodEnum<{
+                    unknown: "unknown";
+                    table: "table";
+                    rule: "rule";
+                }>;
+                contextWindow: z.ZodNullable<z.ZodNumber>;
+                inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        cost: z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+            wallClockMs: z.ZodOptional<z.ZodNumber>;
+            byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    parsimonyVerdict: z.ZodOptional<z.ZodObject<{
+        taskId: z.ZodString;
+        gate: z.ZodString;
+        result: z.ZodEnum<{
+            approve: "approve";
+            reject: "reject";
+            abstain: "abstain";
+            pass: "pass";
+            fail: "fail";
+            escalate: "escalate";
+        }>;
+        confidence: z.ZodNumber;
+        findings: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warn: "warn";
+                blocker: "blocker";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            voter: z.ZodString;
+            vote: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                abstain: "abstain";
+                pass: "pass";
+                fail: "fail";
+                escalate: "escalate";
+            }>;
+            reasoning: z.ZodString;
+            served: z.ZodOptional<z.ZodObject<{
+                provider: z.ZodString;
+                family: z.ZodString;
+                generation: z.ZodString;
+                variant: z.ZodNullable<z.ZodString>;
+                tier: z.ZodEnum<{
+                    frontier: "frontier";
+                    large: "large";
+                    medium: "medium";
+                    small: "small";
+                }>;
+                raw: z.ZodString;
+                resolvedBy: z.ZodEnum<{
+                    unknown: "unknown";
+                    table: "table";
+                    rule: "rule";
+                }>;
+                contextWindow: z.ZodNullable<z.ZodNumber>;
+                inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        cost: z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+            wallClockMs: z.ZodOptional<z.ZodNumber>;
+            byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodString>;
+    iteration: z.ZodDefault<z.ZodNumber>;
+    findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+            blocker: "blocker";
+        }>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    escalated: z.ZodOptional<z.ZodBoolean>;
+    spend: z.ZodOptional<z.ZodObject<{
+        tokens: z.ZodNumber;
+        usd: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ChildResult = z.infer<typeof ChildResultSchema>;
+/** One executed node in the run's trace (deterministic order, child-tagged). */
+export declare const TraceEntrySchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    node: z.ZodString;
+    iteration: z.ZodNumber;
+    childId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type TraceEntry = z.infer<typeof TraceEntrySchema>;
+/**
+ * The complete serializable state of one run. Self-contained: a checkpoint's
+ * state plus the injected executors is everything a resume needs.
+ */
+export declare const RunStateSchema: z.ZodObject<{
+    task: z.ZodObject<{
+        id: z.ZodString;
+        parent: z.ZodOptional<z.ZodString>;
+        goal: z.ZodString;
+        constraints: z.ZodArray<z.ZodString>;
+        budget: z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+            wallClockMin: z.ZodNumber;
+        }, z.core.$strict>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                test: "test";
+                ci: "ci";
+                doc: "doc";
+                eval: "eval";
+            }>;
+            ref: z.ZodString;
+        }, z.core.$strict>>;
+        definitionOfDone: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+        }, z.core.$strict>>;
+        authorityCeiling: z.ZodEnum<{
+            observe: "observe";
+            suggest: "suggest";
+            advisory: "advisory";
+            enforce: "enforce";
+        }>;
+        overlay: z.ZodString;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        escalated: "escalated";
+        running: "running";
+        completed: "completed";
+    }>;
+    cursor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        phase: z.ZodLiteral<"main">;
+        node: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"fanout">;
+        childIndex: z.ZodNumber;
+        sub: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        phase: z.ZodLiteral<"done">;
+    }, z.core.$strict>], "phase">;
+    haltReason: z.ZodOptional<z.ZodEnum<{
+        vote: "vote";
+        "vote-escalation": "vote-escalation";
+        budget: "budget";
+    }>>;
+    iteration: z.ZodNumber;
+    values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    findings: z.ZodArray<z.ZodObject<{
+        severity: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warn: "warn";
+            blocker: "blocker";
+        }>;
+        message: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    children: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        parent: z.ZodOptional<z.ZodString>;
+        goal: z.ZodString;
+        constraints: z.ZodArray<z.ZodString>;
+        budget: z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+            wallClockMin: z.ZodNumber;
+        }, z.core.$strict>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                test: "test";
+                ci: "ci";
+                doc: "doc";
+                eval: "eval";
+            }>;
+            ref: z.ZodString;
+        }, z.core.$strict>>;
+        definitionOfDone: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            command: z.ZodString;
+        }, z.core.$strict>>;
+        authorityCeiling: z.ZodEnum<{
+            observe: "observe";
+            suggest: "suggest";
+            advisory: "advisory";
+            enforce: "enforce";
+        }>;
+        overlay: z.ZodString;
+    }, z.core.$strict>>;
+    childResults: z.ZodArray<z.ZodObject<{
+        child: z.ZodObject<{
+            id: z.ZodString;
+            parent: z.ZodOptional<z.ZodString>;
+            goal: z.ZodString;
+            constraints: z.ZodArray<z.ZodString>;
+            budget: z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+                wallClockMin: z.ZodNumber;
+            }, z.core.$strict>;
+            evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    test: "test";
+                    ci: "ci";
+                    doc: "doc";
+                    eval: "eval";
+                }>;
+                ref: z.ZodString;
+            }, z.core.$strict>>;
+            definitionOfDone: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                command: z.ZodString;
+            }, z.core.$strict>>;
+            authorityCeiling: z.ZodEnum<{
+                observe: "observe";
+                suggest: "suggest";
+                advisory: "advisory";
+                enforce: "enforce";
+            }>;
+            overlay: z.ZodString;
+        }, z.core.$strict>;
+        output: z.ZodOptional<z.ZodUnknown>;
+        verdict: z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodString;
+            gate: z.ZodString;
+            result: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                abstain: "abstain";
+                pass: "pass";
+                fail: "fail";
+                escalate: "escalate";
+            }>;
+            confidence: z.ZodNumber;
+            findings: z.ZodArray<z.ZodObject<{
+                severity: z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    warn: "warn";
+                    blocker: "blocker";
+                }>;
+                message: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                voter: z.ZodString;
+                vote: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                    abstain: "abstain";
+                    pass: "pass";
+                    fail: "fail";
+                    escalate: "escalate";
+                }>;
+                reasoning: z.ZodString;
+                served: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    family: z.ZodString;
+                    generation: z.ZodString;
+                    variant: z.ZodNullable<z.ZodString>;
+                    tier: z.ZodEnum<{
+                        frontier: "frontier";
+                        large: "large";
+                        medium: "medium";
+                        small: "small";
+                    }>;
+                    raw: z.ZodString;
+                    resolvedBy: z.ZodEnum<{
+                        unknown: "unknown";
+                        table: "table";
+                        rule: "rule";
+                    }>;
+                    contextWindow: z.ZodNullable<z.ZodNumber>;
+                    inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                    outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            cost: z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+                wallClockMs: z.ZodOptional<z.ZodNumber>;
+                byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    tokens: z.ZodNumber;
+                    usd: z.ZodNumber;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        reviewVerdict: z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodString;
+            gate: z.ZodString;
+            result: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                abstain: "abstain";
+                pass: "pass";
+                fail: "fail";
+                escalate: "escalate";
+            }>;
+            confidence: z.ZodNumber;
+            findings: z.ZodArray<z.ZodObject<{
+                severity: z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    warn: "warn";
+                    blocker: "blocker";
+                }>;
+                message: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                voter: z.ZodString;
+                vote: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                    abstain: "abstain";
+                    pass: "pass";
+                    fail: "fail";
+                    escalate: "escalate";
+                }>;
+                reasoning: z.ZodString;
+                served: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    family: z.ZodString;
+                    generation: z.ZodString;
+                    variant: z.ZodNullable<z.ZodString>;
+                    tier: z.ZodEnum<{
+                        frontier: "frontier";
+                        large: "large";
+                        medium: "medium";
+                        small: "small";
+                    }>;
+                    raw: z.ZodString;
+                    resolvedBy: z.ZodEnum<{
+                        unknown: "unknown";
+                        table: "table";
+                        rule: "rule";
+                    }>;
+                    contextWindow: z.ZodNullable<z.ZodNumber>;
+                    inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                    outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            cost: z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+                wallClockMs: z.ZodOptional<z.ZodNumber>;
+                byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    tokens: z.ZodNumber;
+                    usd: z.ZodNumber;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        parsimonyVerdict: z.ZodOptional<z.ZodObject<{
+            taskId: z.ZodString;
+            gate: z.ZodString;
+            result: z.ZodEnum<{
+                approve: "approve";
+                reject: "reject";
+                abstain: "abstain";
+                pass: "pass";
+                fail: "fail";
+                escalate: "escalate";
+            }>;
+            confidence: z.ZodNumber;
+            findings: z.ZodArray<z.ZodObject<{
+                severity: z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    warn: "warn";
+                    blocker: "blocker";
+                }>;
+                message: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                voter: z.ZodString;
+                vote: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                    abstain: "abstain";
+                    pass: "pass";
+                    fail: "fail";
+                    escalate: "escalate";
+                }>;
+                reasoning: z.ZodString;
+                served: z.ZodOptional<z.ZodObject<{
+                    provider: z.ZodString;
+                    family: z.ZodString;
+                    generation: z.ZodString;
+                    variant: z.ZodNullable<z.ZodString>;
+                    tier: z.ZodEnum<{
+                        frontier: "frontier";
+                        large: "large";
+                        medium: "medium";
+                        small: "small";
+                    }>;
+                    raw: z.ZodString;
+                    resolvedBy: z.ZodEnum<{
+                        unknown: "unknown";
+                        table: "table";
+                        rule: "rule";
+                    }>;
+                    contextWindow: z.ZodNullable<z.ZodNumber>;
+                    inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                    outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            cost: z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+                wallClockMs: z.ZodOptional<z.ZodNumber>;
+                byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    tokens: z.ZodNumber;
+                    usd: z.ZodNumber;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        error: z.ZodOptional<z.ZodString>;
+        iteration: z.ZodDefault<z.ZodNumber>;
+        findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warn: "warn";
+                blocker: "blocker";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        escalated: z.ZodOptional<z.ZodBoolean>;
+        spend: z.ZodOptional<z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    trace: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        node: z.ZodString;
+        iteration: z.ZodNumber;
+        childId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    observedMaxNodeSpend: z.ZodDefault<z.ZodObject<{
+        tokens: z.ZodNumber;
+        usd: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RunState = z.infer<typeof RunStateSchema>;
+/**
+ * One checkpoint row, persisted through the injected store after EVERY node
+ * completion [CLM-0044]: `{runId, seq, node, iteration, state}` where `node`
+ * is the node that just completed and `state` already points past it.
+ */
+export declare const CheckpointRecordSchema: z.ZodObject<{
+    runId: z.ZodString;
+    seq: z.ZodNumber;
+    node: z.ZodString;
+    iteration: z.ZodNumber;
+    state: z.ZodObject<{
+        task: z.ZodObject<{
+            id: z.ZodString;
+            parent: z.ZodOptional<z.ZodString>;
+            goal: z.ZodString;
+            constraints: z.ZodArray<z.ZodString>;
+            budget: z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+                wallClockMin: z.ZodNumber;
+            }, z.core.$strict>;
+            evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    test: "test";
+                    ci: "ci";
+                    doc: "doc";
+                    eval: "eval";
+                }>;
+                ref: z.ZodString;
+            }, z.core.$strict>>;
+            definitionOfDone: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                command: z.ZodString;
+            }, z.core.$strict>>;
+            authorityCeiling: z.ZodEnum<{
+                observe: "observe";
+                suggest: "suggest";
+                advisory: "advisory";
+                enforce: "enforce";
+            }>;
+            overlay: z.ZodString;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            escalated: "escalated";
+            running: "running";
+            completed: "completed";
+        }>;
+        cursor: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            phase: z.ZodLiteral<"main">;
+            node: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            phase: z.ZodLiteral<"fanout">;
+            childIndex: z.ZodNumber;
+            sub: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            phase: z.ZodLiteral<"done">;
+        }, z.core.$strict>], "phase">;
+        haltReason: z.ZodOptional<z.ZodEnum<{
+            vote: "vote";
+            "vote-escalation": "vote-escalation";
+            budget: "budget";
+        }>>;
+        iteration: z.ZodNumber;
+        values: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        findings: z.ZodArray<z.ZodObject<{
+            severity: z.ZodEnum<{
+                error: "error";
+                info: "info";
+                warn: "warn";
+                blocker: "blocker";
+            }>;
+            message: z.ZodString;
+            path: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        children: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            parent: z.ZodOptional<z.ZodString>;
+            goal: z.ZodString;
+            constraints: z.ZodArray<z.ZodString>;
+            budget: z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+                wallClockMin: z.ZodNumber;
+            }, z.core.$strict>;
+            evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    test: "test";
+                    ci: "ci";
+                    doc: "doc";
+                    eval: "eval";
+                }>;
+                ref: z.ZodString;
+            }, z.core.$strict>>;
+            definitionOfDone: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                command: z.ZodString;
+            }, z.core.$strict>>;
+            authorityCeiling: z.ZodEnum<{
+                observe: "observe";
+                suggest: "suggest";
+                advisory: "advisory";
+                enforce: "enforce";
+            }>;
+            overlay: z.ZodString;
+        }, z.core.$strict>>;
+        childResults: z.ZodArray<z.ZodObject<{
+            child: z.ZodObject<{
+                id: z.ZodString;
+                parent: z.ZodOptional<z.ZodString>;
+                goal: z.ZodString;
+                constraints: z.ZodArray<z.ZodString>;
+                budget: z.ZodObject<{
+                    tokens: z.ZodNumber;
+                    usd: z.ZodNumber;
+                    wallClockMin: z.ZodNumber;
+                }, z.core.$strict>;
+                evidence: z.ZodArray<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        test: "test";
+                        ci: "ci";
+                        doc: "doc";
+                        eval: "eval";
+                    }>;
+                    ref: z.ZodString;
+                }, z.core.$strict>>;
+                definitionOfDone: z.ZodArray<z.ZodObject<{
+                    name: z.ZodString;
+                    command: z.ZodString;
+                }, z.core.$strict>>;
+                authorityCeiling: z.ZodEnum<{
+                    observe: "observe";
+                    suggest: "suggest";
+                    advisory: "advisory";
+                    enforce: "enforce";
+                }>;
+                overlay: z.ZodString;
+            }, z.core.$strict>;
+            output: z.ZodOptional<z.ZodUnknown>;
+            verdict: z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+                gate: z.ZodString;
+                result: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                    abstain: "abstain";
+                    pass: "pass";
+                    fail: "fail";
+                    escalate: "escalate";
+                }>;
+                confidence: z.ZodNumber;
+                findings: z.ZodArray<z.ZodObject<{
+                    severity: z.ZodEnum<{
+                        error: "error";
+                        info: "info";
+                        warn: "warn";
+                        blocker: "blocker";
+                    }>;
+                    message: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    voter: z.ZodString;
+                    vote: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                        abstain: "abstain";
+                        pass: "pass";
+                        fail: "fail";
+                        escalate: "escalate";
+                    }>;
+                    reasoning: z.ZodString;
+                    served: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodString;
+                        family: z.ZodString;
+                        generation: z.ZodString;
+                        variant: z.ZodNullable<z.ZodString>;
+                        tier: z.ZodEnum<{
+                            frontier: "frontier";
+                            large: "large";
+                            medium: "medium";
+                            small: "small";
+                        }>;
+                        raw: z.ZodString;
+                        resolvedBy: z.ZodEnum<{
+                            unknown: "unknown";
+                            table: "table";
+                            rule: "rule";
+                        }>;
+                        contextWindow: z.ZodNullable<z.ZodNumber>;
+                        inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                        outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                cost: z.ZodObject<{
+                    tokens: z.ZodNumber;
+                    usd: z.ZodNumber;
+                    wallClockMs: z.ZodOptional<z.ZodNumber>;
+                    byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        tokens: z.ZodNumber;
+                        usd: z.ZodNumber;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            reviewVerdict: z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+                gate: z.ZodString;
+                result: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                    abstain: "abstain";
+                    pass: "pass";
+                    fail: "fail";
+                    escalate: "escalate";
+                }>;
+                confidence: z.ZodNumber;
+                findings: z.ZodArray<z.ZodObject<{
+                    severity: z.ZodEnum<{
+                        error: "error";
+                        info: "info";
+                        warn: "warn";
+                        blocker: "blocker";
+                    }>;
+                    message: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    voter: z.ZodString;
+                    vote: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                        abstain: "abstain";
+                        pass: "pass";
+                        fail: "fail";
+                        escalate: "escalate";
+                    }>;
+                    reasoning: z.ZodString;
+                    served: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodString;
+                        family: z.ZodString;
+                        generation: z.ZodString;
+                        variant: z.ZodNullable<z.ZodString>;
+                        tier: z.ZodEnum<{
+                            frontier: "frontier";
+                            large: "large";
+                            medium: "medium";
+                            small: "small";
+                        }>;
+                        raw: z.ZodString;
+                        resolvedBy: z.ZodEnum<{
+                            unknown: "unknown";
+                            table: "table";
+                            rule: "rule";
+                        }>;
+                        contextWindow: z.ZodNullable<z.ZodNumber>;
+                        inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                        outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                cost: z.ZodObject<{
+                    tokens: z.ZodNumber;
+                    usd: z.ZodNumber;
+                    wallClockMs: z.ZodOptional<z.ZodNumber>;
+                    byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        tokens: z.ZodNumber;
+                        usd: z.ZodNumber;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            parsimonyVerdict: z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+                gate: z.ZodString;
+                result: z.ZodEnum<{
+                    approve: "approve";
+                    reject: "reject";
+                    abstain: "abstain";
+                    pass: "pass";
+                    fail: "fail";
+                    escalate: "escalate";
+                }>;
+                confidence: z.ZodNumber;
+                findings: z.ZodArray<z.ZodObject<{
+                    severity: z.ZodEnum<{
+                        error: "error";
+                        info: "info";
+                        warn: "warn";
+                        blocker: "blocker";
+                    }>;
+                    message: z.ZodString;
+                    path: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+                voters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    voter: z.ZodString;
+                    vote: z.ZodEnum<{
+                        approve: "approve";
+                        reject: "reject";
+                        abstain: "abstain";
+                        pass: "pass";
+                        fail: "fail";
+                        escalate: "escalate";
+                    }>;
+                    reasoning: z.ZodString;
+                    served: z.ZodOptional<z.ZodObject<{
+                        provider: z.ZodString;
+                        family: z.ZodString;
+                        generation: z.ZodString;
+                        variant: z.ZodNullable<z.ZodString>;
+                        tier: z.ZodEnum<{
+                            frontier: "frontier";
+                            large: "large";
+                            medium: "medium";
+                            small: "small";
+                        }>;
+                        raw: z.ZodString;
+                        resolvedBy: z.ZodEnum<{
+                            unknown: "unknown";
+                            table: "table";
+                            rule: "rule";
+                        }>;
+                        contextWindow: z.ZodNullable<z.ZodNumber>;
+                        inputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                        outputCostPerMTok: z.ZodNullable<z.ZodNumber>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                cost: z.ZodObject<{
+                    tokens: z.ZodNumber;
+                    usd: z.ZodNumber;
+                    wallClockMs: z.ZodOptional<z.ZodNumber>;
+                    byAdapter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        tokens: z.ZodNumber;
+                        usd: z.ZodNumber;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            error: z.ZodOptional<z.ZodString>;
+            iteration: z.ZodDefault<z.ZodNumber>;
+            findings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                severity: z.ZodEnum<{
+                    error: "error";
+                    info: "info";
+                    warn: "warn";
+                    blocker: "blocker";
+                }>;
+                message: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            escalated: z.ZodOptional<z.ZodBoolean>;
+            spend: z.ZodOptional<z.ZodObject<{
+                tokens: z.ZodNumber;
+                usd: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        trace: z.ZodArray<z.ZodObject<{
+            seq: z.ZodNumber;
+            node: z.ZodString;
+            iteration: z.ZodNumber;
+            childId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        observedMaxNodeSpend: z.ZodDefault<z.ZodObject<{
+            tokens: z.ZodNumber;
+            usd: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    createdAt: z.ZodString;
+}, z.core.$strict>;
+export type CheckpointRecord = z.infer<typeof CheckpointRecordSchema>;
+/** Why a run stopped without completing (or could not start/resume). */
+export type WorkflowErrorCode = 'unwired_node' | 'invalid_task' | 'edge_contract' | 'executor_failed' | 'aborted' | 'checkpoint_failed' | 'no_checkpoint' | 'corrupt_checkpoint';
+/**
+ * Typed engine failure. Edge-contract failures name the node and the
+ * contract the emission violated [CLM-0042].
+ */
+export declare class WorkflowError extends Error {
+    readonly code: WorkflowErrorCode;
+    /** Node involved, when one is. */
+    readonly node?: string;
+    /** Contract violated, for `edge_contract`. */
+    readonly contract?: string;
+    constructor(code: WorkflowErrorCode, message: string, details?: {
+        node?: string;
+        contract?: string;
+        cause?: unknown;
+    });
+}
+/** Terminal report of a run (or of a resumed continuation of one). */
+export interface RunResult {
+    readonly runId: string;
+    /**
+     * `completed` — retrospect emitted the final Outcome;
+     * `escalated` — the vote-iterate bound K was exhausted; the run HALTED
+     *   with its findings and resumes from plan after the human edits
+     *   [CLM-0043];
+     * `failed` — a typed error stopped the run; the last checkpoint is
+     *   intact and `resume(runId)` re-attempts from it [CLM-0044].
+     */
+    readonly status: 'completed' | 'escalated' | 'failed';
+    readonly nodeTrace: readonly TraceEntry[];
+    /** The final Outcome, on completion. */
+    readonly outcome?: Outcome;
+    /**
+     * Why an escalated run halted, surfaced so an operator can triage: `vote` (the
+     * K vote-iterate bound), `vote-escalation` (a vote gate ruled `escalate` — a
+     * deadlocked panel asking a human, #192), or `budget`. Present only on
+     * `escalated`; the cli maps a cooperative-abort cancel to its own `'aborted'`.
+     */
+    readonly haltReason?: 'vote' | 'vote-escalation' | 'budget';
+    /** Accumulated rejecting-vote findings, on escalation. */
+    readonly findings?: readonly Finding[];
+    /** The typed error, on failure. */
+    readonly error?: WorkflowError;
+    /**
+     * Per-child metered spend attribution (#56), present when the run was metered
+     * (a `meteredSpend` seam was injected) and produced fan-out children. One
+     * entry per child whose sub-chain incurred spend.
+     */
+    readonly childSpend?: readonly {
+        readonly childId: string;
+        readonly spend: ChildSpend;
+    }[];
+}
+//# sourceMappingURL=state.d.ts.map