@osovv/vv-opencode 1.5.0 → 1.6.0

package/dist/plugins/workflow/results.d.ts

@@ -0,0 +1,2566 @@
+import type { z } from "zod";
+import { type ContractIssue } from "../../lib/agent-tool-contract.js";
+/**
+ * Documented finite bounds for failure diagnostics only. Success payloads,
+ * history, scope files, and batch arrays are never bounded here.
+ */
+export declare const MAX_FAILURE_MESSAGE_CHARS: number;
+export declare const MAX_FAILURE_FIELD_CHARS = 200;
+/** Stable failure categories. Unrecognized owned codes classify as `state`. */
+export declare const WORKFLOW_FAILURE_CATEGORIES: readonly ["input", "state", "authorization", "host_context", "persistence", "internal"];
+export type WorkflowFailureCategory = (typeof WORKFLOW_FAILURE_CATEGORIES)[number];
+/** Truthful post-side-effect outcome vocabulary; keep claims to what was observed. */
+export declare const WORKFLOW_MUTATION_OUTCOMES: readonly ["committed", "not_applied", "rolled_back", "unknown"];
+export type WorkflowMutationOutcome = (typeof WORKFLOW_MUTATION_OUTCOMES)[number];
+/** Classify an existing workflow error code into a stable failure category. */
+export declare function categoryForWorkflowErrorCode(errorCode: string): WorkflowFailureCategory;
+interface WorkflowFailureGuidance {
+    readonly prerequisite?: string;
+    readonly nextAction?: string;
+}
+/** Bounded prerequisite/next-action guidance for a known failure family. */
+export declare function failureGuidance(errorCode: string): WorkflowFailureGuidance | undefined;
+/**
+ * Bound failure issues to the shared finite contract limits. Called by every
+ * failure constructor and by normalization so a caller cannot smuggle an
+ * unbounded issue list or oversized path/message into a public failure.
+ */
+export declare function boundContractIssues(issues: readonly ContractIssue[]): readonly ContractIssue[];
+/**
+ * Enumerated bounded public failure. `applied` is only asserted for known
+ * outcomes: omitted for `unknown` so an unknown outcome can never be read as
+ * "not applied".
+ */
+export interface WorkflowFailure {
+    readonly ok: false;
+    readonly tool?: string;
+    readonly sessionId?: string;
+    readonly errorCode: string;
+    readonly category: WorkflowFailureCategory;
+    readonly message: string;
+    readonly issues?: readonly ContractIssue[];
+    readonly state?: string;
+    readonly attempt?: number;
+    readonly attemptStatus?: string;
+    readonly resultStatus?: string;
+    readonly attemptBudget?: number;
+    readonly remainingAttempts?: number;
+    readonly recoveryCount?: number;
+    readonly pendingReviewers?: readonly string[];
+    readonly prerequisite?: string;
+    readonly nextAction?: string;
+    readonly outcome?: WorkflowMutationOutcome;
+    readonly applied?: boolean;
+    readonly retrySafe?: boolean;
+    readonly existingWorkItemId?: string;
+    readonly runId?: string;
+}
+/**
+ * Record-compatible failure result for positions declared as
+ * `Record<string, unknown>`. The known fields are enumerated on
+ * `WorkflowFailure`; this alias only makes the bounded DTO storable in the
+ * generic result channel.
+ */
+export type WorkflowFailureResult = WorkflowFailure & Record<string, unknown>;
+/**
+ * Add a stable category and bounded guidance to one failure object without
+ * mutating it or parsing its message text. Existing errorCode and message are
+ * preserved; explicit caller-supplied category/guidance/context wins.
+ */
+export declare function normalizeWorkflowFailure(failure: Record<string, unknown>): WorkflowFailureResult;
+/**
+ * Normalize a public workflow result for output: failure envelopes (top-level
+ * and batch items) gain category/guidance, everything else is returned as-is.
+ * Input is never mutated. This is the producer-side representation step;
+ * `validateWorkflowToolResult` validates without repair.
+ */
+export declare function normalizeWorkflowResult(value: unknown): unknown;
+/** Producer-side finalization: typed identity wrapper around `normalizeWorkflowResult`. */
+export declare function finalizeWorkflowResult<T>(value: T): T;
+/** Bounded caller-input failure carrying the exact tokenized issues. */
+export declare function workflowInputFailure(toolId: string, sessionId: string, issues: readonly ContractIssue[]): WorkflowFailureResult;
+/**
+ * Trusted-host-context failure: a missing workspace root, plan loader, or
+ * authorization lookup is not a caller argument error.
+ */
+export declare function workflowHostContextFailure(toolId: string, sessionId: string, message: string): WorkflowFailureResult;
+/**
+ * Internal result-contract/serialization failure with the observed outcome.
+ * Never reported as caller input and never invites an unqualified replay. An
+ * `unknown` outcome omits `applied` entirely.
+ */
+export declare function workflowInternalResultFailure(options: {
+    tool: string;
+    sessionId?: string;
+    message: string;
+    outcome: WorkflowMutationOutcome;
+}): WorkflowFailureResult;
+/**
+ * Thrown owned diagnostic carrying a stable code and category. The message is
+ * bounded for failure diagnostics while preserving its leading code/prefix.
+ */
+export declare class WorkflowDiagnosticError extends Error {
+    readonly code: string;
+    readonly category: WorkflowFailureCategory;
+    readonly outcome?: WorkflowMutationOutcome;
+    constructor(code: string, category: WorkflowFailureCategory, message: string, outcome?: WorkflowMutationOutcome);
+}
+/** Generic failure schema; `tool` stays open so any owned tool can be validated. */
+export declare const workflowFailureSchema: z.ZodObject<{
+    sessionId: z.ZodOptional<z.ZodString>;
+    ok: z.ZodLiteral<false>;
+    errorCode: z.ZodString;
+    category: z.ZodEnum<{
+        input: "input";
+        host_context: "host_context";
+        state: "state";
+        authorization: "authorization";
+        persistence: "persistence";
+        internal: "internal";
+    }>;
+    message: z.ZodString;
+    issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            unrecognized_keys: "unrecognized_keys";
+            invalid_value: "invalid_value";
+            invalid_type: "invalid_type";
+            invalid_format: "invalid_format";
+            too_small: "too_small";
+            too_big: "too_big";
+            missing_value: "missing_value";
+            invalid_union: "invalid_union";
+            custom: "custom";
+        }>;
+        path: z.ZodString;
+        message: z.ZodString;
+        expected: z.ZodOptional<z.ZodString>;
+        received: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    state: z.ZodOptional<z.ZodString>;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    attemptStatus: z.ZodOptional<z.ZodString>;
+    resultStatus: z.ZodOptional<z.ZodString>;
+    attemptBudget: z.ZodOptional<z.ZodNumber>;
+    remainingAttempts: z.ZodOptional<z.ZodNumber>;
+    recoveryCount: z.ZodOptional<z.ZodNumber>;
+    pendingReviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    prerequisite: z.ZodOptional<z.ZodString>;
+    nextAction: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodOptional<z.ZodEnum<{
+        unknown: "unknown";
+        committed: "committed";
+        not_applied: "not_applied";
+        rolled_back: "rolled_back";
+    }>>;
+    applied: z.ZodOptional<z.ZodBoolean>;
+    retrySafe: z.ZodOptional<z.ZodBoolean>;
+    existingWorkItemId: z.ZodOptional<z.ZodString>;
+    runId: z.ZodOptional<z.ZodString>;
+    tool: z.ZodString;
+}, z.core.$strict>;
+declare const workItemViewSchema: z.ZodObject<{
+    workItemId: z.ZodString;
+    header: z.ZodString;
+    key: z.ZodString;
+    title: z.ZodString;
+    mode: z.ZodEnum<{
+        delegated: "delegated";
+        implementation: "implementation";
+        review_only: "review_only";
+    }>;
+    requiredReviewers: z.ZodArray<z.ZodEnum<{
+        spec: "spec";
+        code: "code";
+    }>>;
+    state: z.ZodEnum<{
+        open: "open";
+        awaiting_implementer: "awaiting_implementer";
+        awaiting_reviews: "awaiting_reviews";
+        awaiting_acceptance: "awaiting_acceptance";
+        needs_context: "needs_context";
+        blocked: "blocked";
+        ready_to_close: "ready_to_close";
+        closed: "closed";
+    }>;
+    specReviewCount: z.ZodNumber;
+    codeReviewCount: z.ZodNumber;
+    reviewRound: z.ZodNumber;
+    currentRound: z.ZodOptional<z.ZodObject<{
+        round: z.ZodNumber;
+        requiredReviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        pendingReviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        inFlightReviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        completedReviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        results: z.ZodObject<{
+            spec: z.ZodOptional<z.ZodObject<{
+                reviewer: z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>;
+                agent: z.ZodEnum<{
+                    "vv-spec-reviewer": "vv-spec-reviewer";
+                    "vv-code-reviewer": "vv-code-reviewer";
+                }>;
+                status: z.ZodEnum<{
+                    FAIL: "FAIL";
+                    NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                    PASS: "PASS";
+                }>;
+                completedAt: z.ZodString;
+                resultExcerpt: z.ZodOptional<z.ZodObject<{
+                    source: z.ZodEnum<{
+                        parsed_body: "parsed_body";
+                        normalized_output: "normalized_output";
+                    }>;
+                    text: z.ZodString;
+                    truncated: z.ZodBoolean;
+                    originalLength: z.ZodNumber;
+                    maxLength: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            code: z.ZodOptional<z.ZodObject<{
+                reviewer: z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>;
+                agent: z.ZodEnum<{
+                    "vv-spec-reviewer": "vv-spec-reviewer";
+                    "vv-code-reviewer": "vv-code-reviewer";
+                }>;
+                status: z.ZodEnum<{
+                    FAIL: "FAIL";
+                    NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                    PASS: "PASS";
+                }>;
+                completedAt: z.ZodString;
+                resultExcerpt: z.ZodOptional<z.ZodObject<{
+                    source: z.ZodEnum<{
+                        parsed_body: "parsed_body";
+                        normalized_output: "normalized_output";
+                    }>;
+                    text: z.ZodString;
+                    truncated: z.ZodBoolean;
+                    originalLength: z.ZodNumber;
+                    maxLength: z.ZodNumber;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        status: z.ZodEnum<{
+            active: "active";
+            completed: "completed";
+        }>;
+        createdAt: z.ZodString;
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    resultExcerpt: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            parsed_body: "parsed_body";
+            normalized_output: "normalized_output";
+        }>;
+        text: z.ZodString;
+        truncated: z.ZodBoolean;
+        originalLength: z.ZodNumber;
+        maxLength: z.ZodNumber;
+    }, z.core.$strict>>;
+    completedReviewRoundCount: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    closedAt: z.ZodOptional<z.ZodString>;
+    delegated: z.ZodOptional<z.ZodObject<{
+        writeScope: z.ZodArray<z.ZodString>;
+        planRunId: z.ZodOptional<z.ZodString>;
+        planTaskId: z.ZodOptional<z.ZodString>;
+        attempts: z.ZodNumber;
+        inFlightAttempt: z.ZodBoolean;
+        decisions: z.ZodNumber;
+        accepted: z.ZodBoolean;
+        acceptedAttempt: z.ZodOptional<z.ZodNumber>;
+        reworkCount: z.ZodNumber;
+        attemptBudget: z.ZodNumber;
+        remainingAttempts: z.ZodNumber;
+        recoveryCount: z.ZodNumber;
+        autonomousGrantConsumed: z.ZodBoolean;
+        reportRejectionCount: z.ZodNumber;
+        nextAction: z.ZodEnum<{
+            closed: "closed";
+            launch_implementer: "launch_implementer";
+            await_result: "await_result";
+            decide: "decide";
+            recover: "recover";
+            recover_with_user_authorization: "recover_with_user_authorization";
+            launch_blocked: "launch_blocked";
+            close: "close";
+        }>;
+        latestAttempt: z.ZodOptional<z.ZodObject<{
+            attempt: z.ZodNumber;
+            status: z.ZodEnum<{
+                completed: "completed";
+                in_flight: "in_flight";
+                failed: "failed";
+                report_rejected: "report_rejected";
+            }>;
+            resultStatus: z.ZodOptional<z.ZodEnum<{
+                DONE: "DONE";
+                DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                BLOCKED: "BLOCKED";
+            }>>;
+            completedAt: z.ZodOptional<z.ZodString>;
+            reportRejected: z.ZodBoolean;
+        }, z.core.$strict>>;
+        guidance: z.ZodOptional<z.ZodObject<{
+            nextAction: z.ZodEnum<{
+                closed: "closed";
+                launch_implementer: "launch_implementer";
+                await_result: "await_result";
+                decide: "decide";
+                recover: "recover";
+                recover_with_user_authorization: "recover_with_user_authorization";
+                launch_blocked: "launch_blocked";
+                close: "close";
+            }>;
+            launchEligible: z.ZodBoolean;
+            blockers: z.ZodArray<z.ZodString>;
+            prerequisites: z.ZodArray<z.ZodString>;
+            requiresConcernsDisposition: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const executionViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    executionKey: z.ZodString;
+    sourceKind: z.ZodEnum<{
+        "native-package": "native-package";
+        "provided-plan": "provided-plan";
+        "conversation-scoped": "conversation-scoped";
+    }>;
+    goal: z.ZodString;
+    state: z.ZodEnum<{
+        preparing: "preparing";
+        active: "active";
+        sealed: "sealed";
+    }>;
+    revision: z.ZodNumber;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        workItemId: z.ZodString;
+        status: z.ZodEnum<{
+            pending: "pending";
+            launched: "launched";
+            accepted: "accepted";
+            superseded: "superseded";
+        }>;
+        requiredReviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        blockedBy: z.ZodArray<z.ZodString>;
+        latestAttempt: z.ZodOptional<z.ZodObject<{
+            attempt: z.ZodNumber;
+            status: z.ZodEnum<{
+                completed: "completed";
+                in_flight: "in_flight";
+                failed: "failed";
+                report_rejected: "report_rejected";
+            }>;
+            resultStatus: z.ZodOptional<z.ZodEnum<{
+                DONE: "DONE";
+                DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                BLOCKED: "BLOCKED";
+            }>>;
+            completedAt: z.ZodOptional<z.ZodString>;
+            reportRejected: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    checkpoints: z.ZodArray<z.ZodObject<{
+        checkpointId: z.ZodString;
+        kind: z.ZodEnum<{
+            milestone: "milestone";
+            final: "final";
+        }>;
+        covers: z.ZodArray<z.ZodString>;
+        requiredReviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        status: z.ZodOptional<z.ZodString>;
+        reviewWorkItemId: z.ZodOptional<z.ZodString>;
+        generation: z.ZodOptional<z.ZodNumber>;
+        recoveryCount: z.ZodOptional<z.ZodNumber>;
+        attempts: z.ZodOptional<z.ZodNumber>;
+        generationBudget: z.ZodOptional<z.ZodNumber>;
+        remainingGenerations: z.ZodOptional<z.ZodNumber>;
+        lastOutcome: z.ZodOptional<z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            stale: "stale";
+            stopped: "stopped";
+            incomplete: "incomplete";
+        }>>;
+        nextAction: z.ZodOptional<z.ZodEnum<{
+            start: "start";
+            blocked: "blocked";
+            recover: "recover";
+            recover_with_user_authorization: "recover_with_user_authorization";
+            passed: "passed";
+            collect_and_verify: "collect_and_verify";
+            start_next_generation: "start_next_generation";
+        }>>;
+        prerequisite: z.ZodOptional<z.ZodString>;
+        currentReview: z.ZodOptional<z.ZodObject<{
+            reviewWorkItemId: z.ZodString;
+            generation: z.ZodNumber;
+            coveredAttemptIds: z.ZodArray<z.ZodString>;
+            recordedReviewers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            generation: z.ZodNumber;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                stale: "stale";
+                stopped: "stopped";
+            }>;
+            completedAt: z.ZodString;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    authority: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        authorityId: z.ZodString;
+        availableUnits: z.ZodNumber;
+        revoked: z.ZodBoolean;
+        stages: z.ZodArray<z.ZodEnum<{
+            implementation: "implementation";
+            specification: "specification";
+            planning: "planning";
+            verification: "verification";
+        }>>;
+        reservedStops: z.ZodArray<z.ZodEnum<{
+            implementation: "implementation";
+            specification: "specification";
+            planning: "planning";
+            verification: "verification";
+        }>>;
+        prerequisites: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+declare const delegatedRunViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    sessionId: z.ZodString;
+    planPath: z.ZodString;
+    specPath: z.ZodString;
+    workspaceRoot: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        sealed: "sealed";
+    }>;
+    registeredAt: z.ZodString;
+    sealedAt: z.ZodOptional<z.ZodString>;
+    finalCheckpointId: z.ZodOptional<z.ZodString>;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        workItemId: z.ZodString;
+    }, z.core.$strict>>;
+    checkpoints: z.ZodArray<z.ZodObject<{
+        checkpointId: z.ZodString;
+        kind: z.ZodEnum<{
+            milestone: "milestone";
+            final: "final";
+        }>;
+        afterWave: z.ZodString;
+        covers: z.ZodArray<z.ZodString>;
+        scope: z.ZodArray<z.ZodString>;
+        reviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            in_review: "in_review";
+            passed: "passed";
+        }>;
+        attempts: z.ZodNumber;
+        lastOutcome: z.ZodOptional<z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            stale: "stale";
+            stopped: "stopped";
+            incomplete: "incomplete";
+        }>>;
+        generationBudget: z.ZodNumber;
+        remainingGenerations: z.ZodNumber;
+        recoveryCount: z.ZodNumber;
+        nextAction: z.ZodEnum<{
+            start: "start";
+            blocked: "blocked";
+            recover: "recover";
+            recover_with_user_authorization: "recover_with_user_authorization";
+            passed: "passed";
+            collect_and_verify: "collect_and_verify";
+            start_next_generation: "start_next_generation";
+        }>;
+        prerequisite: z.ZodOptional<z.ZodString>;
+        currentReview: z.ZodOptional<z.ZodObject<{
+            reviewWorkItemId: z.ZodString;
+            generation: z.ZodNumber;
+            coveredAttemptIds: z.ZodArray<z.ZodString>;
+            recordedReviewers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        history: z.ZodArray<z.ZodObject<{
+            generation: z.ZodNumber;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                stale: "stale";
+                stopped: "stopped";
+            }>;
+            fingerprint: z.ZodString;
+            completedAt: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const workflowContractIdentitySchema: z.ZodObject<{
+    packageName: z.ZodString;
+    packageVersion: z.ZodString;
+    toolContractRevision: z.ZodString;
+    referencePath: z.ZodString;
+}, z.core.$strict>;
+declare const workItemListViewSchema: z.ZodObject<{
+    tool: z.ZodLiteral<"work_item_list">;
+    sessionId: z.ZodString;
+    includeClosed: z.ZodBoolean;
+    items: z.ZodArray<z.ZodObject<{
+        workItemId: z.ZodString;
+        header: z.ZodString;
+        key: z.ZodString;
+        title: z.ZodString;
+        mode: z.ZodEnum<{
+            delegated: "delegated";
+            implementation: "implementation";
+            review_only: "review_only";
+        }>;
+        requiredReviewers: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        state: z.ZodEnum<{
+            open: "open";
+            awaiting_implementer: "awaiting_implementer";
+            awaiting_reviews: "awaiting_reviews";
+            awaiting_acceptance: "awaiting_acceptance";
+            needs_context: "needs_context";
+            blocked: "blocked";
+            ready_to_close: "ready_to_close";
+            closed: "closed";
+        }>;
+        specReviewCount: z.ZodNumber;
+        codeReviewCount: z.ZodNumber;
+        reviewRound: z.ZodNumber;
+        currentRound: z.ZodOptional<z.ZodObject<{
+            round: z.ZodNumber;
+            requiredReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            pendingReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            inFlightReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            completedReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            results: z.ZodObject<{
+                spec: z.ZodOptional<z.ZodObject<{
+                    reviewer: z.ZodEnum<{
+                        spec: "spec";
+                        code: "code";
+                    }>;
+                    agent: z.ZodEnum<{
+                        "vv-spec-reviewer": "vv-spec-reviewer";
+                        "vv-code-reviewer": "vv-code-reviewer";
+                    }>;
+                    status: z.ZodEnum<{
+                        FAIL: "FAIL";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        PASS: "PASS";
+                    }>;
+                    completedAt: z.ZodString;
+                    resultExcerpt: z.ZodOptional<z.ZodObject<{
+                        source: z.ZodEnum<{
+                            parsed_body: "parsed_body";
+                            normalized_output: "normalized_output";
+                        }>;
+                        text: z.ZodString;
+                        truncated: z.ZodBoolean;
+                        originalLength: z.ZodNumber;
+                        maxLength: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+                code: z.ZodOptional<z.ZodObject<{
+                    reviewer: z.ZodEnum<{
+                        spec: "spec";
+                        code: "code";
+                    }>;
+                    agent: z.ZodEnum<{
+                        "vv-spec-reviewer": "vv-spec-reviewer";
+                        "vv-code-reviewer": "vv-code-reviewer";
+                    }>;
+                    status: z.ZodEnum<{
+                        FAIL: "FAIL";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        PASS: "PASS";
+                    }>;
+                    completedAt: z.ZodString;
+                    resultExcerpt: z.ZodOptional<z.ZodObject<{
+                        source: z.ZodEnum<{
+                            parsed_body: "parsed_body";
+                            normalized_output: "normalized_output";
+                        }>;
+                        text: z.ZodString;
+                        truncated: z.ZodBoolean;
+                        originalLength: z.ZodNumber;
+                        maxLength: z.ZodNumber;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+            status: z.ZodEnum<{
+                active: "active";
+                completed: "completed";
+            }>;
+            createdAt: z.ZodString;
+            completedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        resultExcerpt: z.ZodOptional<z.ZodObject<{
+            source: z.ZodEnum<{
+                parsed_body: "parsed_body";
+                normalized_output: "normalized_output";
+            }>;
+            text: z.ZodString;
+            truncated: z.ZodBoolean;
+            originalLength: z.ZodNumber;
+            maxLength: z.ZodNumber;
+        }, z.core.$strict>>;
+        completedReviewRoundCount: z.ZodNumber;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        closedAt: z.ZodOptional<z.ZodString>;
+        delegated: z.ZodOptional<z.ZodObject<{
+            writeScope: z.ZodArray<z.ZodString>;
+            planRunId: z.ZodOptional<z.ZodString>;
+            planTaskId: z.ZodOptional<z.ZodString>;
+            attempts: z.ZodNumber;
+            inFlightAttempt: z.ZodBoolean;
+            decisions: z.ZodNumber;
+            accepted: z.ZodBoolean;
+            acceptedAttempt: z.ZodOptional<z.ZodNumber>;
+            reworkCount: z.ZodNumber;
+            attemptBudget: z.ZodNumber;
+            remainingAttempts: z.ZodNumber;
+            recoveryCount: z.ZodNumber;
+            autonomousGrantConsumed: z.ZodBoolean;
+            reportRejectionCount: z.ZodNumber;
+            nextAction: z.ZodEnum<{
+                closed: "closed";
+                launch_implementer: "launch_implementer";
+                await_result: "await_result";
+                decide: "decide";
+                recover: "recover";
+                recover_with_user_authorization: "recover_with_user_authorization";
+                launch_blocked: "launch_blocked";
+                close: "close";
+            }>;
+            latestAttempt: z.ZodOptional<z.ZodObject<{
+                attempt: z.ZodNumber;
+                status: z.ZodEnum<{
+                    completed: "completed";
+                    in_flight: "in_flight";
+                    failed: "failed";
+                    report_rejected: "report_rejected";
+                }>;
+                resultStatus: z.ZodOptional<z.ZodEnum<{
+                    DONE: "DONE";
+                    DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                    NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                    BLOCKED: "BLOCKED";
+                }>>;
+                completedAt: z.ZodOptional<z.ZodString>;
+                reportRejected: z.ZodBoolean;
+            }, z.core.$strict>>;
+            guidance: z.ZodOptional<z.ZodObject<{
+                nextAction: z.ZodEnum<{
+                    closed: "closed";
+                    launch_implementer: "launch_implementer";
+                    await_result: "await_result";
+                    decide: "decide";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    launch_blocked: "launch_blocked";
+                    close: "close";
+                }>;
+                launchEligible: z.ZodBoolean;
+                blockers: z.ZodArray<z.ZodString>;
+                prerequisites: z.ZodArray<z.ZodString>;
+                requiresConcernsDisposition: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    planRuns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        sessionId: z.ZodString;
+        planPath: z.ZodString;
+        specPath: z.ZodString;
+        workspaceRoot: z.ZodString;
+        status: z.ZodEnum<{
+            active: "active";
+            sealed: "sealed";
+        }>;
+        registeredAt: z.ZodString;
+        sealedAt: z.ZodOptional<z.ZodString>;
+        finalCheckpointId: z.ZodOptional<z.ZodString>;
+        tasks: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodString;
+            workItemId: z.ZodString;
+        }, z.core.$strict>>;
+        checkpoints: z.ZodArray<z.ZodObject<{
+            checkpointId: z.ZodString;
+            kind: z.ZodEnum<{
+                milestone: "milestone";
+                final: "final";
+            }>;
+            afterWave: z.ZodString;
+            covers: z.ZodArray<z.ZodString>;
+            scope: z.ZodArray<z.ZodString>;
+            reviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            status: z.ZodEnum<{
+                pending: "pending";
+                failed: "failed";
+                in_review: "in_review";
+                passed: "passed";
+            }>;
+            attempts: z.ZodNumber;
+            lastOutcome: z.ZodOptional<z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                stale: "stale";
+                stopped: "stopped";
+                incomplete: "incomplete";
+            }>>;
+            generationBudget: z.ZodNumber;
+            remainingGenerations: z.ZodNumber;
+            recoveryCount: z.ZodNumber;
+            nextAction: z.ZodEnum<{
+                start: "start";
+                blocked: "blocked";
+                recover: "recover";
+                recover_with_user_authorization: "recover_with_user_authorization";
+                passed: "passed";
+                collect_and_verify: "collect_and_verify";
+                start_next_generation: "start_next_generation";
+            }>;
+            prerequisite: z.ZodOptional<z.ZodString>;
+            currentReview: z.ZodOptional<z.ZodObject<{
+                reviewWorkItemId: z.ZodString;
+                generation: z.ZodNumber;
+                coveredAttemptIds: z.ZodArray<z.ZodString>;
+                recordedReviewers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            history: z.ZodArray<z.ZodObject<{
+                generation: z.ZodNumber;
+                outcome: z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                }>;
+                fingerprint: z.ZodString;
+                completedAt: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    executions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        runId: z.ZodString;
+        sessionId: z.ZodString;
+        executionKey: z.ZodString;
+        sourceKind: z.ZodEnum<{
+            "native-package": "native-package";
+            "provided-plan": "provided-plan";
+            "conversation-scoped": "conversation-scoped";
+        }>;
+        goal: z.ZodString;
+        state: z.ZodEnum<{
+            preparing: "preparing";
+            active: "active";
+            sealed: "sealed";
+        }>;
+        revision: z.ZodNumber;
+        tasks: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodString;
+            workItemId: z.ZodString;
+            status: z.ZodEnum<{
+                pending: "pending";
+                launched: "launched";
+                accepted: "accepted";
+                superseded: "superseded";
+            }>;
+            requiredReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            dependsOn: z.ZodArray<z.ZodString>;
+            blockedBy: z.ZodArray<z.ZodString>;
+            latestAttempt: z.ZodOptional<z.ZodObject<{
+                attempt: z.ZodNumber;
+                status: z.ZodEnum<{
+                    completed: "completed";
+                    in_flight: "in_flight";
+                    failed: "failed";
+                    report_rejected: "report_rejected";
+                }>;
+                resultStatus: z.ZodOptional<z.ZodEnum<{
+                    DONE: "DONE";
+                    DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                    NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                    BLOCKED: "BLOCKED";
+                }>>;
+                completedAt: z.ZodOptional<z.ZodString>;
+                reportRejected: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        checkpoints: z.ZodArray<z.ZodObject<{
+            checkpointId: z.ZodString;
+            kind: z.ZodEnum<{
+                milestone: "milestone";
+                final: "final";
+            }>;
+            covers: z.ZodArray<z.ZodString>;
+            requiredReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            status: z.ZodOptional<z.ZodString>;
+            reviewWorkItemId: z.ZodOptional<z.ZodString>;
+            generation: z.ZodOptional<z.ZodNumber>;
+            recoveryCount: z.ZodOptional<z.ZodNumber>;
+            attempts: z.ZodOptional<z.ZodNumber>;
+            generationBudget: z.ZodOptional<z.ZodNumber>;
+            remainingGenerations: z.ZodOptional<z.ZodNumber>;
+            lastOutcome: z.ZodOptional<z.ZodEnum<{
+                failed: "failed";
+                passed: "passed";
+                stale: "stale";
+                stopped: "stopped";
+                incomplete: "incomplete";
+            }>>;
+            nextAction: z.ZodOptional<z.ZodEnum<{
+                start: "start";
+                blocked: "blocked";
+                recover: "recover";
+                recover_with_user_authorization: "recover_with_user_authorization";
+                passed: "passed";
+                collect_and_verify: "collect_and_verify";
+                start_next_generation: "start_next_generation";
+            }>>;
+            prerequisite: z.ZodOptional<z.ZodString>;
+            currentReview: z.ZodOptional<z.ZodObject<{
+                reviewWorkItemId: z.ZodString;
+                generation: z.ZodNumber;
+                coveredAttemptIds: z.ZodArray<z.ZodString>;
+                recordedReviewers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>;
+            history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                generation: z.ZodNumber;
+                outcome: z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                }>;
+                completedAt: z.ZodString;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        authority: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            authorityId: z.ZodString;
+            availableUnits: z.ZodNumber;
+            revoked: z.ZodBoolean;
+            stages: z.ZodArray<z.ZodEnum<{
+                implementation: "implementation";
+                specification: "specification";
+                planning: "planning";
+                verification: "verification";
+            }>>;
+            reservedStops: z.ZodArray<z.ZodEnum<{
+                implementation: "implementation";
+                specification: "specification";
+                planning: "planning";
+                verification: "verification";
+            }>>;
+            prerequisites: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>>;
+    contract: z.ZodObject<{
+        packageName: z.ZodString;
+        packageVersion: z.ZodString;
+        toolContractRevision: z.ZodString;
+        referencePath: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Closed per-tool result schema map; exported for inspection/catalog consumers. */
+export declare const workflowToolResultSchemas: {
+    readonly work_item_open: z.ZodUnion<readonly [z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_open">;
+        sessionId: z.ZodString;
+        items: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+            reused: z.ZodBoolean;
+            workItemId: z.ZodString;
+            header: z.ZodString;
+            key: z.ZodString;
+            title: z.ZodString;
+            mode: z.ZodEnum<{
+                delegated: "delegated";
+                implementation: "implementation";
+                review_only: "review_only";
+            }>;
+            requiredReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            state: z.ZodEnum<{
+                open: "open";
+                awaiting_implementer: "awaiting_implementer";
+                awaiting_reviews: "awaiting_reviews";
+                awaiting_acceptance: "awaiting_acceptance";
+                needs_context: "needs_context";
+                blocked: "blocked";
+                ready_to_close: "ready_to_close";
+                closed: "closed";
+            }>;
+            specReviewCount: z.ZodNumber;
+            codeReviewCount: z.ZodNumber;
+            reviewRound: z.ZodNumber;
+            currentRound: z.ZodOptional<z.ZodObject<{
+                round: z.ZodNumber;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                pendingReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                inFlightReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                completedReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                results: z.ZodObject<{
+                    spec: z.ZodOptional<z.ZodObject<{
+                        reviewer: z.ZodEnum<{
+                            spec: "spec";
+                            code: "code";
+                        }>;
+                        agent: z.ZodEnum<{
+                            "vv-spec-reviewer": "vv-spec-reviewer";
+                            "vv-code-reviewer": "vv-code-reviewer";
+                        }>;
+                        status: z.ZodEnum<{
+                            FAIL: "FAIL";
+                            NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                            PASS: "PASS";
+                        }>;
+                        completedAt: z.ZodString;
+                        resultExcerpt: z.ZodOptional<z.ZodObject<{
+                            source: z.ZodEnum<{
+                                parsed_body: "parsed_body";
+                                normalized_output: "normalized_output";
+                            }>;
+                            text: z.ZodString;
+                            truncated: z.ZodBoolean;
+                            originalLength: z.ZodNumber;
+                            maxLength: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    code: z.ZodOptional<z.ZodObject<{
+                        reviewer: z.ZodEnum<{
+                            spec: "spec";
+                            code: "code";
+                        }>;
+                        agent: z.ZodEnum<{
+                            "vv-spec-reviewer": "vv-spec-reviewer";
+                            "vv-code-reviewer": "vv-code-reviewer";
+                        }>;
+                        status: z.ZodEnum<{
+                            FAIL: "FAIL";
+                            NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                            PASS: "PASS";
+                        }>;
+                        completedAt: z.ZodString;
+                        resultExcerpt: z.ZodOptional<z.ZodObject<{
+                            source: z.ZodEnum<{
+                                parsed_body: "parsed_body";
+                                normalized_output: "normalized_output";
+                            }>;
+                            text: z.ZodString;
+                            truncated: z.ZodBoolean;
+                            originalLength: z.ZodNumber;
+                            maxLength: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    completed: "completed";
+                }>;
+                createdAt: z.ZodString;
+                completedAt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            resultExcerpt: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    parsed_body: "parsed_body";
+                    normalized_output: "normalized_output";
+                }>;
+                text: z.ZodString;
+                truncated: z.ZodBoolean;
+                originalLength: z.ZodNumber;
+                maxLength: z.ZodNumber;
+            }, z.core.$strict>>;
+            completedReviewRoundCount: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            closedAt: z.ZodOptional<z.ZodString>;
+            delegated: z.ZodOptional<z.ZodObject<{
+                writeScope: z.ZodArray<z.ZodString>;
+                planRunId: z.ZodOptional<z.ZodString>;
+                planTaskId: z.ZodOptional<z.ZodString>;
+                attempts: z.ZodNumber;
+                inFlightAttempt: z.ZodBoolean;
+                decisions: z.ZodNumber;
+                accepted: z.ZodBoolean;
+                acceptedAttempt: z.ZodOptional<z.ZodNumber>;
+                reworkCount: z.ZodNumber;
+                attemptBudget: z.ZodNumber;
+                remainingAttempts: z.ZodNumber;
+                recoveryCount: z.ZodNumber;
+                autonomousGrantConsumed: z.ZodBoolean;
+                reportRejectionCount: z.ZodNumber;
+                nextAction: z.ZodEnum<{
+                    closed: "closed";
+                    launch_implementer: "launch_implementer";
+                    await_result: "await_result";
+                    decide: "decide";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    launch_blocked: "launch_blocked";
+                    close: "close";
+                }>;
+                latestAttempt: z.ZodOptional<z.ZodObject<{
+                    attempt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        completed: "completed";
+                        in_flight: "in_flight";
+                        failed: "failed";
+                        report_rejected: "report_rejected";
+                    }>;
+                    resultStatus: z.ZodOptional<z.ZodEnum<{
+                        DONE: "DONE";
+                        DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        BLOCKED: "BLOCKED";
+                    }>>;
+                    completedAt: z.ZodOptional<z.ZodString>;
+                    reportRejected: z.ZodBoolean;
+                }, z.core.$strict>>;
+                guidance: z.ZodOptional<z.ZodObject<{
+                    nextAction: z.ZodEnum<{
+                        closed: "closed";
+                        launch_implementer: "launch_implementer";
+                        await_result: "await_result";
+                        decide: "decide";
+                        recover: "recover";
+                        recover_with_user_authorization: "recover_with_user_authorization";
+                        launch_blocked: "launch_blocked";
+                        close: "close";
+                    }>;
+                    launchEligible: z.ZodBoolean;
+                    blockers: z.ZodArray<z.ZodString>;
+                    prerequisites: z.ZodArray<z.ZodString>;
+                    requiresConcernsDisposition: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            ok: z.ZodLiteral<false>;
+            errorCode: z.ZodString;
+            category: z.ZodOptional<z.ZodEnum<{
+                input: "input";
+                host_context: "host_context";
+                state: "state";
+                authorization: "authorization";
+                persistence: "persistence";
+                internal: "internal";
+            }>>;
+            message: z.ZodString;
+            existingWorkItemId: z.ZodOptional<z.ZodString>;
+            state: z.ZodOptional<z.ZodString>;
+            prerequisite: z.ZodOptional<z.ZodString>;
+            nextAction: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_open">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"register">;
+        runId: z.ZodString;
+        reused: z.ZodBoolean;
+        execution: z.ZodObject<{
+            runId: z.ZodString;
+            sessionId: z.ZodString;
+            executionKey: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                "native-package": "native-package";
+                "provided-plan": "provided-plan";
+                "conversation-scoped": "conversation-scoped";
+            }>;
+            goal: z.ZodString;
+            state: z.ZodEnum<{
+                preparing: "preparing";
+                active: "active";
+                sealed: "sealed";
+            }>;
+            revision: z.ZodNumber;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                workItemId: z.ZodString;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    launched: "launched";
+                    accepted: "accepted";
+                    superseded: "superseded";
+                }>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                dependsOn: z.ZodArray<z.ZodString>;
+                blockedBy: z.ZodArray<z.ZodString>;
+                latestAttempt: z.ZodOptional<z.ZodObject<{
+                    attempt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        completed: "completed";
+                        in_flight: "in_flight";
+                        failed: "failed";
+                        report_rejected: "report_rejected";
+                    }>;
+                    resultStatus: z.ZodOptional<z.ZodEnum<{
+                        DONE: "DONE";
+                        DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        BLOCKED: "BLOCKED";
+                    }>>;
+                    completedAt: z.ZodOptional<z.ZodString>;
+                    reportRejected: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkpointId: z.ZodString;
+                kind: z.ZodEnum<{
+                    milestone: "milestone";
+                    final: "final";
+                }>;
+                covers: z.ZodArray<z.ZodString>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                status: z.ZodOptional<z.ZodString>;
+                reviewWorkItemId: z.ZodOptional<z.ZodString>;
+                generation: z.ZodOptional<z.ZodNumber>;
+                recoveryCount: z.ZodOptional<z.ZodNumber>;
+                attempts: z.ZodOptional<z.ZodNumber>;
+                generationBudget: z.ZodOptional<z.ZodNumber>;
+                remainingGenerations: z.ZodOptional<z.ZodNumber>;
+                lastOutcome: z.ZodOptional<z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                    incomplete: "incomplete";
+                }>>;
+                nextAction: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    blocked: "blocked";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    passed: "passed";
+                    collect_and_verify: "collect_and_verify";
+                    start_next_generation: "start_next_generation";
+                }>>;
+                prerequisite: z.ZodOptional<z.ZodString>;
+                currentReview: z.ZodOptional<z.ZodObject<{
+                    reviewWorkItemId: z.ZodString;
+                    generation: z.ZodNumber;
+                    coveredAttemptIds: z.ZodArray<z.ZodString>;
+                    recordedReviewers: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    generation: z.ZodNumber;
+                    outcome: z.ZodEnum<{
+                        failed: "failed";
+                        passed: "passed";
+                        stale: "stale";
+                        stopped: "stopped";
+                    }>;
+                    completedAt: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            authority: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                authorityId: z.ZodString;
+                availableUnits: z.ZodNumber;
+                revoked: z.ZodBoolean;
+                stages: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                reservedStops: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                prerequisites: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_open">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"amend">;
+        runId: z.ZodString;
+        revision: z.ZodNumber;
+        execution: z.ZodObject<{
+            runId: z.ZodString;
+            sessionId: z.ZodString;
+            executionKey: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                "native-package": "native-package";
+                "provided-plan": "provided-plan";
+                "conversation-scoped": "conversation-scoped";
+            }>;
+            goal: z.ZodString;
+            state: z.ZodEnum<{
+                preparing: "preparing";
+                active: "active";
+                sealed: "sealed";
+            }>;
+            revision: z.ZodNumber;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                workItemId: z.ZodString;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    launched: "launched";
+                    accepted: "accepted";
+                    superseded: "superseded";
+                }>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                dependsOn: z.ZodArray<z.ZodString>;
+                blockedBy: z.ZodArray<z.ZodString>;
+                latestAttempt: z.ZodOptional<z.ZodObject<{
+                    attempt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        completed: "completed";
+                        in_flight: "in_flight";
+                        failed: "failed";
+                        report_rejected: "report_rejected";
+                    }>;
+                    resultStatus: z.ZodOptional<z.ZodEnum<{
+                        DONE: "DONE";
+                        DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        BLOCKED: "BLOCKED";
+                    }>>;
+                    completedAt: z.ZodOptional<z.ZodString>;
+                    reportRejected: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkpointId: z.ZodString;
+                kind: z.ZodEnum<{
+                    milestone: "milestone";
+                    final: "final";
+                }>;
+                covers: z.ZodArray<z.ZodString>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                status: z.ZodOptional<z.ZodString>;
+                reviewWorkItemId: z.ZodOptional<z.ZodString>;
+                generation: z.ZodOptional<z.ZodNumber>;
+                recoveryCount: z.ZodOptional<z.ZodNumber>;
+                attempts: z.ZodOptional<z.ZodNumber>;
+                generationBudget: z.ZodOptional<z.ZodNumber>;
+                remainingGenerations: z.ZodOptional<z.ZodNumber>;
+                lastOutcome: z.ZodOptional<z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                    incomplete: "incomplete";
+                }>>;
+                nextAction: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    blocked: "blocked";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    passed: "passed";
+                    collect_and_verify: "collect_and_verify";
+                    start_next_generation: "start_next_generation";
+                }>>;
+                prerequisite: z.ZodOptional<z.ZodString>;
+                currentReview: z.ZodOptional<z.ZodObject<{
+                    reviewWorkItemId: z.ZodString;
+                    generation: z.ZodNumber;
+                    coveredAttemptIds: z.ZodArray<z.ZodString>;
+                    recordedReviewers: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    generation: z.ZodNumber;
+                    outcome: z.ZodEnum<{
+                        failed: "failed";
+                        passed: "passed";
+                        stale: "stale";
+                        stopped: "stopped";
+                    }>;
+                    completedAt: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            authority: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                authorityId: z.ZodString;
+                availableUnits: z.ZodNumber;
+                revoked: z.ZodBoolean;
+                stages: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                reservedStops: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                prerequisites: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ok: z.ZodLiteral<false>;
+        errorCode: z.ZodString;
+        category: z.ZodEnum<{
+            input: "input";
+            host_context: "host_context";
+            state: "state";
+            authorization: "authorization";
+            persistence: "persistence";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                unrecognized_keys: "unrecognized_keys";
+                invalid_value: "invalid_value";
+                invalid_type: "invalid_type";
+                invalid_format: "invalid_format";
+                too_small: "too_small";
+                too_big: "too_big";
+                missing_value: "missing_value";
+                invalid_union: "invalid_union";
+                custom: "custom";
+            }>;
+            path: z.ZodString;
+            message: z.ZodString;
+            expected: z.ZodOptional<z.ZodString>;
+            received: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        state: z.ZodOptional<z.ZodString>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        attemptStatus: z.ZodOptional<z.ZodString>;
+        resultStatus: z.ZodOptional<z.ZodString>;
+        attemptBudget: z.ZodOptional<z.ZodNumber>;
+        remainingAttempts: z.ZodOptional<z.ZodNumber>;
+        recoveryCount: z.ZodOptional<z.ZodNumber>;
+        pendingReviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prerequisite: z.ZodOptional<z.ZodString>;
+        nextAction: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            committed: "committed";
+            not_applied: "not_applied";
+            rolled_back: "rolled_back";
+        }>>;
+        applied: z.ZodOptional<z.ZodBoolean>;
+        retrySafe: z.ZodOptional<z.ZodBoolean>;
+        existingWorkItemId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodLiteral<string>;
+    }, z.core.$strict>]>;
+    readonly work_item_list: z.ZodUnion<readonly [z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_list">;
+        sessionId: z.ZodString;
+        includeClosed: z.ZodBoolean;
+        items: z.ZodArray<z.ZodObject<{
+            workItemId: z.ZodString;
+            header: z.ZodString;
+            key: z.ZodString;
+            title: z.ZodString;
+            mode: z.ZodEnum<{
+                delegated: "delegated";
+                implementation: "implementation";
+                review_only: "review_only";
+            }>;
+            requiredReviewers: z.ZodArray<z.ZodEnum<{
+                spec: "spec";
+                code: "code";
+            }>>;
+            state: z.ZodEnum<{
+                open: "open";
+                awaiting_implementer: "awaiting_implementer";
+                awaiting_reviews: "awaiting_reviews";
+                awaiting_acceptance: "awaiting_acceptance";
+                needs_context: "needs_context";
+                blocked: "blocked";
+                ready_to_close: "ready_to_close";
+                closed: "closed";
+            }>;
+            specReviewCount: z.ZodNumber;
+            codeReviewCount: z.ZodNumber;
+            reviewRound: z.ZodNumber;
+            currentRound: z.ZodOptional<z.ZodObject<{
+                round: z.ZodNumber;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                pendingReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                inFlightReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                completedReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                results: z.ZodObject<{
+                    spec: z.ZodOptional<z.ZodObject<{
+                        reviewer: z.ZodEnum<{
+                            spec: "spec";
+                            code: "code";
+                        }>;
+                        agent: z.ZodEnum<{
+                            "vv-spec-reviewer": "vv-spec-reviewer";
+                            "vv-code-reviewer": "vv-code-reviewer";
+                        }>;
+                        status: z.ZodEnum<{
+                            FAIL: "FAIL";
+                            NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                            PASS: "PASS";
+                        }>;
+                        completedAt: z.ZodString;
+                        resultExcerpt: z.ZodOptional<z.ZodObject<{
+                            source: z.ZodEnum<{
+                                parsed_body: "parsed_body";
+                                normalized_output: "normalized_output";
+                            }>;
+                            text: z.ZodString;
+                            truncated: z.ZodBoolean;
+                            originalLength: z.ZodNumber;
+                            maxLength: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                    code: z.ZodOptional<z.ZodObject<{
+                        reviewer: z.ZodEnum<{
+                            spec: "spec";
+                            code: "code";
+                        }>;
+                        agent: z.ZodEnum<{
+                            "vv-spec-reviewer": "vv-spec-reviewer";
+                            "vv-code-reviewer": "vv-code-reviewer";
+                        }>;
+                        status: z.ZodEnum<{
+                            FAIL: "FAIL";
+                            NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                            PASS: "PASS";
+                        }>;
+                        completedAt: z.ZodString;
+                        resultExcerpt: z.ZodOptional<z.ZodObject<{
+                            source: z.ZodEnum<{
+                                parsed_body: "parsed_body";
+                                normalized_output: "normalized_output";
+                            }>;
+                            text: z.ZodString;
+                            truncated: z.ZodBoolean;
+                            originalLength: z.ZodNumber;
+                            maxLength: z.ZodNumber;
+                        }, z.core.$strict>>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>;
+                status: z.ZodEnum<{
+                    active: "active";
+                    completed: "completed";
+                }>;
+                createdAt: z.ZodString;
+                completedAt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            resultExcerpt: z.ZodOptional<z.ZodObject<{
+                source: z.ZodEnum<{
+                    parsed_body: "parsed_body";
+                    normalized_output: "normalized_output";
+                }>;
+                text: z.ZodString;
+                truncated: z.ZodBoolean;
+                originalLength: z.ZodNumber;
+                maxLength: z.ZodNumber;
+            }, z.core.$strict>>;
+            completedReviewRoundCount: z.ZodNumber;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            closedAt: z.ZodOptional<z.ZodString>;
+            delegated: z.ZodOptional<z.ZodObject<{
+                writeScope: z.ZodArray<z.ZodString>;
+                planRunId: z.ZodOptional<z.ZodString>;
+                planTaskId: z.ZodOptional<z.ZodString>;
+                attempts: z.ZodNumber;
+                inFlightAttempt: z.ZodBoolean;
+                decisions: z.ZodNumber;
+                accepted: z.ZodBoolean;
+                acceptedAttempt: z.ZodOptional<z.ZodNumber>;
+                reworkCount: z.ZodNumber;
+                attemptBudget: z.ZodNumber;
+                remainingAttempts: z.ZodNumber;
+                recoveryCount: z.ZodNumber;
+                autonomousGrantConsumed: z.ZodBoolean;
+                reportRejectionCount: z.ZodNumber;
+                nextAction: z.ZodEnum<{
+                    closed: "closed";
+                    launch_implementer: "launch_implementer";
+                    await_result: "await_result";
+                    decide: "decide";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    launch_blocked: "launch_blocked";
+                    close: "close";
+                }>;
+                latestAttempt: z.ZodOptional<z.ZodObject<{
+                    attempt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        completed: "completed";
+                        in_flight: "in_flight";
+                        failed: "failed";
+                        report_rejected: "report_rejected";
+                    }>;
+                    resultStatus: z.ZodOptional<z.ZodEnum<{
+                        DONE: "DONE";
+                        DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        BLOCKED: "BLOCKED";
+                    }>>;
+                    completedAt: z.ZodOptional<z.ZodString>;
+                    reportRejected: z.ZodBoolean;
+                }, z.core.$strict>>;
+                guidance: z.ZodOptional<z.ZodObject<{
+                    nextAction: z.ZodEnum<{
+                        closed: "closed";
+                        launch_implementer: "launch_implementer";
+                        await_result: "await_result";
+                        decide: "decide";
+                        recover: "recover";
+                        recover_with_user_authorization: "recover_with_user_authorization";
+                        launch_blocked: "launch_blocked";
+                        close: "close";
+                    }>;
+                    launchEligible: z.ZodBoolean;
+                    blockers: z.ZodArray<z.ZodString>;
+                    prerequisites: z.ZodArray<z.ZodString>;
+                    requiresConcernsDisposition: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        planRuns: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            sessionId: z.ZodString;
+            planPath: z.ZodString;
+            specPath: z.ZodString;
+            workspaceRoot: z.ZodString;
+            status: z.ZodEnum<{
+                active: "active";
+                sealed: "sealed";
+            }>;
+            registeredAt: z.ZodString;
+            sealedAt: z.ZodOptional<z.ZodString>;
+            finalCheckpointId: z.ZodOptional<z.ZodString>;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                workItemId: z.ZodString;
+            }, z.core.$strict>>;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkpointId: z.ZodString;
+                kind: z.ZodEnum<{
+                    milestone: "milestone";
+                    final: "final";
+                }>;
+                afterWave: z.ZodString;
+                covers: z.ZodArray<z.ZodString>;
+                scope: z.ZodArray<z.ZodString>;
+                reviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    failed: "failed";
+                    in_review: "in_review";
+                    passed: "passed";
+                }>;
+                attempts: z.ZodNumber;
+                lastOutcome: z.ZodOptional<z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                    incomplete: "incomplete";
+                }>>;
+                generationBudget: z.ZodNumber;
+                remainingGenerations: z.ZodNumber;
+                recoveryCount: z.ZodNumber;
+                nextAction: z.ZodEnum<{
+                    start: "start";
+                    blocked: "blocked";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    passed: "passed";
+                    collect_and_verify: "collect_and_verify";
+                    start_next_generation: "start_next_generation";
+                }>;
+                prerequisite: z.ZodOptional<z.ZodString>;
+                currentReview: z.ZodOptional<z.ZodObject<{
+                    reviewWorkItemId: z.ZodString;
+                    generation: z.ZodNumber;
+                    coveredAttemptIds: z.ZodArray<z.ZodString>;
+                    recordedReviewers: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                history: z.ZodArray<z.ZodObject<{
+                    generation: z.ZodNumber;
+                    outcome: z.ZodEnum<{
+                        failed: "failed";
+                        passed: "passed";
+                        stale: "stale";
+                        stopped: "stopped";
+                    }>;
+                    fingerprint: z.ZodString;
+                    completedAt: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+        executions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            sessionId: z.ZodString;
+            executionKey: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                "native-package": "native-package";
+                "provided-plan": "provided-plan";
+                "conversation-scoped": "conversation-scoped";
+            }>;
+            goal: z.ZodString;
+            state: z.ZodEnum<{
+                preparing: "preparing";
+                active: "active";
+                sealed: "sealed";
+            }>;
+            revision: z.ZodNumber;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                workItemId: z.ZodString;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    launched: "launched";
+                    accepted: "accepted";
+                    superseded: "superseded";
+                }>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                dependsOn: z.ZodArray<z.ZodString>;
+                blockedBy: z.ZodArray<z.ZodString>;
+                latestAttempt: z.ZodOptional<z.ZodObject<{
+                    attempt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        completed: "completed";
+                        in_flight: "in_flight";
+                        failed: "failed";
+                        report_rejected: "report_rejected";
+                    }>;
+                    resultStatus: z.ZodOptional<z.ZodEnum<{
+                        DONE: "DONE";
+                        DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        BLOCKED: "BLOCKED";
+                    }>>;
+                    completedAt: z.ZodOptional<z.ZodString>;
+                    reportRejected: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkpointId: z.ZodString;
+                kind: z.ZodEnum<{
+                    milestone: "milestone";
+                    final: "final";
+                }>;
+                covers: z.ZodArray<z.ZodString>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                status: z.ZodOptional<z.ZodString>;
+                reviewWorkItemId: z.ZodOptional<z.ZodString>;
+                generation: z.ZodOptional<z.ZodNumber>;
+                recoveryCount: z.ZodOptional<z.ZodNumber>;
+                attempts: z.ZodOptional<z.ZodNumber>;
+                generationBudget: z.ZodOptional<z.ZodNumber>;
+                remainingGenerations: z.ZodOptional<z.ZodNumber>;
+                lastOutcome: z.ZodOptional<z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                    incomplete: "incomplete";
+                }>>;
+                nextAction: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    blocked: "blocked";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    passed: "passed";
+                    collect_and_verify: "collect_and_verify";
+                    start_next_generation: "start_next_generation";
+                }>>;
+                prerequisite: z.ZodOptional<z.ZodString>;
+                currentReview: z.ZodOptional<z.ZodObject<{
+                    reviewWorkItemId: z.ZodString;
+                    generation: z.ZodNumber;
+                    coveredAttemptIds: z.ZodArray<z.ZodString>;
+                    recordedReviewers: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    generation: z.ZodNumber;
+                    outcome: z.ZodEnum<{
+                        failed: "failed";
+                        passed: "passed";
+                        stale: "stale";
+                        stopped: "stopped";
+                    }>;
+                    completedAt: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            authority: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                authorityId: z.ZodString;
+                availableUnits: z.ZodNumber;
+                revoked: z.ZodBoolean;
+                stages: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                reservedStops: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                prerequisites: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>>;
+        contract: z.ZodObject<{
+            packageName: z.ZodString;
+            packageVersion: z.ZodString;
+            toolContractRevision: z.ZodString;
+            referencePath: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ok: z.ZodLiteral<false>;
+        errorCode: z.ZodString;
+        category: z.ZodEnum<{
+            input: "input";
+            host_context: "host_context";
+            state: "state";
+            authorization: "authorization";
+            persistence: "persistence";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                unrecognized_keys: "unrecognized_keys";
+                invalid_value: "invalid_value";
+                invalid_type: "invalid_type";
+                invalid_format: "invalid_format";
+                too_small: "too_small";
+                too_big: "too_big";
+                missing_value: "missing_value";
+                invalid_union: "invalid_union";
+                custom: "custom";
+            }>;
+            path: z.ZodString;
+            message: z.ZodString;
+            expected: z.ZodOptional<z.ZodString>;
+            received: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        state: z.ZodOptional<z.ZodString>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        attemptStatus: z.ZodOptional<z.ZodString>;
+        resultStatus: z.ZodOptional<z.ZodString>;
+        attemptBudget: z.ZodOptional<z.ZodNumber>;
+        remainingAttempts: z.ZodOptional<z.ZodNumber>;
+        recoveryCount: z.ZodOptional<z.ZodNumber>;
+        pendingReviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prerequisite: z.ZodOptional<z.ZodString>;
+        nextAction: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            committed: "committed";
+            not_applied: "not_applied";
+            rolled_back: "rolled_back";
+        }>>;
+        applied: z.ZodOptional<z.ZodBoolean>;
+        retrySafe: z.ZodOptional<z.ZodBoolean>;
+        existingWorkItemId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodLiteral<string>;
+    }, z.core.$strict>]>;
+    readonly work_item_close: z.ZodUnion<readonly [z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_close">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        workItemId: z.ZodString;
+        header: z.ZodString;
+        state: z.ZodEnum<{
+            open: "open";
+            awaiting_implementer: "awaiting_implementer";
+            awaiting_reviews: "awaiting_reviews";
+            awaiting_acceptance: "awaiting_acceptance";
+            needs_context: "needs_context";
+            blocked: "blocked";
+            ready_to_close: "ready_to_close";
+            closed: "closed";
+        }>;
+        closedAt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ok: z.ZodLiteral<false>;
+        errorCode: z.ZodString;
+        category: z.ZodEnum<{
+            input: "input";
+            host_context: "host_context";
+            state: "state";
+            authorization: "authorization";
+            persistence: "persistence";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                unrecognized_keys: "unrecognized_keys";
+                invalid_value: "invalid_value";
+                invalid_type: "invalid_type";
+                invalid_format: "invalid_format";
+                too_small: "too_small";
+                too_big: "too_big";
+                missing_value: "missing_value";
+                invalid_union: "invalid_union";
+                custom: "custom";
+            }>;
+            path: z.ZodString;
+            message: z.ZodString;
+            expected: z.ZodOptional<z.ZodString>;
+            received: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        state: z.ZodOptional<z.ZodString>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        attemptStatus: z.ZodOptional<z.ZodString>;
+        resultStatus: z.ZodOptional<z.ZodString>;
+        attemptBudget: z.ZodOptional<z.ZodNumber>;
+        remainingAttempts: z.ZodOptional<z.ZodNumber>;
+        recoveryCount: z.ZodOptional<z.ZodNumber>;
+        pendingReviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prerequisite: z.ZodOptional<z.ZodString>;
+        nextAction: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            committed: "committed";
+            not_applied: "not_applied";
+            rolled_back: "rolled_back";
+        }>>;
+        applied: z.ZodOptional<z.ZodBoolean>;
+        retrySafe: z.ZodOptional<z.ZodBoolean>;
+        existingWorkItemId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodLiteral<string>;
+    }, z.core.$strict>]>;
+    readonly work_item_decide: z.ZodUnion<readonly [z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_decide">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"rework">;
+        workItemId: z.ZodString;
+        reworkId: z.ZodString;
+        grantedAttempts: z.ZodNumber;
+        state: z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            awaiting_implementer: "awaiting_implementer";
+            awaiting_reviews: "awaiting_reviews";
+            awaiting_acceptance: "awaiting_acceptance";
+            needs_context: "needs_context";
+            blocked: "blocked";
+            ready_to_close: "ready_to_close";
+            closed: "closed";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_decide">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"recover">;
+        workItemId: z.ZodString;
+        recoveryId: z.ZodString;
+        kind: z.ZodEnum<{
+            resume: "resume";
+            autonomous_grant: "autonomous_grant";
+            user_grant: "user_grant";
+            advance_grant: "advance_grant";
+        }>;
+        attemptBudget: z.ZodNumber;
+        remainingAttempts: z.ZodNumber;
+        state: z.ZodEnum<{
+            open: "open";
+            awaiting_implementer: "awaiting_implementer";
+            awaiting_reviews: "awaiting_reviews";
+            awaiting_acceptance: "awaiting_acceptance";
+            needs_context: "needs_context";
+            blocked: "blocked";
+            ready_to_close: "ready_to_close";
+            closed: "closed";
+        }>;
+        nextAction: z.ZodEnum<{
+            closed: "closed";
+            launch_implementer: "launch_implementer";
+            await_result: "await_result";
+            decide: "decide";
+            recover: "recover";
+            recover_with_user_authorization: "recover_with_user_authorization";
+            launch_blocked: "launch_blocked";
+            close: "close";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_item_decide">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodEnum<{
+            accept: "accept";
+            request_changes: "request_changes";
+        }>;
+        workItemId: z.ZodString;
+        attempt: z.ZodNumber;
+        decisionId: z.ZodString;
+        state: z.ZodEnum<{
+            open: "open";
+            awaiting_implementer: "awaiting_implementer";
+            awaiting_reviews: "awaiting_reviews";
+            awaiting_acceptance: "awaiting_acceptance";
+            needs_context: "needs_context";
+            blocked: "blocked";
+            ready_to_close: "ready_to_close";
+            closed: "closed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ok: z.ZodLiteral<false>;
+        errorCode: z.ZodString;
+        category: z.ZodEnum<{
+            input: "input";
+            host_context: "host_context";
+            state: "state";
+            authorization: "authorization";
+            persistence: "persistence";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                unrecognized_keys: "unrecognized_keys";
+                invalid_value: "invalid_value";
+                invalid_type: "invalid_type";
+                invalid_format: "invalid_format";
+                too_small: "too_small";
+                too_big: "too_big";
+                missing_value: "missing_value";
+                invalid_union: "invalid_union";
+                custom: "custom";
+            }>;
+            path: z.ZodString;
+            message: z.ZodString;
+            expected: z.ZodOptional<z.ZodString>;
+            received: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        state: z.ZodOptional<z.ZodString>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        attemptStatus: z.ZodOptional<z.ZodString>;
+        resultStatus: z.ZodOptional<z.ZodString>;
+        attemptBudget: z.ZodOptional<z.ZodNumber>;
+        remainingAttempts: z.ZodOptional<z.ZodNumber>;
+        recoveryCount: z.ZodOptional<z.ZodNumber>;
+        pendingReviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prerequisite: z.ZodOptional<z.ZodString>;
+        nextAction: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            committed: "committed";
+            not_applied: "not_applied";
+            rolled_back: "rolled_back";
+        }>>;
+        applied: z.ZodOptional<z.ZodBoolean>;
+        retrySafe: z.ZodOptional<z.ZodBoolean>;
+        existingWorkItemId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodLiteral<string>;
+    }, z.core.$strict>]>;
+    readonly work_checkpoint: z.ZodUnion<readonly [z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"register">;
+        runId: z.ZodString;
+        reused: z.ZodBoolean;
+        tasks: z.ZodNumber;
+        checkpoints: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"start">;
+        runId: z.ZodString;
+        checkpointId: z.ZodString;
+        generation: z.ZodOptional<z.ZodNumber>;
+        reviewWorkItemId: z.ZodString;
+        header: z.ZodString;
+        reviewersToLaunch: z.ZodArray<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        coveredAttemptIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"verify">;
+        runId: z.ZodString;
+        checkpointId: z.ZodString;
+        outcome: z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            stale: "stale";
+            stopped: "stopped";
+            incomplete: "incomplete";
+            "already-passed": "already-passed";
+        }>;
+        snapshotCurrent: z.ZodBoolean;
+        sealedRun: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodEnum<{
+            verify: "verify";
+            review: "review";
+            bind: "bind";
+        }>;
+        runId: z.ZodString;
+        checkpointId: z.ZodString;
+        reviewer: z.ZodOptional<z.ZodEnum<{
+            spec: "spec";
+            code: "code";
+        }>>;
+        outcome: z.ZodEnum<{
+            in_progress: "in_progress";
+            failed: "failed";
+            passed: "passed";
+            stopped: "stopped";
+        }>;
+        checkpointStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            in_review: "in_review";
+            passed: "passed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"recover">;
+        runId: z.ZodString;
+        checkpointId: z.ZodString;
+        recoveryId: z.ZodString;
+        kind: z.ZodEnum<{
+            resume: "resume";
+            autonomous_grant: "autonomous_grant";
+            user_grant: "user_grant";
+            advance_grant: "advance_grant";
+        }>;
+        checkpointStatus: z.ZodEnum<{
+            pending: "pending";
+            failed: "failed";
+            in_review: "in_review";
+            passed: "passed";
+        }>;
+        generationBudget: z.ZodOptional<z.ZodNumber>;
+        settledStoppedGeneration: z.ZodOptional<z.ZodNumber>;
+        lastOutcome: z.ZodOptional<z.ZodEnum<{
+            failed: "failed";
+            passed: "passed";
+            stale: "stale";
+            stopped: "stopped";
+            incomplete: "incomplete";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"amend">;
+        revision: z.ZodNumber;
+        execution: z.ZodObject<{
+            runId: z.ZodString;
+            sessionId: z.ZodString;
+            executionKey: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                "native-package": "native-package";
+                "provided-plan": "provided-plan";
+                "conversation-scoped": "conversation-scoped";
+            }>;
+            goal: z.ZodString;
+            state: z.ZodEnum<{
+                preparing: "preparing";
+                active: "active";
+                sealed: "sealed";
+            }>;
+            revision: z.ZodNumber;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                workItemId: z.ZodString;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    launched: "launched";
+                    accepted: "accepted";
+                    superseded: "superseded";
+                }>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                dependsOn: z.ZodArray<z.ZodString>;
+                blockedBy: z.ZodArray<z.ZodString>;
+                latestAttempt: z.ZodOptional<z.ZodObject<{
+                    attempt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        completed: "completed";
+                        in_flight: "in_flight";
+                        failed: "failed";
+                        report_rejected: "report_rejected";
+                    }>;
+                    resultStatus: z.ZodOptional<z.ZodEnum<{
+                        DONE: "DONE";
+                        DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        BLOCKED: "BLOCKED";
+                    }>>;
+                    completedAt: z.ZodOptional<z.ZodString>;
+                    reportRejected: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkpointId: z.ZodString;
+                kind: z.ZodEnum<{
+                    milestone: "milestone";
+                    final: "final";
+                }>;
+                covers: z.ZodArray<z.ZodString>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                status: z.ZodOptional<z.ZodString>;
+                reviewWorkItemId: z.ZodOptional<z.ZodString>;
+                generation: z.ZodOptional<z.ZodNumber>;
+                recoveryCount: z.ZodOptional<z.ZodNumber>;
+                attempts: z.ZodOptional<z.ZodNumber>;
+                generationBudget: z.ZodOptional<z.ZodNumber>;
+                remainingGenerations: z.ZodOptional<z.ZodNumber>;
+                lastOutcome: z.ZodOptional<z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                    incomplete: "incomplete";
+                }>>;
+                nextAction: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    blocked: "blocked";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    passed: "passed";
+                    collect_and_verify: "collect_and_verify";
+                    start_next_generation: "start_next_generation";
+                }>>;
+                prerequisite: z.ZodOptional<z.ZodString>;
+                currentReview: z.ZodOptional<z.ZodObject<{
+                    reviewWorkItemId: z.ZodString;
+                    generation: z.ZodNumber;
+                    coveredAttemptIds: z.ZodArray<z.ZodString>;
+                    recordedReviewers: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    generation: z.ZodNumber;
+                    outcome: z.ZodEnum<{
+                        failed: "failed";
+                        passed: "passed";
+                        stale: "stale";
+                        stopped: "stopped";
+                    }>;
+                    completedAt: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            authority: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                authorityId: z.ZodString;
+                availableUnits: z.ZodNumber;
+                revoked: z.ZodBoolean;
+                stages: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                reservedStops: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                prerequisites: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"complete">;
+        reviewStatus: z.ZodEnum<{
+            controller_accepted: "controller_accepted";
+            independently_reviewed: "independently_reviewed";
+        }>;
+        execution: z.ZodObject<{
+            runId: z.ZodString;
+            sessionId: z.ZodString;
+            executionKey: z.ZodString;
+            sourceKind: z.ZodEnum<{
+                "native-package": "native-package";
+                "provided-plan": "provided-plan";
+                "conversation-scoped": "conversation-scoped";
+            }>;
+            goal: z.ZodString;
+            state: z.ZodEnum<{
+                preparing: "preparing";
+                active: "active";
+                sealed: "sealed";
+            }>;
+            revision: z.ZodNumber;
+            tasks: z.ZodArray<z.ZodObject<{
+                taskId: z.ZodString;
+                workItemId: z.ZodString;
+                status: z.ZodEnum<{
+                    pending: "pending";
+                    launched: "launched";
+                    accepted: "accepted";
+                    superseded: "superseded";
+                }>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                dependsOn: z.ZodArray<z.ZodString>;
+                blockedBy: z.ZodArray<z.ZodString>;
+                latestAttempt: z.ZodOptional<z.ZodObject<{
+                    attempt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        completed: "completed";
+                        in_flight: "in_flight";
+                        failed: "failed";
+                        report_rejected: "report_rejected";
+                    }>;
+                    resultStatus: z.ZodOptional<z.ZodEnum<{
+                        DONE: "DONE";
+                        DONE_WITH_CONCERNS: "DONE_WITH_CONCERNS";
+                        NEEDS_CONTEXT: "NEEDS_CONTEXT";
+                        BLOCKED: "BLOCKED";
+                    }>>;
+                    completedAt: z.ZodOptional<z.ZodString>;
+                    reportRejected: z.ZodBoolean;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            checkpoints: z.ZodArray<z.ZodObject<{
+                checkpointId: z.ZodString;
+                kind: z.ZodEnum<{
+                    milestone: "milestone";
+                    final: "final";
+                }>;
+                covers: z.ZodArray<z.ZodString>;
+                requiredReviewers: z.ZodArray<z.ZodEnum<{
+                    spec: "spec";
+                    code: "code";
+                }>>;
+                status: z.ZodOptional<z.ZodString>;
+                reviewWorkItemId: z.ZodOptional<z.ZodString>;
+                generation: z.ZodOptional<z.ZodNumber>;
+                recoveryCount: z.ZodOptional<z.ZodNumber>;
+                attempts: z.ZodOptional<z.ZodNumber>;
+                generationBudget: z.ZodOptional<z.ZodNumber>;
+                remainingGenerations: z.ZodOptional<z.ZodNumber>;
+                lastOutcome: z.ZodOptional<z.ZodEnum<{
+                    failed: "failed";
+                    passed: "passed";
+                    stale: "stale";
+                    stopped: "stopped";
+                    incomplete: "incomplete";
+                }>>;
+                nextAction: z.ZodOptional<z.ZodEnum<{
+                    start: "start";
+                    blocked: "blocked";
+                    recover: "recover";
+                    recover_with_user_authorization: "recover_with_user_authorization";
+                    passed: "passed";
+                    collect_and_verify: "collect_and_verify";
+                    start_next_generation: "start_next_generation";
+                }>>;
+                prerequisite: z.ZodOptional<z.ZodString>;
+                currentReview: z.ZodOptional<z.ZodObject<{
+                    reviewWorkItemId: z.ZodString;
+                    generation: z.ZodNumber;
+                    coveredAttemptIds: z.ZodArray<z.ZodString>;
+                    recordedReviewers: z.ZodArray<z.ZodString>;
+                }, z.core.$strict>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    generation: z.ZodNumber;
+                    outcome: z.ZodEnum<{
+                        failed: "failed";
+                        passed: "passed";
+                        stale: "stale";
+                        stopped: "stopped";
+                    }>;
+                    completedAt: z.ZodString;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>;
+            authority: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                authorityId: z.ZodString;
+                availableUnits: z.ZodNumber;
+                revoked: z.ZodBoolean;
+                stages: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                reservedStops: z.ZodArray<z.ZodEnum<{
+                    implementation: "implementation";
+                    specification: "specification";
+                    planning: "planning";
+                    verification: "verification";
+                }>>;
+                prerequisites: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"authorize">;
+        authorityId: z.ZodString;
+        reused: z.ZodOptional<z.ZodBoolean>;
+        units: z.ZodOptional<z.ZodNumber>;
+        extensions: z.ZodOptional<z.ZodNumber>;
+        availableUnits: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"record_approval">;
+        approvalId: z.ZodString;
+        stage: z.ZodEnum<{
+            implementation: "implementation";
+            specification: "specification";
+            planning: "planning";
+            verification: "verification";
+        }>;
+        provenance: z.ZodEnum<{
+            controller_delegated: "controller_delegated";
+            user_observed: "user_observed";
+            unspecified: "unspecified";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        tool: z.ZodLiteral<"work_checkpoint">;
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        ok: z.ZodLiteral<true>;
+        action: z.ZodLiteral<"revoke_authority">;
+        authorityId: z.ZodString;
+        kind: z.ZodEnum<{
+            narrow: "narrow";
+            revoke: "revoke";
+        }>;
+        availableUnits: z.ZodNumber;
+        stages: z.ZodArray<z.ZodEnum<{
+            implementation: "implementation";
+            specification: "specification";
+            planning: "planning";
+            verification: "verification";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        sessionId: z.ZodOptional<z.ZodString>;
+        ok: z.ZodLiteral<false>;
+        errorCode: z.ZodString;
+        category: z.ZodEnum<{
+            input: "input";
+            host_context: "host_context";
+            state: "state";
+            authorization: "authorization";
+            persistence: "persistence";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        issues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                unrecognized_keys: "unrecognized_keys";
+                invalid_value: "invalid_value";
+                invalid_type: "invalid_type";
+                invalid_format: "invalid_format";
+                too_small: "too_small";
+                too_big: "too_big";
+                missing_value: "missing_value";
+                invalid_union: "invalid_union";
+                custom: "custom";
+            }>;
+            path: z.ZodString;
+            message: z.ZodString;
+            expected: z.ZodOptional<z.ZodString>;
+            received: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+        state: z.ZodOptional<z.ZodString>;
+        attempt: z.ZodOptional<z.ZodNumber>;
+        attemptStatus: z.ZodOptional<z.ZodString>;
+        resultStatus: z.ZodOptional<z.ZodString>;
+        attemptBudget: z.ZodOptional<z.ZodNumber>;
+        remainingAttempts: z.ZodOptional<z.ZodNumber>;
+        recoveryCount: z.ZodOptional<z.ZodNumber>;
+        pendingReviewers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        prerequisite: z.ZodOptional<z.ZodString>;
+        nextAction: z.ZodOptional<z.ZodString>;
+        outcome: z.ZodOptional<z.ZodEnum<{
+            unknown: "unknown";
+            committed: "committed";
+            not_applied: "not_applied";
+            rolled_back: "rolled_back";
+        }>>;
+        applied: z.ZodOptional<z.ZodBoolean>;
+        retrySafe: z.ZodOptional<z.ZodBoolean>;
+        existingWorkItemId: z.ZodOptional<z.ZodString>;
+        runId: z.ZodOptional<z.ZodString>;
+        tool: z.ZodLiteral<string>;
+    }, z.core.$strict>]>;
+};
+export type WorkflowToolResultToolId = keyof typeof workflowToolResultSchemas;
+/** Schema-derived per-tool result DTO map for future inspection/catalog consumers. */
+export type WorkflowToolResultMap = {
+    [K in WorkflowToolResultToolId]: z.infer<(typeof workflowToolResultSchemas)[K]>;
+};
+/** Bounded loaded-identity view returned by work_item_list.contract. */
+export type WorkflowContractIdentity = z.infer<typeof workflowContractIdentitySchema>;
+/** Read-only execution view shared by generic register/amend/complete and inspection. */
+export type WorkflowExecutionView = z.infer<typeof executionViewSchema>;
+/** Read-only native plan-run view kept alongside the unified execution view. */
+export type WorkflowDelegatedRunView = z.infer<typeof delegatedRunViewSchema>;
+/** Read-only work-item view, including delegated budget/guidance, returned by work_item_list.items. */
+export type WorkflowWorkItemView = z.infer<typeof workItemViewSchema>;
+/** Additive work_item_list inspection payload. */
+export type WorkflowInspectionView = z.infer<typeof workItemListViewSchema>;
+/** Closed result schema for one owned workflow tool id, preserving its inferred type. */
+export declare function workflowToolResultSchema<K extends WorkflowToolResultToolId>(toolId: K): (typeof workflowToolResultSchemas)[K];
+/**
+ * Producer/test validation of one owned workflow tool result against its
+ * closed schema. It does not normalize or repair failures first: a malformed
+ * producer representation fails rather than being made compliant. Producers
+ * apply `finalizeWorkflowResult` before this is used on their output.
+ * Never call this as a throw-after-side-effect execute wrapper.
+ */
+export declare function validateWorkflowToolResult(toolId: WorkflowToolResultToolId, value: unknown): {
+    ok: true;
+} | {
+    ok: false;
+    issues: readonly ContractIssue[];
+};
+/**
+ * Serialize a public workflow result. Producers finalize category/guidance
+ * before this point, so this is a pure presentation step (no silent repair). If
+ * serialization itself fails after execution, produce a bounded truthful
+ * internal error carrying the observed outcome instead of throwing raw or
+ * inviting an unqualified replay. An `unknown` outcome omits `applied`.
+ */
+export declare function serializeWorkflowResult(value: Record<string, unknown>, options?: {
+    outcome?: WorkflowMutationOutcome;
+}): string;
+export {};