@canhta/dsh-autopilot 0.1.0-alpha.1

package/lib/client-types/web/contract.d.ts

@@ -0,0 +1,958 @@
+import { z } from 'zod';
+export declare const runLifecycleSchema: z.ZodEnum<{
+    blocked: "blocked";
+    cancelled: "cancelled";
+    completed: "completed";
+    failed: "failed";
+    implementing: "implementing";
+    paused: "paused";
+    pausing: "pausing";
+    publishing: "publishing";
+    queued: "queued";
+}>;
+export type RunLifecycle = z.infer<typeof runLifecycleSchema>;
+export declare const operationsQuerySchema: z.ZodObject<{
+    offset: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    search: z.ZodOptional<z.ZodString>;
+    states: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        implementing: "implementing";
+        paused: "paused";
+        pausing: "pausing";
+        publishing: "publishing";
+        queued: "queued";
+    }>>>;
+    attentionOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type OperationsQuery = z.infer<typeof operationsQuerySchema>;
+export declare const providerViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    displayName: z.ZodString;
+    configurationNamespace: z.ZodString;
+    selected: z.ZodBoolean;
+    availability: z.ZodEnum<{
+        available: "available";
+        unavailable: "unavailable";
+    }>;
+    setup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        mcpServerName: z.ZodString;
+        resources: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>;
+        credentialRefs: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            ref: z.ZodString;
+        }, z.core.$strip>>;
+        lookup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strip>;
+export type ProviderView = z.infer<typeof providerViewSchema>;
+export declare const providerSetupViewSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+    mcpServerName: z.ZodString;
+    resources: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>>;
+    credentialRefs: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        ref: z.ZodString;
+    }, z.core.$strip>>;
+    lookup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+    reason: z.ZodString;
+}, z.core.$strip>], "status">;
+export type ProviderSetupView = z.infer<typeof providerSetupViewSchema>;
+export declare const usageViewSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"known">;
+    settled: z.ZodNumber;
+    reserved: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"unknown">;
+    reason: z.ZodString;
+}, z.core.$strip>]>;
+export type UsageView = z.infer<typeof usageViewSchema>;
+export declare const externalReferenceSchema: z.ZodUnion<readonly [z.ZodObject<{
+    status: z.ZodLiteral<"available">;
+    url: z.ZodString;
+    label: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    status: z.ZodLiteral<"unknown">;
+    reason: z.ZodString;
+}, z.core.$strip>]>;
+export type ExternalReferenceView = z.infer<typeof externalReferenceSchema>;
+export declare const worktreeViewSchema: z.ZodObject<{
+    path: z.ZodString;
+    branch: z.ZodString;
+    head: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        "cleanup-eligible": "cleanup-eligible";
+        missing: "missing";
+        retained: "retained";
+        unknown: "unknown";
+        unsafe: "unsafe";
+    }>;
+    dirty: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"known">;
+        value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    untracked: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"known">;
+        value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    unpushed: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"known">;
+        value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    pullRequestDisposition: z.ZodEnum<{
+        "closed-unmerged": "closed-unmerged";
+        merged: "merged";
+        open: "open";
+        unknown: "unknown";
+    }>;
+    cleanup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        eligible: z.ZodBoolean;
+        rejections: z.ZodArray<z.ZodEnum<{
+            "dirty-files": "dirty-files";
+            "external-intent-unresolved": "external-intent-unresolved";
+            "ownership-unproven": "ownership-unproven";
+            "pr-closed-unmerged": "pr-closed-unmerged";
+            "pr-open": "pr-open";
+            "pr-unknown": "pr-unknown";
+            "recovery-required": "recovery-required";
+            "retention-not-met": "retention-not-met";
+            "run-active": "run-active";
+            "run-blocked": "run-blocked";
+            "run-failed": "run-failed";
+            "run-paused": "run-paused";
+            "run-publishing": "run-publishing";
+            "unpushed-commits": "unpushed-commits";
+            "untracked-files": "untracked-files";
+            "worktree-missing": "worktree-missing";
+        }>>;
+        removableBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unknown">]>;
+        retentionReference: z.ZodOptional<z.ZodString>;
+        retentionEligibleAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+}, z.core.$strip>;
+export type WorktreeView = z.infer<typeof worktreeViewSchema>;
+export declare const cleanupPreviewViewSchema: z.ZodObject<{
+    path: z.ZodString;
+    branch: z.ZodString;
+    head: z.ZodOptional<z.ZodString>;
+    state: z.ZodEnum<{
+        active: "active";
+        "cleanup-eligible": "cleanup-eligible";
+        missing: "missing";
+        retained: "retained";
+        unknown: "unknown";
+        unsafe: "unsafe";
+    }>;
+    dirty: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"known">;
+        value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    untracked: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"known">;
+        value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    unpushed: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"known">;
+        value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    pullRequestDisposition: z.ZodEnum<{
+        "closed-unmerged": "closed-unmerged";
+        merged: "merged";
+        open: "open";
+        unknown: "unknown";
+    }>;
+    cleanup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        eligible: z.ZodBoolean;
+        rejections: z.ZodArray<z.ZodEnum<{
+            "dirty-files": "dirty-files";
+            "external-intent-unresolved": "external-intent-unresolved";
+            "ownership-unproven": "ownership-unproven";
+            "pr-closed-unmerged": "pr-closed-unmerged";
+            "pr-open": "pr-open";
+            "pr-unknown": "pr-unknown";
+            "recovery-required": "recovery-required";
+            "retention-not-met": "retention-not-met";
+            "run-active": "run-active";
+            "run-blocked": "run-blocked";
+            "run-failed": "run-failed";
+            "run-paused": "run-paused";
+            "run-publishing": "run-publishing";
+            "unpushed-commits": "unpushed-commits";
+            "untracked-files": "untracked-files";
+            "worktree-missing": "worktree-missing";
+        }>>;
+        removableBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unknown">]>;
+        retentionReference: z.ZodOptional<z.ZodString>;
+        retentionEligibleAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unavailable">;
+        reason: z.ZodString;
+    }, z.core.$strip>], "status">;
+    previewId: z.ZodString;
+}, z.core.$strip>;
+export type CleanupPreviewView = z.infer<typeof cleanupPreviewViewSchema>;
+export declare const deliveryViewSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        notification: "notification";
+        "tracker-projection": "tracker-projection";
+        "tracker-report": "tracker-report";
+    }>;
+    providerId: z.ZodString;
+    destination: z.ZodString;
+    status: z.ZodEnum<{
+        exhausted: "exhausted";
+        "in-flight": "in-flight";
+        pending: "pending";
+        "permanent-failure": "permanent-failure";
+        retired: "retired";
+        "retryable-failure": "retryable-failure";
+        succeeded: "succeeded";
+        uncertain: "uncertain";
+    }>;
+    attempts: z.ZodNumber;
+    nextRetryAt: z.ZodOptional<z.ZodString>;
+    receivedAt: z.ZodOptional<z.ZodString>;
+    lastError: z.ZodOptional<z.ZodString>;
+    retryable: z.ZodBoolean;
+}, z.core.$strip>;
+export type DeliveryView = z.infer<typeof deliveryViewSchema>;
+export declare const timelineEntrySchema: z.ZodObject<{
+    at: z.ZodString;
+    label: z.ZodString;
+    detail: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TimelineEntryView = z.infer<typeof timelineEntrySchema>;
+export declare const runSummarySchema: z.ZodObject<{
+    runId: z.ZodString;
+    displayKey: z.ZodString;
+    summary: z.ZodString;
+    providerId: z.ZodString;
+    providerName: z.ZodString;
+    lifecycle: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        implementing: "implementing";
+        paused: "paused";
+        pausing: "pausing";
+        publishing: "publishing";
+        queued: "queued";
+    }>;
+    reason: z.ZodString;
+    priorityRank: z.ZodNumber;
+    phase: z.ZodString;
+    queuedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    attention: z.ZodBoolean;
+    usage: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"known">;
+        settled: z.ZodNumber;
+        reserved: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    ticket: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        url: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    session: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        url: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    pullRequest: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        url: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    deliveries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            notification: "notification";
+            "tracker-projection": "tracker-projection";
+            "tracker-report": "tracker-report";
+        }>;
+        providerId: z.ZodString;
+        destination: z.ZodString;
+        status: z.ZodEnum<{
+            exhausted: "exhausted";
+            "in-flight": "in-flight";
+            pending: "pending";
+            "permanent-failure": "permanent-failure";
+            retired: "retired";
+            "retryable-failure": "retryable-failure";
+            succeeded: "succeeded";
+            uncertain: "uncertain";
+        }>;
+        attempts: z.ZodNumber;
+        nextRetryAt: z.ZodOptional<z.ZodString>;
+        receivedAt: z.ZodOptional<z.ZodString>;
+        lastError: z.ZodOptional<z.ZodString>;
+        retryable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    actions: z.ZodArray<z.ZodEnum<{
+        "cancel-run": "cancel-run";
+        "pause-run": "pause-run";
+        "resume-run": "resume-run";
+    }>>;
+    worktree: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        branch: z.ZodString;
+        head: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<{
+            active: "active";
+            "cleanup-eligible": "cleanup-eligible";
+            missing: "missing";
+            retained: "retained";
+            unknown: "unknown";
+            unsafe: "unsafe";
+        }>;
+        dirty: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"known">;
+            value: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strip>]>;
+        untracked: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"known">;
+            value: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strip>]>;
+        unpushed: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"known">;
+            value: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strip>]>;
+        pullRequestDisposition: z.ZodEnum<{
+            "closed-unmerged": "closed-unmerged";
+            merged: "merged";
+            open: "open";
+            unknown: "unknown";
+        }>;
+        cleanup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            eligible: z.ZodBoolean;
+            rejections: z.ZodArray<z.ZodEnum<{
+                "dirty-files": "dirty-files";
+                "external-intent-unresolved": "external-intent-unresolved";
+                "ownership-unproven": "ownership-unproven";
+                "pr-closed-unmerged": "pr-closed-unmerged";
+                "pr-open": "pr-open";
+                "pr-unknown": "pr-unknown";
+                "recovery-required": "recovery-required";
+                "retention-not-met": "retention-not-met";
+                "run-active": "run-active";
+                "run-blocked": "run-blocked";
+                "run-failed": "run-failed";
+                "run-paused": "run-paused";
+                "run-publishing": "run-publishing";
+                "unpushed-commits": "unpushed-commits";
+                "untracked-files": "untracked-files";
+                "worktree-missing": "worktree-missing";
+            }>>;
+            removableBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unknown">]>;
+            retentionReference: z.ZodOptional<z.ZodString>;
+            retentionEligibleAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunSummaryView = z.infer<typeof runSummarySchema>;
+export declare const runDetailSchema: z.ZodObject<{
+    runId: z.ZodString;
+    displayKey: z.ZodString;
+    summary: z.ZodString;
+    providerId: z.ZodString;
+    providerName: z.ZodString;
+    lifecycle: z.ZodEnum<{
+        blocked: "blocked";
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        implementing: "implementing";
+        paused: "paused";
+        pausing: "pausing";
+        publishing: "publishing";
+        queued: "queued";
+    }>;
+    reason: z.ZodString;
+    priorityRank: z.ZodNumber;
+    phase: z.ZodString;
+    queuedAt: z.ZodString;
+    updatedAt: z.ZodString;
+    attention: z.ZodBoolean;
+    usage: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"known">;
+        settled: z.ZodNumber;
+        reserved: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    ticket: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        url: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    session: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        url: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    pullRequest: z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodLiteral<"available">;
+        url: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        reason: z.ZodString;
+    }, z.core.$strip>]>;
+    deliveries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            notification: "notification";
+            "tracker-projection": "tracker-projection";
+            "tracker-report": "tracker-report";
+        }>;
+        providerId: z.ZodString;
+        destination: z.ZodString;
+        status: z.ZodEnum<{
+            exhausted: "exhausted";
+            "in-flight": "in-flight";
+            pending: "pending";
+            "permanent-failure": "permanent-failure";
+            retired: "retired";
+            "retryable-failure": "retryable-failure";
+            succeeded: "succeeded";
+            uncertain: "uncertain";
+        }>;
+        attempts: z.ZodNumber;
+        nextRetryAt: z.ZodOptional<z.ZodString>;
+        receivedAt: z.ZodOptional<z.ZodString>;
+        lastError: z.ZodOptional<z.ZodString>;
+        retryable: z.ZodBoolean;
+    }, z.core.$strip>>;
+    actions: z.ZodArray<z.ZodEnum<{
+        "cancel-run": "cancel-run";
+        "pause-run": "pause-run";
+        "resume-run": "resume-run";
+    }>>;
+    worktree: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        branch: z.ZodString;
+        head: z.ZodOptional<z.ZodString>;
+        state: z.ZodEnum<{
+            active: "active";
+            "cleanup-eligible": "cleanup-eligible";
+            missing: "missing";
+            retained: "retained";
+            unknown: "unknown";
+            unsafe: "unsafe";
+        }>;
+        dirty: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"known">;
+            value: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strip>]>;
+        untracked: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"known">;
+            value: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strip>]>;
+        unpushed: z.ZodUnion<readonly [z.ZodObject<{
+            status: z.ZodLiteral<"known">;
+            value: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unknown">;
+            reason: z.ZodString;
+        }, z.core.$strip>]>;
+        pullRequestDisposition: z.ZodEnum<{
+            "closed-unmerged": "closed-unmerged";
+            merged: "merged";
+            open: "open";
+            unknown: "unknown";
+        }>;
+        cleanup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            eligible: z.ZodBoolean;
+            rejections: z.ZodArray<z.ZodEnum<{
+                "dirty-files": "dirty-files";
+                "external-intent-unresolved": "external-intent-unresolved";
+                "ownership-unproven": "ownership-unproven";
+                "pr-closed-unmerged": "pr-closed-unmerged";
+                "pr-open": "pr-open";
+                "pr-unknown": "pr-unknown";
+                "recovery-required": "recovery-required";
+                "retention-not-met": "retention-not-met";
+                "run-active": "run-active";
+                "run-blocked": "run-blocked";
+                "run-failed": "run-failed";
+                "run-paused": "run-paused";
+                "run-publishing": "run-publishing";
+                "unpushed-commits": "unpushed-commits";
+                "untracked-files": "untracked-files";
+                "worktree-missing": "worktree-missing";
+            }>>;
+            removableBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unknown">]>;
+            retentionReference: z.ZodOptional<z.ZodString>;
+            retentionEligibleAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strip>>;
+    brief: z.ZodObject<{
+        updatedAt: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+    outcome: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            blocked: "blocked";
+            failed: "failed";
+            verified: "verified";
+        }>;
+        summary: z.ZodString;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    timeline: z.ZodArray<z.ZodObject<{
+        at: z.ZodString;
+        label: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunDetailView = z.infer<typeof runDetailSchema>;
+export declare const commandKindSchema: z.ZodEnum<{
+    "cancel-run": "cancel-run";
+    drain: "drain";
+    "pause-run": "pause-run";
+    "pause-scheduler": "pause-scheduler";
+    reconcile: "reconcile";
+    "remove-worktree": "remove-worktree";
+    "resume-run": "resume-run";
+    "resume-scheduler": "resume-scheduler";
+    "retry-delivery": "retry-delivery";
+}>;
+export type CommandKind = z.infer<typeof commandKindSchema>;
+export declare const commandRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    kind: z.ZodEnum<{
+        "cancel-run": "cancel-run";
+        drain: "drain";
+        "pause-run": "pause-run";
+        "pause-scheduler": "pause-scheduler";
+        reconcile: "reconcile";
+        "remove-worktree": "remove-worktree";
+        "resume-run": "resume-run";
+        "resume-scheduler": "resume-scheduler";
+        "retry-delivery": "retry-delivery";
+    }>;
+    runId: z.ZodOptional<z.ZodString>;
+    deliveryId: z.ZodOptional<z.ZodString>;
+    previewId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CommandRequest = z.infer<typeof commandRequestSchema>;
+export declare const commandReceiptSchema: z.ZodObject<{
+    requestId: z.ZodString;
+    kind: z.ZodEnum<{
+        "cancel-run": "cancel-run";
+        drain: "drain";
+        "pause-run": "pause-run";
+        "pause-scheduler": "pause-scheduler";
+        reconcile: "reconcile";
+        "remove-worktree": "remove-worktree";
+        "resume-run": "resume-run";
+        "resume-scheduler": "resume-scheduler";
+        "retry-delivery": "retry-delivery";
+    }>;
+    status: z.ZodEnum<{
+        accepted: "accepted";
+        "in-progress": "in-progress";
+        rejected: "rejected";
+        succeeded: "succeeded";
+    }>;
+    acceptedAt: z.ZodString;
+    finishedAt: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    revision: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type CommandReceipt = z.infer<typeof commandReceiptSchema>;
+export declare const reconciliationViewSchema: z.ZodObject<{
+    active: z.ZodNumber;
+    nextScheduledAt: z.ZodOptional<z.ZodString>;
+    lastAttempt: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            manual: "manual";
+            scheduled: "scheduled";
+            startup: "startup";
+            webhook: "webhook";
+        }>;
+        completedAt: z.ZodString;
+        outcome: z.ZodEnum<{
+            failed: "failed";
+            succeeded: "succeeded";
+        }>;
+        admitted: z.ZodNumber;
+        failure: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ReconciliationView = z.infer<typeof reconciliationViewSchema>;
+export declare const operationsSnapshotSchema: z.ZodObject<{
+    revision: z.ZodNumber;
+    fetchedAt: z.ZodString;
+    scheduler: z.ZodObject<{
+        mode: z.ZodEnum<{
+            disabled: "disabled";
+            draining: "draining";
+            enabled: "enabled";
+        }>;
+        changedAt: z.ZodString;
+    }, z.core.$strip>;
+    providers: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        displayName: z.ZodString;
+        configurationNamespace: z.ZodString;
+        selected: z.ZodBoolean;
+        availability: z.ZodEnum<{
+            available: "available";
+            unavailable: "unavailable";
+        }>;
+        setup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+            mcpServerName: z.ZodString;
+            resources: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strip>>;
+            credentialRefs: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                ref: z.ZodString;
+            }, z.core.$strip>>;
+            lookup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unavailable">;
+                reason: z.ZodString;
+            }, z.core.$strip>], "status">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strip>>;
+    runs: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            runId: z.ZodString;
+            displayKey: z.ZodString;
+            summary: z.ZodString;
+            providerId: z.ZodString;
+            providerName: z.ZodString;
+            lifecycle: z.ZodEnum<{
+                blocked: "blocked";
+                cancelled: "cancelled";
+                completed: "completed";
+                failed: "failed";
+                implementing: "implementing";
+                paused: "paused";
+                pausing: "pausing";
+                publishing: "publishing";
+                queued: "queued";
+            }>;
+            reason: z.ZodString;
+            priorityRank: z.ZodNumber;
+            phase: z.ZodString;
+            queuedAt: z.ZodString;
+            updatedAt: z.ZodString;
+            attention: z.ZodBoolean;
+            usage: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"known">;
+                settled: z.ZodNumber;
+                reserved: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strip>]>;
+            ticket: z.ZodUnion<readonly [z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                url: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strip>]>;
+            session: z.ZodUnion<readonly [z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                url: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strip>]>;
+            pullRequest: z.ZodUnion<readonly [z.ZodObject<{
+                status: z.ZodLiteral<"available">;
+                url: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                status: z.ZodLiteral<"unknown">;
+                reason: z.ZodString;
+            }, z.core.$strip>]>;
+            deliveries: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    notification: "notification";
+                    "tracker-projection": "tracker-projection";
+                    "tracker-report": "tracker-report";
+                }>;
+                providerId: z.ZodString;
+                destination: z.ZodString;
+                status: z.ZodEnum<{
+                    exhausted: "exhausted";
+                    "in-flight": "in-flight";
+                    pending: "pending";
+                    "permanent-failure": "permanent-failure";
+                    retired: "retired";
+                    "retryable-failure": "retryable-failure";
+                    succeeded: "succeeded";
+                    uncertain: "uncertain";
+                }>;
+                attempts: z.ZodNumber;
+                nextRetryAt: z.ZodOptional<z.ZodString>;
+                receivedAt: z.ZodOptional<z.ZodString>;
+                lastError: z.ZodOptional<z.ZodString>;
+                retryable: z.ZodBoolean;
+            }, z.core.$strip>>;
+            actions: z.ZodArray<z.ZodEnum<{
+                "cancel-run": "cancel-run";
+                "pause-run": "pause-run";
+                "resume-run": "resume-run";
+            }>>;
+            worktree: z.ZodOptional<z.ZodObject<{
+                path: z.ZodString;
+                branch: z.ZodString;
+                head: z.ZodOptional<z.ZodString>;
+                state: z.ZodEnum<{
+                    active: "active";
+                    "cleanup-eligible": "cleanup-eligible";
+                    missing: "missing";
+                    retained: "retained";
+                    unknown: "unknown";
+                    unsafe: "unsafe";
+                }>;
+                dirty: z.ZodUnion<readonly [z.ZodObject<{
+                    status: z.ZodLiteral<"known">;
+                    value: z.ZodBoolean;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"unknown">;
+                    reason: z.ZodString;
+                }, z.core.$strip>]>;
+                untracked: z.ZodUnion<readonly [z.ZodObject<{
+                    status: z.ZodLiteral<"known">;
+                    value: z.ZodBoolean;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"unknown">;
+                    reason: z.ZodString;
+                }, z.core.$strip>]>;
+                unpushed: z.ZodUnion<readonly [z.ZodObject<{
+                    status: z.ZodLiteral<"known">;
+                    value: z.ZodBoolean;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"unknown">;
+                    reason: z.ZodString;
+                }, z.core.$strip>]>;
+                pullRequestDisposition: z.ZodEnum<{
+                    "closed-unmerged": "closed-unmerged";
+                    merged: "merged";
+                    open: "open";
+                    unknown: "unknown";
+                }>;
+                cleanup: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    status: z.ZodLiteral<"available">;
+                    eligible: z.ZodBoolean;
+                    rejections: z.ZodArray<z.ZodEnum<{
+                        "dirty-files": "dirty-files";
+                        "external-intent-unresolved": "external-intent-unresolved";
+                        "ownership-unproven": "ownership-unproven";
+                        "pr-closed-unmerged": "pr-closed-unmerged";
+                        "pr-open": "pr-open";
+                        "pr-unknown": "pr-unknown";
+                        "recovery-required": "recovery-required";
+                        "retention-not-met": "retention-not-met";
+                        "run-active": "run-active";
+                        "run-blocked": "run-blocked";
+                        "run-failed": "run-failed";
+                        "run-paused": "run-paused";
+                        "run-publishing": "run-publishing";
+                        "unpushed-commits": "unpushed-commits";
+                        "untracked-files": "untracked-files";
+                        "worktree-missing": "worktree-missing";
+                    }>>;
+                    removableBytes: z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"unknown">]>;
+                    retentionReference: z.ZodOptional<z.ZodString>;
+                    retentionEligibleAt: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>, z.ZodObject<{
+                    status: z.ZodLiteral<"unavailable">;
+                    reason: z.ZodString;
+                }, z.core.$strip>], "status">;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        total: z.ZodNumber;
+        offset: z.ZodNumber;
+        limit: z.ZodNumber;
+    }, z.core.$strip>;
+    budget: z.ZodObject<{
+        deploymentCap: z.ZodNumber;
+        settled: z.ZodNumber;
+        reserved: z.ZodNumber;
+        remaining: z.ZodNullable<z.ZodNumber>;
+        usageUncertain: z.ZodBoolean;
+    }, z.core.$strip>;
+    schedule: z.ZodObject<{
+        timezone: z.ZodString;
+        reconcileIntervalSeconds: z.ZodNumber;
+    }, z.core.$strip>;
+    reconciliation: z.ZodObject<{
+        active: z.ZodNumber;
+        nextScheduledAt: z.ZodOptional<z.ZodString>;
+        lastAttempt: z.ZodOptional<z.ZodObject<{
+            source: z.ZodEnum<{
+                manual: "manual";
+                scheduled: "scheduled";
+                startup: "startup";
+                webhook: "webhook";
+            }>;
+            completedAt: z.ZodString;
+            outcome: z.ZodEnum<{
+                failed: "failed";
+                succeeded: "succeeded";
+            }>;
+            admitted: z.ZodNumber;
+            failure: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    commands: z.ZodArray<z.ZodObject<{
+        requestId: z.ZodString;
+        kind: z.ZodEnum<{
+            "cancel-run": "cancel-run";
+            drain: "drain";
+            "pause-run": "pause-run";
+            "pause-scheduler": "pause-scheduler";
+            reconcile: "reconcile";
+            "remove-worktree": "remove-worktree";
+            "resume-run": "resume-run";
+            "resume-scheduler": "resume-scheduler";
+            "retry-delivery": "retry-delivery";
+        }>;
+        status: z.ZodEnum<{
+            accepted: "accepted";
+            "in-progress": "in-progress";
+            rejected: "rejected";
+            succeeded: "succeeded";
+        }>;
+        acceptedAt: z.ZodString;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    integrations: z.ZodObject<{
+        deliveries: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+        worktrees: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"available">;
+        }, z.core.$strip>, z.ZodObject<{
+            status: z.ZodLiteral<"unavailable">;
+            reason: z.ZodString;
+        }, z.core.$strip>], "status">;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OperationsSnapshot = z.infer<typeof operationsSnapshotSchema>;
+export declare const providerTestResultSchema: z.ZodObject<{
+    providerId: z.ZodString;
+    checkedAt: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        ready: "ready";
+    }>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ProviderTestResult = z.infer<typeof providerTestResultSchema>;