@ai-dev-orchestrator/schemas 0.1.1

package/dist/config/event-payloads.d.ts

@@ -0,0 +1,919 @@
+import { z } from 'zod/v4';
+export declare const runStartedDataSchema: z.ZodObject<{
+    config: z.ZodObject<{
+        workflow: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+        repository: z.ZodString;
+        sourceType: z.ZodString;
+    }, z.core.$strip>;
+    tokenBudget: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RunStartedData = z.infer<typeof runStartedDataSchema>;
+export declare const runCompletedDataSchema: z.ZodObject<{
+    outcome: z.ZodEnum<{
+        success: "success";
+        failed: "failed";
+        partial: "partial";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+    artifactCount: z.ZodNumber;
+    totalDurationMs: z.ZodNumber;
+    totalTokens: z.ZodObject<{
+        input: z.ZodNumber;
+        output: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RunCompletedData = z.infer<typeof runCompletedDataSchema>;
+export declare const runAbortedDataSchema: z.ZodObject<{
+    reason: z.ZodString;
+    abortedBy: z.ZodEnum<{
+        policy: "policy";
+        governance: "governance";
+        system: "system";
+        user: "user";
+    }>;
+    lastState: z.ZodString;
+}, z.core.$strip>;
+export type RunAbortedData = z.infer<typeof runAbortedDataSchema>;
+export declare const runResumedDataSchema: z.ZodObject<{
+    resumedFromState: z.ZodString;
+    checkpointTimestamp: z.ZodString;
+    eventsReplayed: z.ZodNumber;
+}, z.core.$strip>;
+export type RunResumedData = z.infer<typeof runResumedDataSchema>;
+export declare const runPausedDataSchema: z.ZodObject<{
+    reason: z.ZodEnum<{
+        human_input_required: "human_input_required";
+        rate_limited: "rate_limited";
+        manual: "manual";
+    }>;
+    pausedInState: z.ZodString;
+}, z.core.$strip>;
+export type RunPausedData = z.infer<typeof runPausedDataSchema>;
+export declare const stateEnteredDataSchema: z.ZodObject<{
+    stateId: z.ZodString;
+    stateType: z.ZodString;
+    entryActionsCount: z.ZodNumber;
+}, z.core.$strip>;
+export type StateEnteredData = z.infer<typeof stateEnteredDataSchema>;
+export declare const stateExitedDataSchema: z.ZodObject<{
+    stateId: z.ZodString;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>;
+export type StateExitedData = z.infer<typeof stateExitedDataSchema>;
+export declare const transitionRequestedDataSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    trigger: z.ZodString;
+    guardsToEvaluate: z.ZodNumber;
+}, z.core.$strip>;
+export type TransitionRequestedData = z.infer<typeof transitionRequestedDataSchema>;
+export declare const transitionCompletedDataSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    trigger: z.ZodString;
+    guardsEvaluated: z.ZodNumber;
+    guardsPassed: z.ZodNumber;
+    governanceConsulted: z.ZodBoolean;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>;
+export type TransitionCompletedData = z.infer<typeof transitionCompletedDataSchema>;
+export declare const transitionDeniedDataSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    trigger: z.ZodString;
+    deniedBy: z.ZodEnum<{
+        policy: "policy";
+        guard: "guard";
+        governance: "governance";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type TransitionDeniedData = z.infer<typeof transitionDeniedDataSchema>;
+export declare const workerDispatchedDataSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodString;
+    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>>>;
+}, z.core.$strip>;
+export type WorkerDispatchedData = z.infer<typeof workerDispatchedDataSchema>;
+export declare const workerCompletedDataSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodString;
+    model: z.ZodString;
+    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>>>;
+    durationMs: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    repairAttempts: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkerCompletedData = z.infer<typeof workerCompletedDataSchema>;
+export declare const workerFailedDataSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodString;
+    error: z.ZodString;
+    errorCategory: z.ZodEnum<{
+        unknown: "unknown";
+        timeout: "timeout";
+        agent_error: "agent_error";
+        cancelled: "cancelled";
+        validation_error: "validation_error";
+    }>;
+    durationMs: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    willRetry: z.ZodBoolean;
+}, z.core.$strip>;
+export type WorkerFailedData = z.infer<typeof workerFailedDataSchema>;
+export declare const workerRetriedDataSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodString;
+    attempt: z.ZodNumber;
+    maxAttempts: z.ZodNumber;
+    retryReason: z.ZodString;
+    backoffMs: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkerRetriedData = z.infer<typeof workerRetriedDataSchema>;
+export declare const workerCancelledDataSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodString;
+    cancelledBy: z.ZodEnum<{
+        timeout: "timeout";
+        governance: "governance";
+        system: "system";
+        user: "user";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type WorkerCancelledData = z.infer<typeof workerCancelledDataSchema>;
+export declare const workerTimeoutDataSchema: z.ZodObject<{
+    workerId: z.ZodString;
+    role: z.ZodString;
+    timeoutMs: z.ZodNumber;
+    elapsedMs: z.ZodNumber;
+}, z.core.$strip>;
+export type WorkerTimeoutData = z.infer<typeof workerTimeoutDataSchema>;
+export declare const artifactStoredDataSchema: 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>;
+    producedBy: z.ZodString;
+    sizeBytes: z.ZodNumber;
+    predecessorRef: 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>>;
+}, z.core.$strip>;
+export type ArtifactStoredData = z.infer<typeof artifactStoredDataSchema>;
+export declare const artifactVerifiedDataSchema: 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>;
+    integrityValid: z.ZodBoolean;
+    expectedChecksum: z.ZodString;
+    actualChecksum: z.ZodString;
+}, z.core.$strip>;
+export type ArtifactVerifiedData = z.infer<typeof artifactVerifiedDataSchema>;
+export declare const artifactInvalidatedDataSchema: 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>;
+    reason: z.ZodEnum<{
+        policy: "policy";
+        manual: "manual";
+        upstream_changed: "upstream_changed";
+    }>;
+    invalidatedBy: z.ZodString;
+}, z.core.$strip>;
+export type ArtifactInvalidatedData = z.infer<typeof artifactInvalidatedDataSchema>;
+export declare const governanceDecisionDataSchema: z.ZodObject<{
+    transition: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strip>;
+    decision: z.ZodEnum<{
+        allowed: "allowed";
+        denied: "denied";
+        escalated: "escalated";
+    }>;
+    policiesEvaluated: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+    policyResults: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        policyType: z.ZodString;
+        outcome: z.ZodEnum<{
+            pass: "pass";
+            fail: "fail";
+            skip: "skip";
+        }>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type GovernanceDecisionData = z.infer<typeof governanceDecisionDataSchema>;
+export declare const agreementProducedDataSchema: z.ZodObject<{
+    agreementType: z.ZodString;
+    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>;
+    participantCount: z.ZodNumber;
+    findingsCount: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        conditionally_approved: "conditionally_approved";
+        rejected: "rejected";
+    }>;
+}, z.core.$strip>;
+export type AgreementProducedData = z.infer<typeof agreementProducedDataSchema>;
+export declare const escalationTriggeredDataSchema: z.ZodObject<{
+    trigger: z.ZodEnum<{
+        iteration_limit_exceeded: "iteration_limit_exceeded";
+        quality_gate_failed: "quality_gate_failed";
+        unresolvable_conflict: "unresolvable_conflict";
+        human_requested: "human_requested";
+        token_budget_exceeded: "token_budget_exceeded";
+        retry_limit_exceeded: "retry_limit_exceeded";
+        confidence_too_low: "confidence_too_low";
+        provider_failure: "provider_failure";
+        timeout: "timeout";
+        unrecoverable_error: "unrecoverable_error";
+    }>;
+    currentState: z.ZodString;
+    iterationCount: z.ZodNumber;
+    escalationContextRef: 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 EscalationTriggeredData = z.infer<typeof escalationTriggeredDataSchema>;
+export declare const policyEvaluatedDataSchema: z.ZodObject<{
+    policyCount: z.ZodNumber;
+    passCount: z.ZodNumber;
+    failCount: z.ZodNumber;
+    skipCount: z.ZodNumber;
+    overallOutcome: z.ZodEnum<{
+        deny: "deny";
+        escalate: "escalate";
+        allow: "allow";
+    }>;
+}, z.core.$strip>;
+export type PolicyEvaluatedData = z.infer<typeof policyEvaluatedDataSchema>;
+export declare const policyDeniedDataSchema: z.ZodObject<{
+    policyType: z.ZodString;
+    reason: z.ZodString;
+    remediations: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type PolicyDeniedData = z.infer<typeof policyDeniedDataSchema>;
+export declare const policyEscalatedDataSchema: z.ZodObject<{
+    policyType: z.ZodString;
+    reason: z.ZodString;
+    escalationTarget: z.ZodEnum<{
+        human: "human";
+        governance: "governance";
+    }>;
+}, z.core.$strip>;
+export type PolicyEscalatedData = z.infer<typeof policyEscalatedDataSchema>;
+export declare const findingRaisedDataSchema: z.ZodObject<{
+    findingId: z.ZodString;
+    severity: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+        info: "info";
+        critical: "critical";
+    }>;
+    category: z.ZodString;
+    title: z.ZodString;
+    reviewArtifact: 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 FindingRaisedData = z.infer<typeof findingRaisedDataSchema>;
+export declare const findingAddressedDataSchema: z.ZodObject<{
+    findingId: z.ZodString;
+    resolutionType: z.ZodEnum<{
+        fixed: "fixed";
+        acknowledged: "acknowledged";
+        wont_fix: "wont_fix";
+        deferred: "deferred";
+    }>;
+    implementationArtifact: 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 FindingAddressedData = z.infer<typeof findingAddressedDataSchema>;
+export declare const findingAcceptedDataSchema: z.ZodObject<{
+    findingId: z.ZodString;
+    acceptedBy: z.ZodString;
+}, z.core.$strip>;
+export type FindingAcceptedData = z.infer<typeof findingAcceptedDataSchema>;
+export declare const findingRejectedDataSchema: z.ZodObject<{
+    findingId: z.ZodString;
+    rejectedBy: z.ZodString;
+    reason: z.ZodString;
+}, z.core.$strip>;
+export type FindingRejectedData = z.infer<typeof findingRejectedDataSchema>;
+export declare const findingEscalatedDataSchema: z.ZodObject<{
+    findingId: z.ZodString;
+    reason: z.ZodString;
+    escalationContextRef: 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 FindingEscalatedData = z.infer<typeof findingEscalatedDataSchema>;
+export declare const humanInputRequestedDataSchema: z.ZodObject<{
+    requestType: z.ZodEnum<{
+        clarification: "clarification";
+        review: "review";
+        approval: "approval";
+        decision: "decision";
+    }>;
+    context: z.ZodString;
+    currentState: z.ZodString;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type HumanInputRequestedData = z.infer<typeof humanInputRequestedDataSchema>;
+export declare const humanInputReceivedDataSchema: z.ZodObject<{
+    requestType: z.ZodString;
+    responseTimeMs: z.ZodNumber;
+    inputSizeChars: z.ZodNumber;
+}, z.core.$strip>;
+export type HumanInputReceivedData = z.infer<typeof humanInputReceivedDataSchema>;
+export declare const humanApprovalGrantedDataSchema: z.ZodObject<{
+    approvalType: z.ZodString;
+    conditions: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    artifactRef: 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>>;
+}, z.core.$strip>;
+export type HumanApprovalGrantedData = z.infer<typeof humanApprovalGrantedDataSchema>;
+export declare const humanApprovalDeniedDataSchema: z.ZodObject<{
+    approvalType: z.ZodString;
+    reason: z.ZodString;
+    artifactRef: 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>>;
+}, z.core.$strip>;
+export type HumanApprovalDeniedData = z.infer<typeof humanApprovalDeniedDataSchema>;
+export declare const humanTimeoutDataSchema: z.ZodObject<{
+    requestType: z.ZodString;
+    timeoutMs: z.ZodNumber;
+    fallbackAction: z.ZodEnum<{
+        abort: "abort";
+        escalate: "escalate";
+        continue_with_default: "continue_with_default";
+    }>;
+}, z.core.$strip>;
+export type HumanTimeoutData = z.infer<typeof humanTimeoutDataSchema>;
+export declare const humanPermissionRequestedDataSchema: z.ZodObject<{
+    runId: z.ZodString;
+    messageId: z.ZodString;
+    action: z.ZodString;
+    resource: z.ZodString;
+    riskLevel: z.ZodEnum<{
+        high: "high";
+        medium: "medium";
+        low: "low";
+    }>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanPermissionRequestedData = z.infer<typeof humanPermissionRequestedDataSchema>;
+export declare const humanPermissionResolvedDataSchema: z.ZodObject<{
+    runId: z.ZodString;
+    messageId: z.ZodString;
+    granted: z.ZodBoolean;
+}, z.core.$strip>;
+export type HumanPermissionResolvedData = z.infer<typeof humanPermissionResolvedDataSchema>;
+export declare const humanClarificationRequestedDataSchema: z.ZodObject<{
+    runId: z.ZodString;
+    messageId: z.ZodString;
+    question: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type HumanClarificationRequestedData = z.infer<typeof humanClarificationRequestedDataSchema>;
+export declare const humanClarificationAnsweredDataSchema: z.ZodObject<{
+    runId: z.ZodString;
+    messageId: z.ZodString;
+    answer: z.ZodString;
+}, z.core.$strip>;
+export type HumanClarificationAnsweredData = z.infer<typeof humanClarificationAnsweredDataSchema>;
+export declare const checkpointSavedDataSchema: z.ZodObject<{
+    checkpointId: z.ZodString;
+    currentState: z.ZodString;
+    artifactCount: z.ZodNumber;
+    sizeBytes: z.ZodNumber;
+}, z.core.$strip>;
+export type CheckpointSavedData = z.infer<typeof checkpointSavedDataSchema>;
+export declare const checkpointRestoredDataSchema: z.ZodObject<{
+    checkpointId: z.ZodString;
+    restoredToState: z.ZodString;
+    eventsSinceCheckpoint: z.ZodNumber;
+}, z.core.$strip>;
+export type CheckpointRestoredData = z.infer<typeof checkpointRestoredDataSchema>;
+export declare const systemErrorDataSchema: z.ZodObject<{
+    component: z.ZodString;
+    message: z.ZodString;
+    recoverable: z.ZodBoolean;
+    stack: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SystemErrorData = z.infer<typeof systemErrorDataSchema>;
+export declare const systemWarningDataSchema: z.ZodObject<{
+    component: z.ZodString;
+    message: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type SystemWarningData = z.infer<typeof systemWarningDataSchema>;