@ai-dev-orchestrator/schemas 0.1.1

package/dist/dashboard/dashboard-domain.d.ts

@@ -0,0 +1,1076 @@
+import { z } from 'zod/v4';
+export declare const runStatusSchema: z.ZodEnum<{
+    running: "running";
+    paused: "paused";
+    completed: "completed";
+    failed: "failed";
+    aborted: "aborted";
+    waiting: "waiting";
+    interrupted: "interrupted";
+}>;
+export type RunStatus = z.infer<typeof runStatusSchema>;
+export declare const dashboardWaitingContextSchema: z.ZodObject<{
+    reason: z.ZodString;
+    requiredInput: z.ZodString;
+    requestingState: z.ZodString;
+    autoResumeSafe: z.ZodBoolean;
+    presentedArtifacts: 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>>>;
+    waitingSince: z.ZodString;
+    budgetExhaustion: z.ZodOptional<z.ZodObject<{
+        limitType: z.ZodLiteral<"token">;
+        current: z.ZodNumber;
+        limit: z.ZodNumber;
+        role: z.ZodOptional<z.ZodString>;
+        cumulativeTokens: z.ZodNumber;
+    }, z.core.$strip>>;
+    liveSessionId: z.ZodOptional<z.ZodString>;
+    pendingRequestId: z.ZodOptional<z.ZodString>;
+    liveRequestType: z.ZodOptional<z.ZodEnum<{
+        permission: "permission";
+        clarification: "clarification";
+    }>>;
+    sessionTransport: z.ZodOptional<z.ZodEnum<{
+        stdio: "stdio";
+        remote: "remote";
+    }>>;
+}, z.core.$strip>;
+export type DashboardWaitingContext = z.infer<typeof dashboardWaitingContextSchema>;
+export declare const dashboardSessionViewSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    runId: z.ZodString;
+    role: z.ZodString;
+    stateId: z.ZodString;
+    transport: z.ZodEnum<{
+        stdio: "stdio";
+        remote: "remote";
+    }>;
+    state: z.ZodString;
+    pendingRequestKind: z.ZodOptional<z.ZodEnum<{
+        permission: "permission";
+        clarification: "clarification";
+    }>>;
+    pendingRequestId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type DashboardSessionView = z.infer<typeof dashboardSessionViewSchema>;
+export declare const runStateViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        paused: "paused";
+        completed: "completed";
+        failed: "failed";
+        aborted: "aborted";
+        waiting: "waiting";
+        interrupted: "interrupted";
+    }>;
+    currentState: z.ZodString;
+    previousState: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodString;
+    stateEnteredAt: z.ZodString;
+    elapsedMs: z.ZodNumber;
+    transitionCount: z.ZodNumber;
+    isWaitingForHuman: z.ZodBoolean;
+    waitingReason: z.ZodOptional<z.ZodString>;
+    waitingContext: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+        requiredInput: z.ZodString;
+        requestingState: z.ZodString;
+        autoResumeSafe: z.ZodBoolean;
+        presentedArtifacts: 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>>>;
+        waitingSince: z.ZodString;
+        budgetExhaustion: z.ZodOptional<z.ZodObject<{
+            limitType: z.ZodLiteral<"token">;
+            current: z.ZodNumber;
+            limit: z.ZodNumber;
+            role: z.ZodOptional<z.ZodString>;
+            cumulativeTokens: z.ZodNumber;
+        }, z.core.$strip>>;
+        liveSessionId: z.ZodOptional<z.ZodString>;
+        pendingRequestId: z.ZodOptional<z.ZodString>;
+        liveRequestType: z.ZodOptional<z.ZodEnum<{
+            permission: "permission";
+            clarification: "clarification";
+        }>>;
+        sessionTransport: z.ZodOptional<z.ZodEnum<{
+            stdio: "stdio";
+            remote: "remote";
+        }>>;
+    }, z.core.$strip>>;
+    repoRoot: z.ZodOptional<z.ZodString>;
+    processAlive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RunStateView = z.infer<typeof runStateViewSchema>;
+export declare const parallelInfoSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        join: "join";
+        fork: "fork";
+    }>;
+    parallelRoles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    roleDurations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    dynamicRole: z.ZodOptional<z.ZodString>;
+    dynamicWorkerCount: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ParallelInfo = z.infer<typeof parallelInfoSchema>;
+export declare const stateNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    label: z.ZodString;
+    visited: z.ZodBoolean;
+    current: z.ZodBoolean;
+    timeSpentMs: z.ZodNumber;
+    visitCount: z.ZodNumber;
+    parallelInfo: z.ZodOptional<z.ZodObject<{
+        type: z.ZodEnum<{
+            join: "join";
+            fork: "fork";
+        }>;
+        parallelRoles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        roleDurations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        dynamicRole: z.ZodOptional<z.ZodString>;
+        dynamicWorkerCount: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    scripts: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type StateNode = z.infer<typeof stateNodeSchema>;
+export declare const transitionEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    trigger: z.ZodString;
+    traversed: z.ZodBoolean;
+    traversalCount: z.ZodNumber;
+}, z.core.$strip>;
+export type TransitionEdge = z.infer<typeof transitionEdgeSchema>;
+export declare const workflowStateViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    states: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodString;
+        label: z.ZodString;
+        visited: z.ZodBoolean;
+        current: z.ZodBoolean;
+        timeSpentMs: z.ZodNumber;
+        visitCount: z.ZodNumber;
+        parallelInfo: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                join: "join";
+                fork: "fork";
+            }>;
+            parallelRoles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            roleDurations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+            dynamicRole: z.ZodOptional<z.ZodString>;
+            dynamicWorkerCount: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        roles: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        scripts: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>>;
+    transitions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        trigger: z.ZodString;
+        traversed: z.ZodBoolean;
+        traversalCount: z.ZodNumber;
+    }, z.core.$strip>>>;
+    currentState: z.ZodString;
+    visitedStates: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    stateHistory: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    abortReason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type WorkflowStateView = z.infer<typeof workflowStateViewSchema>;
+export declare const artifactEntryViewSchema: 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>;
+    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;
+    producedBy: z.ZodString;
+    createdAt: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    verdict: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        conditionally_approved: "conditionally_approved";
+        rejected: "rejected";
+    }>>;
+}, z.core.$strip>;
+export type ArtifactEntryView = z.infer<typeof artifactEntryViewSchema>;
+export declare const artifactInventoryViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    artifacts: 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>;
+        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;
+        producedBy: z.ZodString;
+        createdAt: z.ZodString;
+        sizeBytes: z.ZodNumber;
+        verdict: z.ZodOptional<z.ZodEnum<{
+            approved: "approved";
+            conditionally_approved: "conditionally_approved";
+            rejected: "rejected";
+        }>>;
+    }, z.core.$strip>>>;
+    totalCount: z.ZodNumber;
+    totalSizeBytes: z.ZodNumber;
+    byType: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type ArtifactInventoryView = z.infer<typeof artifactInventoryViewSchema>;
+export declare const artifactVersionViewSchema: 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>;
+    version: z.ZodNumber;
+    checksum: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type ArtifactVersionView = z.infer<typeof artifactVersionViewSchema>;
+export declare const artifactDetailViewSchema: 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>;
+    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;
+    currentVersion: z.ZodNumber;
+    producedBy: z.ZodString;
+    createdAt: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    versions: 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>;
+        version: z.ZodNumber;
+        checksum: z.ZodString;
+        createdAt: z.ZodString;
+    }, z.core.$strip>>>;
+    dependsOn: 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>>>;
+    dependedOnBy: 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>>>;
+}, z.core.$strip>;
+export type ArtifactDetailView = z.infer<typeof artifactDetailViewSchema>;
+export declare const artifactContentViewSchema: z.ZodObject<{
+    content: z.ZodString;
+    contentType: z.ZodEnum<{
+        json: "json";
+        text: "text";
+        markdown: "markdown";
+        diff: "diff";
+    }>;
+    sizeBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type ArtifactContentView = z.infer<typeof artifactContentViewSchema>;
+export declare const contractProgressViewSchema: z.ZodObject<{
+    contractId: z.ZodString;
+    currentIteration: z.ZodNumber;
+    maxIterations: z.ZodNumber;
+    status: z.ZodString;
+    findingsTotal: z.ZodNumber;
+    findingsResolved: z.ZodNumber;
+    judgeArbitrations: z.ZodNumber;
+}, z.core.$strip>;
+export type ContractProgressView = z.infer<typeof contractProgressViewSchema>;
+export declare const iterationProgressViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    contracts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        contractId: z.ZodString;
+        currentIteration: z.ZodNumber;
+        maxIterations: z.ZodNumber;
+        status: z.ZodString;
+        findingsTotal: z.ZodNumber;
+        findingsResolved: z.ZodNumber;
+        judgeArbitrations: z.ZodNumber;
+    }, z.core.$strip>>>;
+    totalIterations: z.ZodNumber;
+    totalFindings: z.ZodNumber;
+    resolvedFindings: z.ZodNumber;
+}, z.core.$strip>;
+export type IterationProgressView = z.infer<typeof iterationProgressViewSchema>;
+export declare const findingEntryViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    severity: z.ZodString;
+    status: z.ZodString;
+    category: z.ZodString;
+    description: z.ZodString;
+    source: z.ZodString;
+    iteration: z.ZodNumber;
+}, z.core.$strip>;
+export type FindingEntryView = z.infer<typeof findingEntryViewSchema>;
+export declare const findingsViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    findings: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        severity: z.ZodString;
+        status: z.ZodString;
+        category: z.ZodString;
+        description: z.ZodString;
+        source: z.ZodString;
+        iteration: z.ZodNumber;
+    }, z.core.$strip>>>;
+    totalCount: z.ZodNumber;
+    bySeverity: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    byStatus: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type FindingsView = z.infer<typeof findingsViewSchema>;
+export declare const roleUsageViewSchema: z.ZodObject<{
+    role: z.ZodString;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    dispatches: z.ZodNumber;
+    totalDurationMs: z.ZodNumber;
+}, z.core.$strip>;
+export type RoleUsageView = z.infer<typeof roleUsageViewSchema>;
+export declare const usageBreakdownViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    totalInputTokens: z.ZodNumber;
+    totalOutputTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    byRole: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        dispatches: z.ZodNumber;
+        totalDurationMs: z.ZodNumber;
+    }, z.core.$strip>>>;
+    budgetSummary: z.ZodOptional<z.ZodObject<{
+        configuredMaxTokens: z.ZodNullable<z.ZodNumber>;
+        budgetExceeded: z.ZodBoolean;
+        alertThresholds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+        crossedThresholds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodNumber>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type UsageBreakdownView = z.infer<typeof usageBreakdownViewSchema>;
+export declare const runSummaryViewSchema: z.ZodObject<{
+    runId: z.ZodString;
+    repository: z.ZodString;
+    repoRoot: z.ZodOptional<z.ZodString>;
+    workflow: z.ZodString;
+    status: z.ZodString;
+    startedAt: z.ZodString;
+    completedAt: z.ZodString;
+    durationMs: z.ZodNumber;
+    totalArtifacts: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    totalInputTokens: z.ZodNumber;
+    totalOutputTokens: z.ZodNumber;
+    finalState: z.ZodString;
+    sources: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type RunSummaryView = z.infer<typeof runSummaryViewSchema>;
+export declare const roleAssignmentViewSchema: z.ZodObject<{
+    role: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    dispatchType: z.ZodOptional<z.ZodString>;
+    runner: z.ZodOptional<z.ZodString>;
+    maxTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    maxTurns: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RoleAssignmentView = z.infer<typeof roleAssignmentViewSchema>;
+export declare const runConfigViewSchema: z.ZodObject<{
+    roles: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        role: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        dispatchType: z.ZodOptional<z.ZodString>;
+        runner: z.ZodOptional<z.ZodString>;
+        maxTokens: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        maxTurns: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    iterationLimits: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    qualityGates: z.ZodObject<{
+        specificationReadiness: z.ZodObject<{
+            minCompletenessScore: z.ZodNumber;
+        }, z.core.$strip>;
+        implementationReview: z.ZodObject<{
+            maxHighSeverityFindings: z.ZodNumber;
+            maxMediumSeverityFindings: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    budget: z.ZodObject<{
+        maxTokensPerRun: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    sources: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    workflow: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunConfigView = z.infer<typeof runConfigViewSchema>;
+export declare const dashboardEventTypeSchema: z.ZodEnum<{
+    run_started: "run_started";
+    run_completed: "run_completed";
+    run_failed: "run_failed";
+    run_aborted: "run_aborted";
+    worker_dispatched: "worker_dispatched";
+    worker_completed: "worker_completed";
+    script_started: "script_started";
+    script_completed: "script_completed";
+    finding_resolved: "finding_resolved";
+    state_changed: "state_changed";
+    artifact_produced: "artifact_produced";
+    finding_added: "finding_added";
+    iteration_completed: "iteration_completed";
+    health_changed: "health_changed";
+    permission_requested: "permission_requested";
+    permission_resolved: "permission_resolved";
+    clarification_requested: "clarification_requested";
+    clarification_resolved: "clarification_resolved";
+}>;
+export type DashboardEventType = z.infer<typeof dashboardEventTypeSchema>;
+export declare const dashboardEventSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        run_started: "run_started";
+        run_completed: "run_completed";
+        run_failed: "run_failed";
+        run_aborted: "run_aborted";
+        worker_dispatched: "worker_dispatched";
+        worker_completed: "worker_completed";
+        script_started: "script_started";
+        script_completed: "script_completed";
+        finding_resolved: "finding_resolved";
+        state_changed: "state_changed";
+        artifact_produced: "artifact_produced";
+        finding_added: "finding_added";
+        iteration_completed: "iteration_completed";
+        health_changed: "health_changed";
+        permission_requested: "permission_requested";
+        permission_resolved: "permission_resolved";
+        clarification_requested: "clarification_requested";
+        clarification_resolved: "clarification_resolved";
+    }>;
+    timestamp: z.ZodString;
+    runId: z.ZodOptional<z.ZodString>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type DashboardEvent = z.infer<typeof dashboardEventSchema>;
+export declare const subsystemHealthViewSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        degraded: "degraded";
+        unhealthy: "unhealthy";
+    }>;
+    lastCheckedAt: z.ZodString;
+    consecutiveFailures: z.ZodNumber;
+    message: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SubsystemHealthView = z.infer<typeof subsystemHealthViewSchema>;
+export declare const systemHealthViewSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    overallStatus: z.ZodEnum<{
+        unknown: "unknown";
+        healthy: "healthy";
+        degraded: "degraded";
+        unhealthy: "unhealthy";
+    }>;
+    subsystems: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            healthy: "healthy";
+            degraded: "degraded";
+            unhealthy: "unhealthy";
+        }>;
+        lastCheckedAt: z.ZodString;
+        consecutiveFailures: z.ZodNumber;
+        message: z.ZodString;
+        version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type SystemHealthView = z.infer<typeof systemHealthViewSchema>;
+export declare const runnerDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    models: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type RunnerDefinition = z.infer<typeof runnerDefinitionSchema>;
+export declare const settingsRoleAssignmentSchema: z.ZodObject<{
+    model: z.ZodString;
+    dispatchType: z.ZodOptional<z.ZodString>;
+    runner: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SettingsRoleAssignment = z.infer<typeof settingsRoleAssignmentSchema>;
+export declare const settingsPermissionRuleSchema: z.ZodObject<{
+    action: z.ZodString;
+    decision: z.ZodEnum<{
+        grant: "grant";
+        deny: "deny";
+    }>;
+    scope: z.ZodOptional<z.ZodString>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const settingsPermissionPolicySchema: z.ZodObject<{
+    defaultAction: z.ZodEnum<{
+        grant: "grant";
+        deny: "deny";
+        ask_human: "ask_human";
+    }>;
+    rules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        decision: z.ZodEnum<{
+            grant: "grant";
+            deny: "deny";
+        }>;
+        scope: z.ZodOptional<z.ZodString>;
+        pattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>>;
+    roleTrust: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        none: "none";
+    }>>>;
+    safeCommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type SettingsPermissionPolicy = z.infer<typeof settingsPermissionPolicySchema>;
+export declare const settingsGovernanceSchema: z.ZodObject<{
+    iterationLimits: z.ZodObject<{
+        defaults: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>;
+    qualityGates: z.ZodObject<{
+        specificationReadiness: z.ZodObject<{
+            minCompletenessScore: z.ZodNumber;
+        }, z.core.$strip>;
+        implementationReview: z.ZodObject<{
+            maxHighSeverityFindings: z.ZodNumber;
+            maxMediumSeverityFindings: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    budget: z.ZodOptional<z.ZodObject<{
+        maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    permissionPolicy: z.ZodOptional<z.ZodObject<{
+        defaultAction: z.ZodEnum<{
+            grant: "grant";
+            deny: "deny";
+            ask_human: "ask_human";
+        }>;
+        rules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            decision: z.ZodEnum<{
+                grant: "grant";
+                deny: "deny";
+            }>;
+            scope: z.ZodOptional<z.ZodString>;
+            pattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>>;
+        roleTrust: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+            high: "high";
+            medium: "medium";
+            none: "none";
+        }>>>;
+        safeCommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type SettingsGovernance = z.infer<typeof settingsGovernanceSchema>;
+export declare const projectSettingsViewSchema: z.ZodObject<{
+    roles: z.ZodObject<{
+        assignments: z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodString;
+            dispatchType: z.ZodOptional<z.ZodString>;
+            runner: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    governance: z.ZodObject<{
+        iterationLimits: z.ZodObject<{
+            defaults: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        }, z.core.$strip>;
+        qualityGates: z.ZodObject<{
+            specificationReadiness: z.ZodObject<{
+                minCompletenessScore: z.ZodNumber;
+            }, z.core.$strip>;
+            implementationReview: z.ZodObject<{
+                maxHighSeverityFindings: z.ZodNumber;
+                maxMediumSeverityFindings: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        budget: z.ZodOptional<z.ZodObject<{
+            maxTokensPerRun: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        permissionPolicy: z.ZodOptional<z.ZodObject<{
+            defaultAction: z.ZodEnum<{
+                grant: "grant";
+                deny: "deny";
+                ask_human: "ask_human";
+            }>;
+            rules: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                action: z.ZodString;
+                decision: z.ZodEnum<{
+                    grant: "grant";
+                    deny: "deny";
+                }>;
+                scope: z.ZodOptional<z.ZodString>;
+                pattern: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>>;
+            roleTrust: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+                high: "high";
+                medium: "medium";
+                none: "none";
+            }>>>;
+            safeCommands: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    runtime: z.ZodObject<{
+        logLevel: z.ZodString;
+    }, z.core.$strip>;
+    availableRunners: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    modelsByRunner: z.ZodRecord<z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+}, z.core.$strip>;
+export type ProjectSettingsView = z.infer<typeof projectSettingsViewSchema>;