@zhixuan92/multi-model-agent-core 3.12.6 → 4.0.0

package/dist/events/observability-events.d.ts

@@ -0,0 +1,1196 @@
+import { z } from 'zod';
+export { RouteEnum, TierEnum, DiagLoopEnum, DiagRoleEnum, DiagReasonEnum, ProviderTypeEnum, InternalRunStatusEnum, ReviewVerdictEnum, VerifyOutcomeEnum, VerifySkipReasonEnum, WorkerStatusEnum, } from './event-base.js';
+export declare const TaskStartedEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"task_started">;
+    route: z.ZodEnum<{
+        review: "review";
+        retry: "retry";
+        delegate: "delegate";
+        audit: "audit";
+        verify: "verify";
+        debug: "debug";
+        "execute-plan": "execute-plan";
+        investigate: "investigate";
+        explore: "explore";
+        explore_internal: "explore_internal";
+        explore_external: "explore_external";
+        explore_synthesize: "explore_synthesize";
+        "register-context-block": "register-context-block";
+    }>;
+    cwd: z.ZodString;
+}, z.core.$strict>;
+export declare const StageChangeEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"stage_change">;
+    from: z.ZodString;
+    to: z.ZodString;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    attemptCap: z.ZodOptional<z.ZodNumber>;
+    implTier: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>>;
+    reviewerTier: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>>;
+    escalated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const HeartbeatEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"heartbeat">;
+    elapsed: z.ZodString;
+    stage: z.ZodString;
+    round: z.ZodOptional<z.ZodNumber>;
+    cap: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodNumber;
+    read: z.ZodNumber;
+    wrote: z.ZodNumber;
+    text: z.ZodNumber;
+    cost: z.ZodNullable<z.ZodNumber>;
+    idle_ms: z.ZodNumber;
+    stage_idle_ms: z.ZodNumber;
+}, z.core.$strict>;
+export declare const FallbackEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"fallback">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        specReviewer: "specReviewer";
+        qualityReviewer: "qualityReviewer";
+        diffReviewer: "diffReviewer";
+    }>;
+    assignedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    usedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reason: z.ZodEnum<{
+        transport_failure: "transport_failure";
+        not_configured: "not_configured";
+    }>;
+    triggeringStatus: z.ZodOptional<z.ZodEnum<{
+        provider_transport_failure: "provider_transport_failure";
+        error: "error";
+        ok: "ok";
+        incomplete: "incomplete";
+        timeout: "timeout";
+        api_aborted: "api_aborted";
+        api_error: "api_error";
+        brief_too_vague: "brief_too_vague";
+        cost_exceeded: "cost_exceeded";
+        unavailable: "unavailable";
+    }>>;
+    violatesSeparation: z.ZodBoolean;
+    fallbackSeparationRespected: z.ZodOptional<z.ZodBoolean>;
+    assignedIdentity: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        providerType: z.ZodString;
+        normalizedEndpoint: z.ZodString;
+        modelId: z.ZodString;
+    }, z.core.$strip>>>;
+    usedIdentity: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        providerType: z.ZodString;
+        normalizedEndpoint: z.ZodString;
+        modelId: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export declare const FallbackUnavailableEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"fallback_unavailable">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        specReviewer: "specReviewer";
+        qualityReviewer: "qualityReviewer";
+        diffReviewer: "diffReviewer";
+    }>;
+    assignedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reason: z.ZodEnum<{
+        transport_failure: "transport_failure";
+        not_configured: "not_configured";
+    }>;
+}, z.core.$strict>;
+export declare const EscalationEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"escalation">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    baseTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    implTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reviewerTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+}, z.core.$strict>;
+export declare const EscalationUnavailableEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"escalation_unavailable">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        specReviewer: "specReviewer";
+        qualityReviewer: "qualityReviewer";
+        diffReviewer: "diffReviewer";
+    }>;
+    wantedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reason: z.ZodEnum<{
+        transport_failure: "transport_failure";
+        not_configured: "not_configured";
+    }>;
+}, z.core.$strict>;
+export declare const ReviewDecisionEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"review_decision">;
+    stage: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        concerns: "concerns";
+        changes_required: "changes_required";
+        annotated: "annotated";
+        error: "error";
+        skipped: "skipped";
+        not_applicable: "not_applicable";
+    }>;
+    round: z.ZodNumber;
+}, z.core.$strict>;
+export declare const VerifyStepEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"verify_step">;
+    command: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        passed: "passed";
+        failed: "failed";
+    }>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    signal: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const VerifySkippedEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"verify_skipped">;
+    reason: z.ZodEnum<{
+        other: "other";
+        not_applicable: "not_applicable";
+        no_command: "no_command";
+        dirty_worktree: "dirty_worktree";
+    }>;
+    stage: z.ZodString;
+}, z.core.$strict>;
+export declare const ReadOnlyReviewQualityEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"read_only_review.quality">;
+    route: z.ZodString;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        concerns: "concerns";
+        changes_required: "changes_required";
+        annotated: "annotated";
+        error: "error";
+        skipped: "skipped";
+        not_applicable: "not_applicable";
+    }>;
+    iterationIndex: z.ZodNumber;
+    findingsReviewed: z.ZodNumber;
+    meanConfidence: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNumber;
+    costUSD: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const ReadOnlyReviewTerminalEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"read_only_review.terminal">;
+    route: z.ZodString;
+    roundsUsed: z.ZodNumber;
+    finalQualityVerdict: z.ZodEnum<{
+        approved: "approved";
+        concerns: "concerns";
+        changes_required: "changes_required";
+        annotated: "annotated";
+        error: "error";
+        skipped: "skipped";
+        not_applicable: "not_applicable";
+    }>;
+    costUSD: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const StallAbortEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"stall_abort">;
+    idle_ms: z.ZodNumber;
+    threshold_ms: z.ZodNumber;
+}, z.core.$strict>;
+export declare const TimeCheckEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"time_check">;
+    stage: z.ZodString;
+    tripped: z.ZodBoolean;
+    wallClockMs: z.ZodNumber;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const CostCheckEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"cost_check">;
+    stage: z.ZodString;
+    tripped: z.ZodBoolean;
+    cost_used_usd: z.ZodNumber;
+    cost_cap_usd: z.ZodNumber;
+    cost_available: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const ExploreParallelStartEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_parallel_start">;
+    internalRoute: z.ZodString;
+    externalRoute: z.ZodString;
+}, z.core.$strict>;
+export declare const ExploreParallelEndEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_parallel_end">;
+    internalOk: z.ZodBoolean;
+    externalOk: z.ZodBoolean;
+    internalDurationMs: z.ZodNumber;
+    externalDurationMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ExploreInternalUnavailableEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_internal_unavailable">;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export declare const ExploreExternalUnavailableEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_external_unavailable">;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export declare const ExploreSynthesizeStartEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_synthesize_start">;
+    internalAvailable: z.ZodBoolean;
+    externalAvailable: z.ZodBoolean;
+}, z.core.$strict>;
+export declare const ExploreSynthesizeEndEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_synthesize_end">;
+    threadCount: z.ZodNumber;
+    recommendedNextStep: z.ZodBoolean;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ExploreThreadStartedEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_thread_started">;
+    threadIndex: z.ZodNumber;
+}, z.core.$strict>;
+export declare const ExploreThreadCompletedEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_thread_completed">;
+    threadIndex: z.ZodNumber;
+}, z.core.$strict>;
+export declare const BatchCompletedEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"batch_completed">;
+    tool: z.ZodString;
+    durationMs: z.ZodNumber;
+    taskCount: z.ZodNumber;
+}, z.core.$strict>;
+export declare const BatchFailedEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"batch_failed">;
+    tool: z.ZodString;
+    durationMs: z.ZodNumber;
+    errorCode: z.ZodString;
+    errorMessage: z.ZodString;
+}, z.core.$strict>;
+export declare const StageStatsMapSchema: z.ZodObject<{
+    implementing: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"implementing">;
+    }, z.core.$strip>;
+    spec_rework: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"spec_rework">;
+    }, z.core.$strip>;
+    quality_rework: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"quality_rework">;
+    }, z.core.$strip>;
+    committing: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"committing">;
+    }, z.core.$strip>;
+    verifying: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"verifying">;
+        outcome: z.ZodNullable<z.ZodEnum<{
+            skipped: "skipped";
+            not_applicable: "not_applicable";
+            passed: "passed";
+            failed: "failed";
+        }>>;
+        skipReason: z.ZodNullable<z.ZodEnum<{
+            other: "other";
+            not_applicable: "not_applicable";
+            no_command: "no_command";
+            dirty_worktree: "dirty_worktree";
+        }>>;
+    }, z.core.$strip>;
+    spec_review: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"spec_review">;
+        verdict: z.ZodNullable<z.ZodEnum<{
+            approved: "approved";
+            concerns: "concerns";
+            changes_required: "changes_required";
+            annotated: "annotated";
+            error: "error";
+            skipped: "skipped";
+            not_applicable: "not_applicable";
+        }>>;
+        roundsUsed: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    quality_review: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"quality_review">;
+        verdict: z.ZodNullable<z.ZodEnum<{
+            approved: "approved";
+            concerns: "concerns";
+            changes_required: "changes_required";
+            annotated: "annotated";
+            error: "error";
+            skipped: "skipped";
+            not_applicable: "not_applicable";
+        }>>;
+        roundsUsed: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+    diff_review: z.ZodObject<{
+        entered: z.ZodBoolean;
+        durationMs: z.ZodNullable<z.ZodNumber>;
+        costUSD: z.ZodNullable<z.ZodNumber>;
+        agentTier: z.ZodNullable<z.ZodEnum<{
+            standard: "standard";
+            complex: "complex";
+        }>>;
+        modelFamily: z.ZodNullable<z.ZodString>;
+        model: z.ZodNullable<z.ZodString>;
+        maxIdleMs: z.ZodNullable<z.ZodNumber>;
+        totalIdleMs: z.ZodNullable<z.ZodNumber>;
+        activityEvents: z.ZodNullable<z.ZodNumber>;
+        stage: z.ZodLiteral<"diff_review">;
+        verdict: z.ZodNullable<z.ZodEnum<{
+            approved: "approved";
+            concerns: "concerns";
+            changes_required: "changes_required";
+            annotated: "annotated";
+            error: "error";
+            skipped: "skipped";
+            not_applicable: "not_applicable";
+        }>>;
+        roundsUsed: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const TaskCompletedLocalEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"task_completed">;
+    status: z.ZodString;
+    workerStatus: z.ZodNullable<z.ZodString>;
+    turns: z.ZodNumber;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    filesRead: z.ZodNumber;
+    filesWritten: z.ZodNumber;
+    toolCalls: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cachedReadTokens: z.ZodNumber;
+    cachedNonReadTokens: z.ZodNumber;
+    costUSD: z.ZodNullable<z.ZodNumber>;
+    taskMaxIdleMs: z.ZodNullable<z.ZodNumber>;
+    stallTriggered: z.ZodBoolean;
+    stages: z.ZodString;
+}, z.core.$loose>;
+export declare const WorkerStartEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"worker_start">;
+    model: z.ZodString;
+    providerType: z.ZodEnum<{
+        claude: "claude";
+        "claude-compatible": "claude-compatible";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        codex: "codex";
+    }>;
+    tier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+}, z.core.$strict>;
+export declare const TurnStartEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"turn_start">;
+    turnIndex: z.ZodNumber;
+    providerType: z.ZodEnum<{
+        claude: "claude";
+        "claude-compatible": "claude-compatible";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        codex: "codex";
+    }>;
+    model: z.ZodString;
+}, z.core.$strict>;
+export declare const TurnCompleteEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"turn_complete">;
+    turnIndex: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cachedReadTokens: z.ZodNumber;
+    cachedNonReadTokens: z.ZodNumber;
+    costUSD: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    providerType: z.ZodEnum<{
+        claude: "claude";
+        "claude-compatible": "claude-compatible";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        codex: "codex";
+    }>;
+    model: z.ZodString;
+}, z.core.$strict>;
+export declare const ToolCallEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"tool_call">;
+    tool: z.ZodString;
+    turnIndex: z.ZodNumber;
+}, z.core.$strict>;
+export declare const TextEmissionEvent: z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"text_emission">;
+    chars: z.ZodNumber;
+    turnIndex: z.ZodNumber;
+}, z.core.$strict>;
+export { TaskCompletedCloudEvent, SessionStartedCloudEvent, InstallChangedCloudEvent, SkillInstalledCloudEvent, CLOUD_EVENT_NAMES, } from './cloud-events.js';
+export declare const Event: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"task_started">;
+    route: z.ZodEnum<{
+        review: "review";
+        retry: "retry";
+        delegate: "delegate";
+        audit: "audit";
+        verify: "verify";
+        debug: "debug";
+        "execute-plan": "execute-plan";
+        investigate: "investigate";
+        explore: "explore";
+        explore_internal: "explore_internal";
+        explore_external: "explore_external";
+        explore_synthesize: "explore_synthesize";
+        "register-context-block": "register-context-block";
+    }>;
+    cwd: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"stage_change">;
+    from: z.ZodString;
+    to: z.ZodString;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    attemptCap: z.ZodOptional<z.ZodNumber>;
+    implTier: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>>;
+    reviewerTier: z.ZodOptional<z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>>;
+    escalated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"heartbeat">;
+    elapsed: z.ZodString;
+    stage: z.ZodString;
+    round: z.ZodOptional<z.ZodNumber>;
+    cap: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodNumber;
+    read: z.ZodNumber;
+    wrote: z.ZodNumber;
+    text: z.ZodNumber;
+    cost: z.ZodNullable<z.ZodNumber>;
+    idle_ms: z.ZodNumber;
+    stage_idle_ms: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"fallback">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        specReviewer: "specReviewer";
+        qualityReviewer: "qualityReviewer";
+        diffReviewer: "diffReviewer";
+    }>;
+    assignedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    usedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reason: z.ZodEnum<{
+        transport_failure: "transport_failure";
+        not_configured: "not_configured";
+    }>;
+    triggeringStatus: z.ZodOptional<z.ZodEnum<{
+        provider_transport_failure: "provider_transport_failure";
+        error: "error";
+        ok: "ok";
+        incomplete: "incomplete";
+        timeout: "timeout";
+        api_aborted: "api_aborted";
+        api_error: "api_error";
+        brief_too_vague: "brief_too_vague";
+        cost_exceeded: "cost_exceeded";
+        unavailable: "unavailable";
+    }>>;
+    violatesSeparation: z.ZodBoolean;
+    fallbackSeparationRespected: z.ZodOptional<z.ZodBoolean>;
+    assignedIdentity: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        providerType: z.ZodString;
+        normalizedEndpoint: z.ZodString;
+        modelId: z.ZodString;
+    }, z.core.$strip>>>;
+    usedIdentity: z.ZodNullable<z.ZodOptional<z.ZodObject<{
+        providerType: z.ZodString;
+        normalizedEndpoint: z.ZodString;
+        modelId: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"fallback_unavailable">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        specReviewer: "specReviewer";
+        qualityReviewer: "qualityReviewer";
+        diffReviewer: "diffReviewer";
+    }>;
+    assignedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reason: z.ZodEnum<{
+        transport_failure: "transport_failure";
+        not_configured: "not_configured";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"escalation">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    baseTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    implTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reviewerTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"escalation_unavailable">;
+    loop: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    attempt: z.ZodNumber;
+    role: z.ZodEnum<{
+        implementer: "implementer";
+        specReviewer: "specReviewer";
+        qualityReviewer: "qualityReviewer";
+        diffReviewer: "diffReviewer";
+    }>;
+    wantedTier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    reason: z.ZodEnum<{
+        transport_failure: "transport_failure";
+        not_configured: "not_configured";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"review_decision">;
+    stage: z.ZodEnum<{
+        spec: "spec";
+        quality: "quality";
+        diff: "diff";
+    }>;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        concerns: "concerns";
+        changes_required: "changes_required";
+        annotated: "annotated";
+        error: "error";
+        skipped: "skipped";
+        not_applicable: "not_applicable";
+    }>;
+    round: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"verify_step">;
+    command: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        passed: "passed";
+        failed: "failed";
+    }>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    signal: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodNumber;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"verify_skipped">;
+    reason: z.ZodEnum<{
+        other: "other";
+        not_applicable: "not_applicable";
+        no_command: "no_command";
+        dirty_worktree: "dirty_worktree";
+    }>;
+    stage: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"read_only_review.quality">;
+    route: z.ZodString;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        concerns: "concerns";
+        changes_required: "changes_required";
+        annotated: "annotated";
+        error: "error";
+        skipped: "skipped";
+        not_applicable: "not_applicable";
+    }>;
+    iterationIndex: z.ZodNumber;
+    findingsReviewed: z.ZodNumber;
+    meanConfidence: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNumber;
+    costUSD: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"read_only_review.terminal">;
+    route: z.ZodString;
+    roundsUsed: z.ZodNumber;
+    finalQualityVerdict: z.ZodEnum<{
+        approved: "approved";
+        concerns: "concerns";
+        changes_required: "changes_required";
+        annotated: "annotated";
+        error: "error";
+        skipped: "skipped";
+        not_applicable: "not_applicable";
+    }>;
+    costUSD: z.ZodNullable<z.ZodNumber>;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"stall_abort">;
+    idle_ms: z.ZodNumber;
+    threshold_ms: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"time_check">;
+    stage: z.ZodString;
+    tripped: z.ZodBoolean;
+    wallClockMs: z.ZodNumber;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"cost_check">;
+    stage: z.ZodString;
+    tripped: z.ZodBoolean;
+    cost_used_usd: z.ZodNumber;
+    cost_cap_usd: z.ZodNumber;
+    cost_available: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"batch_completed">;
+    tool: z.ZodString;
+    durationMs: z.ZodNumber;
+    taskCount: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"batch_failed">;
+    tool: z.ZodString;
+    durationMs: z.ZodNumber;
+    errorCode: z.ZodString;
+    errorMessage: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"task_completed">;
+    status: z.ZodString;
+    workerStatus: z.ZodNullable<z.ZodString>;
+    turns: z.ZodNumber;
+    durationMs: z.ZodNullable<z.ZodNumber>;
+    filesRead: z.ZodNumber;
+    filesWritten: z.ZodNumber;
+    toolCalls: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cachedReadTokens: z.ZodNumber;
+    cachedNonReadTokens: z.ZodNumber;
+    costUSD: z.ZodNullable<z.ZodNumber>;
+    taskMaxIdleMs: z.ZodNullable<z.ZodNumber>;
+    stallTriggered: z.ZodBoolean;
+    stages: z.ZodString;
+}, z.core.$loose>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_parallel_start">;
+    internalRoute: z.ZodString;
+    externalRoute: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_parallel_end">;
+    internalOk: z.ZodBoolean;
+    externalOk: z.ZodBoolean;
+    internalDurationMs: z.ZodNumber;
+    externalDurationMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_internal_unavailable">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_external_unavailable">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_synthesize_start">;
+    internalAvailable: z.ZodBoolean;
+    externalAvailable: z.ZodBoolean;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_synthesize_end">;
+    threadCount: z.ZodNumber;
+    recommendedNextStep: z.ZodBoolean;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_thread_started">;
+    threadIndex: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    event: z.ZodLiteral<"explore_thread_completed">;
+    threadIndex: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"worker_start">;
+    model: z.ZodString;
+    providerType: z.ZodEnum<{
+        claude: "claude";
+        "claude-compatible": "claude-compatible";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        codex: "codex";
+    }>;
+    tier: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"turn_start">;
+    turnIndex: z.ZodNumber;
+    providerType: z.ZodEnum<{
+        claude: "claude";
+        "claude-compatible": "claude-compatible";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        codex: "codex";
+    }>;
+    model: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"turn_complete">;
+    turnIndex: z.ZodNumber;
+    inputTokens: z.ZodNumber;
+    outputTokens: z.ZodNumber;
+    cachedReadTokens: z.ZodNumber;
+    cachedNonReadTokens: z.ZodNumber;
+    costUSD: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    providerType: z.ZodEnum<{
+        claude: "claude";
+        "claude-compatible": "claude-compatible";
+        openai: "openai";
+        "openai-compatible": "openai-compatible";
+        codex: "codex";
+    }>;
+    model: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"tool_call">;
+    tool: z.ZodString;
+    turnIndex: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    ts: z.ZodString;
+    batchId: z.ZodString;
+    taskIndex: z.ZodNumber;
+    event: z.ZodLiteral<"text_emission">;
+    chars: z.ZodNumber;
+    turnIndex: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    event: z.ZodLiteral<"task.completed">;
+    ts: z.ZodString;
+    route: z.ZodEnum<{
+        review: "review";
+        retry: "retry";
+        delegate: "delegate";
+        audit: "audit";
+        verify: "verify";
+        debug: "debug";
+        "execute-plan": "execute-plan";
+        investigate: "investigate";
+        explore: "explore";
+        explore_internal: "explore_internal";
+        explore_external: "explore_external";
+        explore_synthesize: "explore_synthesize";
+        "register-context-block": "register-context-block";
+    }>;
+    agentType: z.ZodEnum<{
+        standard: "standard";
+        complex: "complex";
+    }>;
+    toolMode: z.ZodEnum<{
+        full: "full";
+        none: "none";
+        readonly: "readonly";
+        "no-shell": "no-shell";
+    }>;
+    triggeredFromSkill: z.ZodString;
+    client: z.ZodString;
+    fileCountBucket: z.ZodEnum<{
+        0: "0";
+        "1-5": "1-5";
+        "6-20": "6-20";
+        "21-50": "21-50";
+        "51+": "51+";
+    }>;
+    durationBucket: z.ZodEnum<{
+        "<10s": "<10s";
+        "10s-1m": "10s-1m";
+        "1m-5m": "1m-5m";
+        "5m-30m": "5m-30m";
+        "30m+": "30m+";
+    }>;
+    costBucket: z.ZodEnum<{
+        $0: "$0";
+        "<$0.01": "<$0.01";
+        "$0.01-$0.10": "$0.01-$0.10";
+        "$0.10-$1": "$0.10-$1";
+        "$1+": "$1+";
+    }>;
+    savedCostBucket: z.ZodEnum<{
+        unknown: "unknown";
+        $0: "$0";
+        "$0.10-$1": "$0.10-$1";
+        "$1+": "$1+";
+        "<$0.10": "<$0.10";
+    }>;
+    implementerModelFamily: z.ZodString;
+    implementerModel: z.ZodString;
+    terminalStatus: z.ZodEnum<{
+        error: "error";
+        ok: "ok";
+        incomplete: "incomplete";
+        timeout: "timeout";
+        brief_too_vague: "brief_too_vague";
+        cost_exceeded: "cost_exceeded";
+        unavailable: "unavailable";
+    }>;
+    workerStatus: z.ZodEnum<{
+        failed: "failed";
+        done: "done";
+        done_with_concerns: "done_with_concerns";
+        needs_context: "needs_context";
+        blocked: "blocked";
+        review_loop_capped: "review_loop_capped";
+    }>;
+    errorCode: z.ZodNullable<z.ZodString>;
+    escalated: z.ZodBoolean;
+    fallbackTriggered: z.ZodBoolean;
+    topToolNames: z.ZodArray<z.ZodString>;
+    stages: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$loose>, z.ZodObject<{
+    event: z.ZodLiteral<"session.started">;
+    ts: z.ZodString;
+    configFlavor: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    providersConfigured: z.ZodArray<z.ZodEnum<{
+        claude: "claude";
+        "openai-compatible": "openai-compatible";
+        codex: "codex";
+    }>>;
+}, z.core.$loose>, z.ZodObject<{
+    event: z.ZodLiteral<"install.changed">;
+    ts: z.ZodString;
+    fromVersion: z.ZodNullable<z.ZodString>;
+    toVersion: z.ZodString;
+    trigger: z.ZodEnum<{
+        fresh_install: "fresh_install";
+        upgrade: "upgrade";
+        downgrade: "downgrade";
+    }>;
+}, z.core.$loose>, z.ZodObject<{
+    event: z.ZodLiteral<"skill.installed">;
+    ts: z.ZodString;
+    skill: z.ZodString;
+    client: z.ZodString;
+}, z.core.$loose>], "event">;
+export type EventType = z.infer<typeof Event>;
+/**
+ * Map from event discriminator to its full-envelope Zod schema.
+ *
+ * Each schema validates the **complete persisted envelope** (including the
+ * `event: <name>` discriminator field), not just the caller-supplied payload.
+ * This makes one schema authoritative for both emit and ingest.
+ *
+ * Used by the telemetry coverage invariant test and by the emit-time
+ * validator (NODE_ENV=test|development).
+ */
+export declare const EventSchemas: Record<string, z.ZodType>;
+//# sourceMappingURL=observability-events.d.ts.map