@ai-dev-orchestrator/schemas 0.1.1

package/dist/runner/runner-system.d.ts

@@ -0,0 +1,1721 @@
+import { z } from 'zod/v4';
+import { type AgentStreamEventType } from '../shared/string-enums';
+export declare const agentSessionStateSchema: z.ZodEnum<{
+    running: "running";
+    awaiting_human: "awaiting_human";
+    paused: "paused";
+    reconnecting: "reconnecting";
+    completed: "completed";
+    failed: "failed";
+    aborted: "aborted";
+    orphaned: "orphaned";
+}>;
+export type AgentSessionState = z.infer<typeof agentSessionStateSchema>;
+export declare const agentSessionRefSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    stateId: z.ZodString;
+    role: z.ZodEnum<{
+        judge: "judge";
+        requirements_analyst: "requirements_analyst";
+        context_analyst: "context_analyst";
+        codebase_analyst: "codebase_analyst";
+        planner: "planner";
+        plan_reviewer: "plan_reviewer";
+        implementer: "implementer";
+        test_engineer: "test_engineer";
+        static_reviewer: "static_reviewer";
+        security_reviewer: "security_reviewer";
+        performance_reviewer: "performance_reviewer";
+        adversarial_reviewer: "adversarial_reviewer";
+        design_reviewer: "design_reviewer";
+        docs_reviewer: "docs_reviewer";
+        ux_reviewer: "ux_reviewer";
+        report_synthesizer: "report_synthesizer";
+        remediation_triage: "remediation_triage";
+        verifier: "verifier";
+        summary_writer: "summary_writer";
+        review_findings_writer: "review_findings_writer";
+        acceptance_validator: "acceptance_validator";
+        breakdown_analyst: "breakdown_analyst";
+        decomposer: "decomposer";
+        decomposition_reviewer: "decomposition_reviewer";
+        task_spec_writer: "task_spec_writer";
+    }>;
+    transport: z.ZodEnum<{
+        stdio: "stdio";
+        remote: "remote";
+    }>;
+}, z.core.$strip>;
+export type AgentSessionRef = z.infer<typeof agentSessionRefSchema>;
+export declare const permissionPayloadSchema: z.ZodObject<{
+    action: z.ZodString;
+    resource: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+    riskLevel: z.ZodOptional<z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>>;
+    externalRequestId: z.ZodOptional<z.ZodString>;
+    toolInput: z.ZodOptional<z.ZodString>;
+    granted: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+    timedOut: z.ZodOptional<z.ZodBoolean>;
+    aborted: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type PermissionPayload = z.infer<typeof permissionPayloadSchema>;
+export declare const clarificationPayloadSchema: z.ZodObject<{
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    answer: z.ZodOptional<z.ZodString>;
+}, z.core.$catchall<z.ZodUnknown>>;
+export type ClarificationPayload = z.infer<typeof clarificationPayloadSchema>;
+export declare const sessionPendingRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    requestId: z.ZodString;
+    kind: z.ZodLiteral<"permission">;
+    createdAt: z.ZodString;
+    payload: z.ZodObject<{
+        action: z.ZodString;
+        resource: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        riskLevel: z.ZodOptional<z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            low: "low";
+        }>>;
+        externalRequestId: z.ZodOptional<z.ZodString>;
+        toolInput: z.ZodOptional<z.ZodString>;
+        granted: z.ZodOptional<z.ZodBoolean>;
+        reason: z.ZodOptional<z.ZodString>;
+        timedOut: z.ZodOptional<z.ZodBoolean>;
+        aborted: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$strip>, z.ZodObject<{
+    requestId: z.ZodString;
+    kind: z.ZodLiteral<"clarification">;
+    createdAt: z.ZodString;
+    payload: z.ZodObject<{
+        question: z.ZodString;
+        context: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        answer: z.ZodOptional<z.ZodString>;
+    }, z.core.$catchall<z.ZodUnknown>>;
+}, z.core.$strip>], "kind">;
+export type SessionPendingRequest = z.infer<typeof sessionPendingRequestSchema>;
+export declare const stdioReconnectMetaSchema: z.ZodObject<{
+    type: z.ZodLiteral<"stdio">;
+    pid: z.ZodNumber;
+    socketPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type StdioReconnectMeta = z.infer<typeof stdioReconnectMetaSchema>;
+export declare const remoteReconnectMetaSchema: z.ZodObject<{
+    type: z.ZodLiteral<"remote">;
+    remoteSessionId: z.ZodString;
+    reconnectUrl: z.ZodString;
+    websocketUrl: z.ZodOptional<z.ZodString>;
+    leaseExpiresAt: z.ZodOptional<z.ZodString>;
+    heartbeatIntervalMs: z.ZodOptional<z.ZodNumber>;
+    authHeader: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RemoteReconnectMeta = z.infer<typeof remoteReconnectMetaSchema>;
+export declare const reconnectMetaSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"stdio">;
+    pid: z.ZodNumber;
+    socketPath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"remote">;
+    remoteSessionId: z.ZodString;
+    reconnectUrl: z.ZodString;
+    websocketUrl: z.ZodOptional<z.ZodString>;
+    leaseExpiresAt: z.ZodOptional<z.ZodString>;
+    heartbeatIntervalMs: z.ZodOptional<z.ZodNumber>;
+    authHeader: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type ReconnectMeta = z.infer<typeof reconnectMetaSchema>;
+export declare const agentSessionSnapshotSchema: z.ZodObject<{
+    ref: z.ZodObject<{
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        stateId: z.ZodString;
+        role: z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            remote: "remote";
+        }>;
+    }, z.core.$strip>;
+    state: z.ZodEnum<{
+        running: "running";
+        awaiting_human: "awaiting_human";
+        paused: "paused";
+        reconnecting: "reconnecting";
+        completed: "completed";
+        failed: "failed";
+        aborted: "aborted";
+        orphaned: "orphaned";
+    }>;
+    pendingRequests: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodLiteral<"permission">;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            action: z.ZodString;
+            resource: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            riskLevel: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+            externalRequestId: z.ZodOptional<z.ZodString>;
+            toolInput: z.ZodOptional<z.ZodString>;
+            granted: z.ZodOptional<z.ZodBoolean>;
+            reason: z.ZodOptional<z.ZodString>;
+            timedOut: z.ZodOptional<z.ZodBoolean>;
+            aborted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodLiteral<"clarification">;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            question: z.ZodString;
+            context: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            answer: z.ZodOptional<z.ZodString>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strip>], "kind">>>;
+    lastProtocolTimestamp: z.ZodString;
+    reconnect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"stdio">;
+        pid: z.ZodNumber;
+        socketPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"remote">;
+        remoteSessionId: z.ZodString;
+        reconnectUrl: z.ZodString;
+        websocketUrl: z.ZodOptional<z.ZodString>;
+        leaseExpiresAt: z.ZodOptional<z.ZodString>;
+        heartbeatIntervalMs: z.ZodOptional<z.ZodNumber>;
+        authHeader: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    workerId: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentSessionSnapshot = z.infer<typeof agentSessionSnapshotSchema>;
+export declare const agentSessionHandleSchema: z.ZodObject<{
+    ref: z.ZodObject<{
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        stateId: z.ZodString;
+        role: z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            remote: "remote";
+        }>;
+    }, z.core.$strip>;
+    state: z.ZodEnum<{
+        running: "running";
+        awaiting_human: "awaiting_human";
+        paused: "paused";
+        reconnecting: "reconnecting";
+        completed: "completed";
+        failed: "failed";
+        aborted: "aborted";
+        orphaned: "orphaned";
+    }>;
+    pendingRequests: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodLiteral<"permission">;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            action: z.ZodString;
+            resource: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            riskLevel: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+            externalRequestId: z.ZodOptional<z.ZodString>;
+            toolInput: z.ZodOptional<z.ZodString>;
+            granted: z.ZodOptional<z.ZodBoolean>;
+            reason: z.ZodOptional<z.ZodString>;
+            timedOut: z.ZodOptional<z.ZodBoolean>;
+            aborted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodLiteral<"clarification">;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            question: z.ZodString;
+            context: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            answer: z.ZodOptional<z.ZodString>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strip>], "kind">>>;
+}, z.core.$strip>;
+export type AgentSessionHandle = z.infer<typeof agentSessionHandleSchema>;
+export declare const sessionDispatchOutcomeSchema: z.ZodEnum<{
+    awaiting_human: "awaiting_human";
+    completed: "completed";
+    session_active: "session_active";
+}>;
+export type SessionDispatchOutcome = z.infer<typeof sessionDispatchOutcomeSchema>;
+export declare const resolvedArtifactSchema: z.ZodObject<{
+    ref: z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>;
+    content: z.ZodString;
+}, z.core.$strip>;
+export type ResolvedArtifact = z.infer<typeof resolvedArtifactSchema>;
+export declare const workerOutputFormatSchema: z.ZodEnum<{
+    markdown_with_frontmatter: "markdown_with_frontmatter";
+    yaml: "yaml";
+    json: "json";
+    freeform: "freeform";
+}>;
+export type WorkerOutputFormat = z.infer<typeof workerOutputFormatSchema>;
+export declare const workerConstraintsSchema: z.ZodObject<{
+    maxOutputTokens: z.ZodNumber;
+    timeout: z.ZodNumber;
+    requiredOutputType: z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputFormat: z.ZodOptional<z.ZodEnum<{
+        markdown_with_frontmatter: "markdown_with_frontmatter";
+        yaml: "yaml";
+        json: "json";
+        freeform: "freeform";
+    }>>;
+}, z.core.$strip>;
+export type WorkerConstraints = z.infer<typeof workerConstraintsSchema>;
+export type StreamEventCallback = (event: {
+    timestamp: string;
+    type: AgentStreamEventType;
+    content: string;
+    structuredData?: Record<string, unknown>;
+    requestMessageId?: string;
+}) => void;
+export declare const dispatchOverridesSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodObject<{
+        roleId: z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>;
+        model: z.ZodString;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    maxRetries: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type DispatchOverrides = z.infer<typeof dispatchOverridesSchema>;
+export declare const dispatchRequestSchema: z.ZodObject<{
+    runId: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    stateId: z.ZodString;
+    role: z.ZodEnum<{
+        judge: "judge";
+        requirements_analyst: "requirements_analyst";
+        context_analyst: "context_analyst";
+        codebase_analyst: "codebase_analyst";
+        planner: "planner";
+        plan_reviewer: "plan_reviewer";
+        implementer: "implementer";
+        test_engineer: "test_engineer";
+        static_reviewer: "static_reviewer";
+        security_reviewer: "security_reviewer";
+        performance_reviewer: "performance_reviewer";
+        adversarial_reviewer: "adversarial_reviewer";
+        design_reviewer: "design_reviewer";
+        docs_reviewer: "docs_reviewer";
+        ux_reviewer: "ux_reviewer";
+        report_synthesizer: "report_synthesizer";
+        remediation_triage: "remediation_triage";
+        verifier: "verifier";
+        summary_writer: "summary_writer";
+        review_findings_writer: "review_findings_writer";
+        acceptance_validator: "acceptance_validator";
+        breakdown_analyst: "breakdown_analyst";
+        decomposer: "decomposer";
+        decomposition_reviewer: "decomposition_reviewer";
+        task_spec_writer: "task_spec_writer";
+    }>;
+    inputArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    overrides: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodObject<{
+            roleId: z.ZodEnum<{
+                judge: "judge";
+                requirements_analyst: "requirements_analyst";
+                context_analyst: "context_analyst";
+                codebase_analyst: "codebase_analyst";
+                planner: "planner";
+                plan_reviewer: "plan_reviewer";
+                implementer: "implementer";
+                test_engineer: "test_engineer";
+                static_reviewer: "static_reviewer";
+                security_reviewer: "security_reviewer";
+                performance_reviewer: "performance_reviewer";
+                adversarial_reviewer: "adversarial_reviewer";
+                design_reviewer: "design_reviewer";
+                docs_reviewer: "docs_reviewer";
+                ux_reviewer: "ux_reviewer";
+                report_synthesizer: "report_synthesizer";
+                remediation_triage: "remediation_triage";
+                verifier: "verifier";
+                summary_writer: "summary_writer";
+                review_findings_writer: "review_findings_writer";
+                acceptance_validator: "acceptance_validator";
+                breakdown_analyst: "breakdown_analyst";
+                decomposer: "decomposer";
+                decomposition_reviewer: "decomposition_reviewer";
+                task_spec_writer: "task_spec_writer";
+            }>;
+            model: z.ZodString;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        maxRetries: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    humanFeedback: z.ZodOptional<z.ZodString>;
+    userPrompt: z.ZodOptional<z.ZodString>;
+    previousReviewContent: z.ZodOptional<z.ZodString>;
+    structuredFindings: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodString;
+        blocking: z.ZodEnum<{
+            must_fix: "must_fix";
+            should_fix: "should_fix";
+            nit: "nit";
+        }>;
+        category: z.ZodEnum<{
+            completeness: "completeness";
+            correctness: "correctness";
+            consistency: "consistency";
+            security: "security";
+            performance: "performance";
+            maintainability: "maintainability";
+            style: "style";
+            documentation: "documentation";
+            test_coverage: "test_coverage";
+            architecture: "architecture";
+            other: "other";
+        }>;
+        title: z.ZodString;
+        description: z.ZodString;
+        location: z.ZodOptional<z.ZodObject<{
+            artifactRef: z.ZodObject<{
+                type: z.ZodEnum<{
+                    intake_requirements: "intake_requirements";
+                    canonical_specification: "canonical_specification";
+                    clarification_questions: "clarification_questions";
+                    clarification_answers: "clarification_answers";
+                    plan: "plan";
+                    plan_review: "plan_review";
+                    test_plan: "test_plan";
+                    implementation: "implementation";
+                    static_review: "static_review";
+                    security_review: "security_review";
+                    performance_review: "performance_review";
+                    adversarial_review: "adversarial_review";
+                    design_review: "design_review";
+                    docs_review: "docs_review";
+                    ux_review: "ux_review";
+                    review_report: "review_report";
+                    remediation_plan: "remediation_plan";
+                    verification: "verification";
+                    judge_decision: "judge_decision";
+                    planning_agreement: "planning_agreement";
+                    implementation_agreement: "implementation_agreement";
+                    verification_agreement: "verification_agreement";
+                    release_summary: "release_summary";
+                    release_agreement: "release_agreement";
+                    escalation_context: "escalation_context";
+                    run_manifest: "run_manifest";
+                    codebase_context: "codebase_context";
+                    test_suite: "test_suite";
+                    acceptance_validation: "acceptance_validation";
+                    review_findings: "review_findings";
+                    task_breakdown: "task_breakdown";
+                    decomposition_review: "decomposition_review";
+                    task_specifications: "task_specifications";
+                    pr_diff_context: "pr_diff_context";
+                }>;
+                name: z.ZodString;
+                version: z.ZodNumber;
+                checksum: z.ZodString;
+            }, z.core.$strip>;
+            section: z.ZodOptional<z.ZodString>;
+            line: z.ZodOptional<z.ZodNumber>;
+            snippet: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        suggestedFix: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            rejected: "rejected";
+            escalated: "escalated";
+            open: "open";
+            addressed: "addressed";
+            accepted: "accepted";
+        }>;
+        resolution: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                rejected: "rejected";
+                escalated: "escalated";
+                open: "open";
+                addressed: "addressed";
+                accepted: "accepted";
+            }>;
+            resolvedInArtifact: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    intake_requirements: "intake_requirements";
+                    canonical_specification: "canonical_specification";
+                    clarification_questions: "clarification_questions";
+                    clarification_answers: "clarification_answers";
+                    plan: "plan";
+                    plan_review: "plan_review";
+                    test_plan: "test_plan";
+                    implementation: "implementation";
+                    static_review: "static_review";
+                    security_review: "security_review";
+                    performance_review: "performance_review";
+                    adversarial_review: "adversarial_review";
+                    design_review: "design_review";
+                    docs_review: "docs_review";
+                    ux_review: "ux_review";
+                    review_report: "review_report";
+                    remediation_plan: "remediation_plan";
+                    verification: "verification";
+                    judge_decision: "judge_decision";
+                    planning_agreement: "planning_agreement";
+                    implementation_agreement: "implementation_agreement";
+                    verification_agreement: "verification_agreement";
+                    release_summary: "release_summary";
+                    release_agreement: "release_agreement";
+                    escalation_context: "escalation_context";
+                    run_manifest: "run_manifest";
+                    codebase_context: "codebase_context";
+                    test_suite: "test_suite";
+                    acceptance_validation: "acceptance_validation";
+                    review_findings: "review_findings";
+                    task_breakdown: "task_breakdown";
+                    decomposition_review: "decomposition_review";
+                    task_specifications: "task_specifications";
+                    pr_diff_context: "pr_diff_context";
+                }>;
+                name: z.ZodString;
+                version: z.ZodNumber;
+                checksum: z.ZodString;
+            }, z.core.$strip>>;
+            resolvedBy: z.ZodString;
+            rationale: z.ZodString;
+            timestamp: z.ZodString;
+        }, z.core.$strip>>;
+        supersedes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    iterationCount: z.ZodOptional<z.ZodNumber>;
+    variableOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type DispatchRequest = z.infer<typeof dispatchRequestSchema>;
+export declare const workerErrorTypeSchema: z.ZodEnum<{
+    timeout: "timeout";
+    agent_error: "agent_error";
+    invalid_output: "invalid_output";
+    schema_violation: "schema_violation";
+    ownership_violation: "ownership_violation";
+    cancelled: "cancelled";
+}>;
+export type WorkerErrorType = z.infer<typeof workerErrorTypeSchema>;
+export declare const workerErrorSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        timeout: "timeout";
+        agent_error: "agent_error";
+        invalid_output: "invalid_output";
+        schema_violation: "schema_violation";
+        ownership_violation: "ownership_violation";
+        cancelled: "cancelled";
+    }>;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+}, z.core.$strip>;
+export type WorkerError = z.infer<typeof workerErrorSchema>;
+export declare const workerMetricsSchema: z.ZodObject<{
+    startedAt: z.ZodString;
+    completedAt: z.ZodString;
+    durationMs: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    retryCount: z.ZodNumber;
+    modelUsed: z.ZodString;
+}, z.core.$strip>;
+export type WorkerMetrics = z.infer<typeof workerMetricsSchema>;
+export declare const dispatchStatusSchema: z.ZodEnum<{
+    success: "success";
+    timeout: "timeout";
+    cancelled: "cancelled";
+    failure: "failure";
+}>;
+export type DispatchStatus = z.infer<typeof dispatchStatusSchema>;
+export declare const dispatchResultSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodEnum<{
+        judge: "judge";
+        requirements_analyst: "requirements_analyst";
+        context_analyst: "context_analyst";
+        codebase_analyst: "codebase_analyst";
+        planner: "planner";
+        plan_reviewer: "plan_reviewer";
+        implementer: "implementer";
+        test_engineer: "test_engineer";
+        static_reviewer: "static_reviewer";
+        security_reviewer: "security_reviewer";
+        performance_reviewer: "performance_reviewer";
+        adversarial_reviewer: "adversarial_reviewer";
+        design_reviewer: "design_reviewer";
+        docs_reviewer: "docs_reviewer";
+        ux_reviewer: "ux_reviewer";
+        report_synthesizer: "report_synthesizer";
+        remediation_triage: "remediation_triage";
+        verifier: "verifier";
+        summary_writer: "summary_writer";
+        review_findings_writer: "review_findings_writer";
+        acceptance_validator: "acceptance_validator";
+        breakdown_analyst: "breakdown_analyst";
+        decomposer: "decomposer";
+        decomposition_reviewer: "decomposition_reviewer";
+        task_spec_writer: "task_spec_writer";
+    }>;
+    status: z.ZodEnum<{
+        success: "success";
+        timeout: "timeout";
+        cancelled: "cancelled";
+        failure: "failure";
+    }>;
+    outputArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            timeout: "timeout";
+            agent_error: "agent_error";
+            invalid_output: "invalid_output";
+            schema_violation: "schema_violation";
+            ownership_violation: "ownership_violation";
+            cancelled: "cancelled";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    metrics: z.ZodObject<{
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        durationMs: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        retryCount: z.ZodNumber;
+        modelUsed: z.ZodString;
+    }, z.core.$strip>;
+    sessionOutcome: z.ZodOptional<z.ZodEnum<{
+        awaiting_human: "awaiting_human";
+        completed: "completed";
+        session_active: "session_active";
+    }>>;
+    sessionRef: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodString;
+        runId: z.ZodString;
+        stateId: z.ZodString;
+        role: z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>;
+        transport: z.ZodEnum<{
+            stdio: "stdio";
+            remote: "remote";
+        }>;
+    }, z.core.$strip>>;
+    pendingRequest: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodLiteral<"permission">;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            action: z.ZodString;
+            resource: z.ZodString;
+            detail: z.ZodOptional<z.ZodString>;
+            riskLevel: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                low: "low";
+            }>>;
+            externalRequestId: z.ZodOptional<z.ZodString>;
+            toolInput: z.ZodOptional<z.ZodString>;
+            granted: z.ZodOptional<z.ZodBoolean>;
+            reason: z.ZodOptional<z.ZodString>;
+            timedOut: z.ZodOptional<z.ZodBoolean>;
+            aborted: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodLiteral<"clarification">;
+        createdAt: z.ZodString;
+        payload: z.ZodObject<{
+            question: z.ZodString;
+            context: z.ZodOptional<z.ZodString>;
+            options: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            answer: z.ZodOptional<z.ZodString>;
+        }, z.core.$catchall<z.ZodUnknown>>;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type DispatchResult = z.infer<typeof dispatchResultSchema>;
+export declare const workerStatusSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodEnum<{
+        judge: "judge";
+        requirements_analyst: "requirements_analyst";
+        context_analyst: "context_analyst";
+        codebase_analyst: "codebase_analyst";
+        planner: "planner";
+        plan_reviewer: "plan_reviewer";
+        implementer: "implementer";
+        test_engineer: "test_engineer";
+        static_reviewer: "static_reviewer";
+        security_reviewer: "security_reviewer";
+        performance_reviewer: "performance_reviewer";
+        adversarial_reviewer: "adversarial_reviewer";
+        design_reviewer: "design_reviewer";
+        docs_reviewer: "docs_reviewer";
+        ux_reviewer: "ux_reviewer";
+        report_synthesizer: "report_synthesizer";
+        remediation_triage: "remediation_triage";
+        verifier: "verifier";
+        summary_writer: "summary_writer";
+        review_findings_writer: "review_findings_writer";
+        acceptance_validator: "acceptance_validator";
+        breakdown_analyst: "breakdown_analyst";
+        decomposer: "decomposer";
+        decomposition_reviewer: "decomposition_reviewer";
+        task_spec_writer: "task_spec_writer";
+    }>;
+    state: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+        pending: "pending";
+        "timed-out": "timed-out";
+    }>;
+    startedAt: z.ZodString;
+    elapsedMs: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkerStatus = z.infer<typeof workerStatusSchema>;
+export declare const workerContextSchema: z.ZodObject<{
+    role: z.ZodObject<{
+        id: z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>;
+        name: z.ZodString;
+        description: z.ZodString;
+        ownedArtifacts: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>>>;
+        readableArtifacts: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>>>;
+        forbiddenArtifacts: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>>>;
+        reviewedBy: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>>>;
+        reviews: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>>>;
+        agreementParticipation: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            agreementType: z.ZodString;
+            action: z.ZodEnum<{
+                approved: "approved";
+                produced: "produced";
+                reviewed: "reviewed";
+            }>;
+        }, z.core.$strip>>>;
+        requiredCapabilities: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            code_generation: "code_generation";
+            code_review: "code_review";
+            reasoning: "reasoning";
+            long_context: "long_context";
+            structured_output: "structured_output";
+            vision: "vision";
+            external_data_fetch: "external_data_fetch";
+        }>>>;
+        dispatchType: z.ZodEnum<{
+            agent: "agent";
+        }>;
+        runner: z.ZodOptional<z.ZodString>;
+        agentConfig: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+            instructions: z.ZodOptional<z.ZodString>;
+            command: z.ZodOptional<z.ZodString>;
+            args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            handshakeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            liveRequestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            endpoint: z.ZodOptional<z.ZodString>;
+            authHeader: z.ZodOptional<z.ZodString>;
+            pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+            maxTurns: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    prompt: z.ZodString;
+    inputArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        ref: z.ZodObject<{
+            type: z.ZodEnum<{
+                intake_requirements: "intake_requirements";
+                canonical_specification: "canonical_specification";
+                clarification_questions: "clarification_questions";
+                clarification_answers: "clarification_answers";
+                plan: "plan";
+                plan_review: "plan_review";
+                test_plan: "test_plan";
+                implementation: "implementation";
+                static_review: "static_review";
+                security_review: "security_review";
+                performance_review: "performance_review";
+                adversarial_review: "adversarial_review";
+                design_review: "design_review";
+                docs_review: "docs_review";
+                ux_review: "ux_review";
+                review_report: "review_report";
+                remediation_plan: "remediation_plan";
+                verification: "verification";
+                judge_decision: "judge_decision";
+                planning_agreement: "planning_agreement";
+                implementation_agreement: "implementation_agreement";
+                verification_agreement: "verification_agreement";
+                release_summary: "release_summary";
+                release_agreement: "release_agreement";
+                escalation_context: "escalation_context";
+                run_manifest: "run_manifest";
+                codebase_context: "codebase_context";
+                test_suite: "test_suite";
+                acceptance_validation: "acceptance_validation";
+                review_findings: "review_findings";
+                task_breakdown: "task_breakdown";
+                decomposition_review: "decomposition_review";
+                task_specifications: "task_specifications";
+                pr_diff_context: "pr_diff_context";
+            }>;
+            name: z.ZodString;
+            version: z.ZodNumber;
+            checksum: z.ZodString;
+        }, z.core.$strip>;
+        content: z.ZodString;
+    }, z.core.$strip>>>;
+    modelAssignment: z.ZodObject<{
+        roleId: z.ZodEnum<{
+            judge: "judge";
+            requirements_analyst: "requirements_analyst";
+            context_analyst: "context_analyst";
+            codebase_analyst: "codebase_analyst";
+            planner: "planner";
+            plan_reviewer: "plan_reviewer";
+            implementer: "implementer";
+            test_engineer: "test_engineer";
+            static_reviewer: "static_reviewer";
+            security_reviewer: "security_reviewer";
+            performance_reviewer: "performance_reviewer";
+            adversarial_reviewer: "adversarial_reviewer";
+            design_reviewer: "design_reviewer";
+            docs_reviewer: "docs_reviewer";
+            ux_reviewer: "ux_reviewer";
+            report_synthesizer: "report_synthesizer";
+            remediation_triage: "remediation_triage";
+            verifier: "verifier";
+            summary_writer: "summary_writer";
+            review_findings_writer: "review_findings_writer";
+            acceptance_validator: "acceptance_validator";
+            breakdown_analyst: "breakdown_analyst";
+            decomposer: "decomposer";
+            decomposition_reviewer: "decomposition_reviewer";
+            task_spec_writer: "task_spec_writer";
+        }>;
+        model: z.ZodString;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+    constraints: z.ZodObject<{
+        maxOutputTokens: z.ZodNumber;
+        timeout: z.ZodNumber;
+        requiredOutputType: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        outputFormat: z.ZodOptional<z.ZodEnum<{
+            markdown_with_frontmatter: "markdown_with_frontmatter";
+            yaml: "yaml";
+            json: "json";
+            freeform: "freeform";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type WorkerContext = z.infer<typeof workerContextSchema>;
+export declare const workerInvocationRecordSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    runId: z.core.$ZodBranded<z.ZodString, "RunId", "out">;
+    workerId: z.ZodString;
+    stateId: z.ZodString;
+    role: z.ZodEnum<{
+        judge: "judge";
+        requirements_analyst: "requirements_analyst";
+        context_analyst: "context_analyst";
+        codebase_analyst: "codebase_analyst";
+        planner: "planner";
+        plan_reviewer: "plan_reviewer";
+        implementer: "implementer";
+        test_engineer: "test_engineer";
+        static_reviewer: "static_reviewer";
+        security_reviewer: "security_reviewer";
+        performance_reviewer: "performance_reviewer";
+        adversarial_reviewer: "adversarial_reviewer";
+        design_reviewer: "design_reviewer";
+        docs_reviewer: "docs_reviewer";
+        ux_reviewer: "ux_reviewer";
+        report_synthesizer: "report_synthesizer";
+        remediation_triage: "remediation_triage";
+        verifier: "verifier";
+        summary_writer: "summary_writer";
+        review_findings_writer: "review_findings_writer";
+        acceptance_validator: "acceptance_validator";
+        breakdown_analyst: "breakdown_analyst";
+        decomposer: "decomposer";
+        decomposition_reviewer: "decomposition_reviewer";
+        task_spec_writer: "task_spec_writer";
+    }>;
+    model: z.ZodString;
+    inputArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    outputArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+    }, z.core.$strip>>>;
+    status: z.ZodEnum<{
+        success: "success";
+        timeout: "timeout";
+        cancelled: "cancelled";
+        failure: "failure";
+    }>;
+    metrics: z.ZodObject<{
+        startedAt: z.ZodString;
+        completedAt: z.ZodString;
+        durationMs: z.ZodNumber;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        retryCount: z.ZodNumber;
+        modelUsed: z.ZodString;
+    }, z.core.$strip>;
+    error: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            timeout: "timeout";
+            agent_error: "agent_error";
+            invalid_output: "invalid_output";
+            schema_violation: "schema_violation";
+            ownership_violation: "ownership_violation";
+            cancelled: "cancelled";
+        }>;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkerInvocationRecord = z.infer<typeof workerInvocationRecordSchema>;
+export declare const retryPolicySchema: z.ZodObject<{
+    maxRetries: z.ZodNumber;
+    initialDelayMs: z.ZodNumber;
+    maxDelayMs: z.ZodNumber;
+    backoffMultiplier: z.ZodNumber;
+}, z.core.$strip>;
+export type RetryPolicy = z.infer<typeof retryPolicySchema>;
+export declare const agentConstraintsSchema: z.ZodObject<{
+    timeout: z.ZodNumber;
+    requiredOutputType: z.ZodEnum<{
+        intake_requirements: "intake_requirements";
+        canonical_specification: "canonical_specification";
+        clarification_questions: "clarification_questions";
+        clarification_answers: "clarification_answers";
+        plan: "plan";
+        plan_review: "plan_review";
+        test_plan: "test_plan";
+        implementation: "implementation";
+        static_review: "static_review";
+        security_review: "security_review";
+        performance_review: "performance_review";
+        adversarial_review: "adversarial_review";
+        design_review: "design_review";
+        docs_review: "docs_review";
+        ux_review: "ux_review";
+        review_report: "review_report";
+        remediation_plan: "remediation_plan";
+        verification: "verification";
+        judge_decision: "judge_decision";
+        planning_agreement: "planning_agreement";
+        implementation_agreement: "implementation_agreement";
+        verification_agreement: "verification_agreement";
+        release_summary: "release_summary";
+        release_agreement: "release_agreement";
+        escalation_context: "escalation_context";
+        run_manifest: "run_manifest";
+        codebase_context: "codebase_context";
+        test_suite: "test_suite";
+        acceptance_validation: "acceptance_validation";
+        review_findings: "review_findings";
+        task_breakdown: "task_breakdown";
+        decomposition_review: "decomposition_review";
+        task_specifications: "task_specifications";
+        pr_diff_context: "pr_diff_context";
+    }>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputFormat: z.ZodOptional<z.ZodEnum<{
+        markdown_with_frontmatter: "markdown_with_frontmatter";
+        yaml: "yaml";
+        json: "json";
+        freeform: "freeform";
+    }>>;
+}, z.core.$strip>;
+export type AgentConstraints = z.infer<typeof agentConstraintsSchema>;
+export declare const agentTaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    runId: z.ZodString;
+    stateId: z.ZodString;
+    role: z.ZodEnum<{
+        judge: "judge";
+        requirements_analyst: "requirements_analyst";
+        context_analyst: "context_analyst";
+        codebase_analyst: "codebase_analyst";
+        planner: "planner";
+        plan_reviewer: "plan_reviewer";
+        implementer: "implementer";
+        test_engineer: "test_engineer";
+        static_reviewer: "static_reviewer";
+        security_reviewer: "security_reviewer";
+        performance_reviewer: "performance_reviewer";
+        adversarial_reviewer: "adversarial_reviewer";
+        design_reviewer: "design_reviewer";
+        docs_reviewer: "docs_reviewer";
+        ux_reviewer: "ux_reviewer";
+        report_synthesizer: "report_synthesizer";
+        remediation_triage: "remediation_triage";
+        verifier: "verifier";
+        summary_writer: "summary_writer";
+        review_findings_writer: "review_findings_writer";
+        acceptance_validator: "acceptance_validator";
+        breakdown_analyst: "breakdown_analyst";
+        decomposer: "decomposer";
+        decomposition_reviewer: "decomposition_reviewer";
+        task_spec_writer: "task_spec_writer";
+    }>;
+    description: z.ZodString;
+    inputArtifacts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        ref: z.ZodObject<{
+            type: z.ZodEnum<{
+                intake_requirements: "intake_requirements";
+                canonical_specification: "canonical_specification";
+                clarification_questions: "clarification_questions";
+                clarification_answers: "clarification_answers";
+                plan: "plan";
+                plan_review: "plan_review";
+                test_plan: "test_plan";
+                implementation: "implementation";
+                static_review: "static_review";
+                security_review: "security_review";
+                performance_review: "performance_review";
+                adversarial_review: "adversarial_review";
+                design_review: "design_review";
+                docs_review: "docs_review";
+                ux_review: "ux_review";
+                review_report: "review_report";
+                remediation_plan: "remediation_plan";
+                verification: "verification";
+                judge_decision: "judge_decision";
+                planning_agreement: "planning_agreement";
+                implementation_agreement: "implementation_agreement";
+                verification_agreement: "verification_agreement";
+                release_summary: "release_summary";
+                release_agreement: "release_agreement";
+                escalation_context: "escalation_context";
+                run_manifest: "run_manifest";
+                codebase_context: "codebase_context";
+                test_suite: "test_suite";
+                acceptance_validation: "acceptance_validation";
+                review_findings: "review_findings";
+                task_breakdown: "task_breakdown";
+                decomposition_review: "decomposition_review";
+                task_specifications: "task_specifications";
+                pr_diff_context: "pr_diff_context";
+            }>;
+            name: z.ZodString;
+            version: z.ZodNumber;
+            checksum: z.ZodString;
+        }, z.core.$strip>;
+        content: z.ZodString;
+    }, z.core.$strip>>>;
+    repoRoot: z.ZodString;
+    runDir: z.ZodString;
+    outputArtifactPath: z.ZodString;
+    constraints: z.ZodObject<{
+        timeout: z.ZodNumber;
+        requiredOutputType: z.ZodEnum<{
+            intake_requirements: "intake_requirements";
+            canonical_specification: "canonical_specification";
+            clarification_questions: "clarification_questions";
+            clarification_answers: "clarification_answers";
+            plan: "plan";
+            plan_review: "plan_review";
+            test_plan: "test_plan";
+            implementation: "implementation";
+            static_review: "static_review";
+            security_review: "security_review";
+            performance_review: "performance_review";
+            adversarial_review: "adversarial_review";
+            design_review: "design_review";
+            docs_review: "docs_review";
+            ux_review: "ux_review";
+            review_report: "review_report";
+            remediation_plan: "remediation_plan";
+            verification: "verification";
+            judge_decision: "judge_decision";
+            planning_agreement: "planning_agreement";
+            implementation_agreement: "implementation_agreement";
+            verification_agreement: "verification_agreement";
+            release_summary: "release_summary";
+            release_agreement: "release_agreement";
+            escalation_context: "escalation_context";
+            run_manifest: "run_manifest";
+            codebase_context: "codebase_context";
+            test_suite: "test_suite";
+            acceptance_validation: "acceptance_validation";
+            review_findings: "review_findings";
+            task_breakdown: "task_breakdown";
+            decomposition_review: "decomposition_review";
+            task_specifications: "task_specifications";
+            pr_diff_context: "pr_diff_context";
+        }>;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        outputFormat: z.ZodOptional<z.ZodEnum<{
+            markdown_with_frontmatter: "markdown_with_frontmatter";
+            yaml: "yaml";
+            json: "json";
+            freeform: "freeform";
+        }>>;
+    }, z.core.$strip>;
+    instructions: z.ZodOptional<z.ZodString>;
+    rolePrompt: z.ZodOptional<z.ZodString>;
+    agentConfig: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        instructions: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        handshakeTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        liveRequestTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        endpoint: z.ZodOptional<z.ZodString>;
+        authHeader: z.ZodOptional<z.ZodString>;
+        pollIntervalMs: z.ZodOptional<z.ZodNumber>;
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    modelHint: z.ZodOptional<z.ZodString>;
+    humanFeedback: z.ZodOptional<z.ZodString>;
+    userPrompt: z.ZodOptional<z.ZodString>;
+    previousFindings: z.ZodOptional<z.ZodString>;
+    iterationCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type AgentTask = z.infer<typeof agentTaskSchema>;
+export declare const agentTokenUsageSchema: z.ZodObject<{
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+}, z.core.$strip>;
+export type AgentTokenUsage = z.infer<typeof agentTokenUsageSchema>;
+export declare const agentResultSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    status: z.ZodEnum<{
+        success: "success";
+        timeout: "timeout";
+        failure: "failure";
+    }>;
+    artifactContent: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    tokenUsage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentResult = z.infer<typeof agentResultSchema>;
+export declare const livePermissionResponsePayloadSchema: z.ZodObject<{
+    granted: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type LivePermissionResponsePayload = z.infer<typeof livePermissionResponsePayloadSchema>;
+export declare const liveClarificationResponsePayloadSchema: z.ZodObject<{
+    answer: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type LiveClarificationResponsePayload = z.infer<typeof liveClarificationResponsePayloadSchema>;
+export declare const submitResponseSchema: z.ZodObject<{
+    taskId: z.ZodString;
+}, z.core.$loose>;
+export type SubmitResponse = z.infer<typeof submitResponseSchema>;
+export declare const pollResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        running: "running";
+        completed: "completed";
+        failed: "failed";
+    }>;
+    result: z.ZodOptional<z.ZodObject<{
+        taskId: z.ZodString;
+        status: z.ZodEnum<{
+            success: "success";
+            timeout: "timeout";
+            failure: "failure";
+        }>;
+        artifactContent: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+        durationMs: z.ZodNumber;
+        tokenUsage: z.ZodOptional<z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type PollResponse = z.infer<typeof pollResponseSchema>;