@open-mercato/cezar 0.9.1 → 0.9.2

package/dist/contract/events.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+/**
+ * SSE frame payloads — the only shapes in this contract that are NOT derived from a route.
+ *
+ * They are delivered over `text/event-stream` (`GET /api/v1/runs/:id/events`, `/api/v1/events`,
+ * `/api/v1/workspace/events`), which Hono types as a string body, so `InferResponseType` sees a
+ * stream of text and never the frame inside it. That makes the route-parity check in
+ * `contract-parity*.test.ts` inapplicable here — but it is no reason to hand-write the TYPE.
+ * These are zod like everything else, and `api-types.test.ts` still pins `RunEvent` against the
+ * server's own declaration, which is the closest thing to a route that exists for it.
+ */
+/**
+ * One line of a run transcript.
+ *
+ * Open by design: `type` is a plain string and unknown keys pass through, because the event
+ * vocabulary is an APPEND-ONLY on-disk format (BACKWARD_COMPATIBILITY.md §7) that old NDJSON
+ * recordings must keep replaying forever. Closing this schema would make a recording written by
+ * a newer cezar unreadable by an older one — the opposite of what the format promises.
+ */
+export declare const runEventSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    ts: z.ZodString;
+    stepId: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+}, z.core.$loose>;
+export type RunEvent = z.infer<typeof runEventSchema>;
+/**
+ * One `checkout-progress` workspace frame (multi-project spec, step 4.3).
+ *
+ * `cloning` carries a single line of `git clone` output; `done` and `error` are terminal. The
+ * clone dialog renders `error` VERBATIM — a clone fails for reasons (auth, network, a mistyped
+ * repo) that only the server can name.
+ */
+export declare const checkoutProgressEventSchema: z.ZodObject<{
+    checkoutId: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    phase: z.ZodEnum<{
+        cloning: "cloning";
+        done: "done";
+        error: "error";
+    }>;
+    line: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CheckoutProgressEvent = z.infer<typeof checkoutProgressEventSchema>;

package/dist/contract/github.d.ts

@@ -0,0 +1,467 @@
+import { z } from 'zod';
+/**
+ * One issue or pull request, flattened for the cockpit (`ForgeItem` server-side).
+ * A protected shape — BACKWARD_COMPATIBILITY.md §2 forbids reshaping it.
+ */
+export declare const githubItemSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        issue: "issue";
+        pr: "pr";
+    }>;
+    number: z.ZodNumber;
+    title: z.ZodString;
+    author: z.ZodString;
+    createdAt: z.ZodString;
+    labels: z.ZodArray<z.ZodString>;
+    body: z.ZodString;
+    url: z.ZodString;
+    comments: z.ZodNumber;
+    isDraft: z.ZodOptional<z.ZodBoolean>;
+    additions: z.ZodOptional<z.ZodNumber>;
+    deletions: z.ZodOptional<z.ZodNumber>;
+    checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+    }>>>;
+}, z.core.$strip>;
+export type GithubItem = z.infer<typeof githubItemSchema>;
+/**
+ * `GET /api/v1/github` — the tab's issue + PR lists.
+ *
+ * NOT a discriminated union, unlike its siblings: `fetchGithub` always answers the full record and
+ * merely flips `available`, so an unavailable payload still carries `issues: []` / `prs: []`.
+ */
+export declare const githubDataSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    syncedAt: z.ZodOptional<z.ZodString>;
+    issues: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            issue: "issue";
+            pr: "pr";
+        }>;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        author: z.ZodString;
+        createdAt: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        body: z.ZodString;
+        url: z.ZodString;
+        comments: z.ZodNumber;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
+        additions: z.ZodOptional<z.ZodNumber>;
+        deletions: z.ZodOptional<z.ZodNumber>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+    }, z.core.$strip>>;
+    prs: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            issue: "issue";
+            pr: "pr";
+        }>;
+        number: z.ZodNumber;
+        title: z.ZodString;
+        author: z.ZodString;
+        createdAt: z.ZodString;
+        labels: z.ZodArray<z.ZodString>;
+        body: z.ZodString;
+        url: z.ZodString;
+        comments: z.ZodNumber;
+        isDraft: z.ZodOptional<z.ZodBoolean>;
+        additions: z.ZodOptional<z.ZodNumber>;
+        deletions: z.ZodOptional<z.ZodNumber>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+    }, z.core.$strip>>;
+    labelColors: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type GithubData = z.infer<typeof githubDataSchema>;
+/**
+ * `GET /api/v1/github/checks?prs=…` (#664) — lazy PR checks glyphs, `number → glyph`. The list
+ * call no longer ships `statusCheckRollup`, so a row's glyph is hydrated here for the on-screen
+ * rows only. An absent number means "no checks / not found".
+ */
+export declare const githubChecksDataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    available: z.ZodLiteral<true>;
+    checks: z.ZodRecord<z.ZodNumber, z.ZodNullable<z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+    }>>>;
+}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, z.core.$strip>], "available">;
+export type GithubChecksData = z.infer<typeof githubChecksDataSchema>;
+/** One comment or PR review summary in an issue/PR thread (#499). */
+export declare const githubCommentSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    author: z.ZodString;
+    avatarUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    body: z.ZodString;
+    kind: z.ZodEnum<{
+        comment: "comment";
+        review: "review";
+    }>;
+    reviewState: z.ZodOptional<z.ZodEnum<{
+        approved: "approved";
+        changes_requested: "changes_requested";
+        commented: "commented";
+        dismissed: "dismissed";
+    }>>;
+    url: z.ZodString;
+}, z.core.$strip>;
+export type GithubComment = z.infer<typeof githubCommentSchema>;
+/**
+ * The timeline event kinds the thread renders (#525) — an allowlist, so an unknown GitHub event
+ * type is dropped server-side rather than reaching the client.
+ */
+export declare const githubTimelineEventKindSchema: z.ZodEnum<{
+    assigned: "assigned";
+    closed: "closed";
+    committed: "committed";
+    "cross-referenced": "cross-referenced";
+    head_ref_force_pushed: "head_ref_force_pushed";
+    labeled: "labeled";
+    merged: "merged";
+    renamed: "renamed";
+    reopened: "reopened";
+    unassigned: "unassigned";
+    unlabeled: "unlabeled";
+}>;
+export type GithubTimelineEventKind = z.infer<typeof githubTimelineEventKindSchema>;
+/**
+ * One non-comment timeline row (#525). Deliberately a separate shape from `GithubComment` rather
+ * than a widened `kind`, which would break the client's narrowing.
+ */
+export declare const githubTimelineEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        assigned: "assigned";
+        closed: "closed";
+        committed: "committed";
+        "cross-referenced": "cross-referenced";
+        head_ref_force_pushed: "head_ref_force_pushed";
+        labeled: "labeled";
+        merged: "merged";
+        renamed: "renamed";
+        reopened: "reopened";
+        unassigned: "unassigned";
+        unlabeled: "unlabeled";
+    }>;
+    actor: z.ZodString;
+    avatarUrl: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    sha: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+    checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+    }>>>;
+    label: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        color: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    subject: z.ZodOptional<z.ZodString>;
+    refNumber: z.ZodOptional<z.ZodNumber>;
+    refTitle: z.ZodOptional<z.ZodString>;
+    refIsPr: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GithubTimelineEvent = z.infer<typeof githubTimelineEventSchema>;
+/**
+ * `GET /api/v1/github/comments/:kind/:number` — the full thread. Degrades to
+ * `{ available: false, reason }` like the list fetch, never an error.
+ */
+export declare const githubCommentsDataSchema: z.ZodObject<{
+    available: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+    comments: z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        author: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        body: z.ZodString;
+        kind: z.ZodEnum<{
+            comment: "comment";
+            review: "review";
+        }>;
+        reviewState: z.ZodOptional<z.ZodEnum<{
+            approved: "approved";
+            changes_requested: "changes_requested";
+            commented: "commented";
+            dismissed: "dismissed";
+        }>>;
+        url: z.ZodString;
+    }, z.core.$strip>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+    events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            assigned: "assigned";
+            closed: "closed";
+            committed: "committed";
+            "cross-referenced": "cross-referenced";
+            head_ref_force_pushed: "head_ref_force_pushed";
+            labeled: "labeled";
+            merged: "merged";
+            renamed: "renamed";
+            reopened: "reopened";
+            unassigned: "unassigned";
+            unlabeled: "unlabeled";
+        }>;
+        actor: z.ZodString;
+        avatarUrl: z.ZodOptional<z.ZodString>;
+        createdAt: z.ZodString;
+        url: z.ZodOptional<z.ZodString>;
+        sha: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodString>;
+        checks: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+        }>>>;
+        label: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            color: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        subject: z.ZodOptional<z.ZodString>;
+        refNumber: z.ZodOptional<z.ZodNumber>;
+        refTitle: z.ZodOptional<z.ZodString>;
+        refIsPr: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GithubCommentsData = z.infer<typeof githubCommentsDataSchema>;
+export declare const githubMergeMethodSchema: z.ZodEnum<{
+    merge: "merge";
+    rebase: "rebase";
+    squash: "squash";
+}>;
+export type GithubMergeMethod = z.infer<typeof githubMergeMethodSchema>;
+/** One check row of the merge panel. */
+export declare const githubPrCheckSchema: z.ZodObject<{
+    name: z.ZodString;
+    state: z.ZodEnum<{
+        failing: "failing";
+        passing: "passing";
+        pending: "pending";
+        unknown: "unknown";
+    }>;
+    required: z.ZodNullable<z.ZodBoolean>;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GithubPrCheck = z.infer<typeof githubPrCheckSchema>;
+/** Everything the merge panel needs about one PR. */
+export declare const githubPrMergeStateSchema: z.ZodObject<{
+    number: z.ZodNumber;
+    title: z.ZodString;
+    url: z.ZodString;
+    state: z.ZodEnum<{
+        closed: "closed";
+        merged: "merged";
+        open: "open";
+    }>;
+    isDraft: z.ZodBoolean;
+    headRef: z.ZodString;
+    baseRef: z.ZodString;
+    headSha: z.ZodString;
+    mergeable: z.ZodEnum<{
+        conflicting: "conflicting";
+        mergeable: "mergeable";
+        unknown: "unknown";
+    }>;
+    reviewDecision: z.ZodEnum<{
+        approved: "approved";
+        "changes-requested": "changes-requested";
+        "review-required": "review-required";
+        unknown: "unknown";
+    }>;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        state: z.ZodEnum<{
+            failing: "failing";
+            passing: "passing";
+            pending: "pending";
+            unknown: "unknown";
+        }>;
+        required: z.ZodNullable<z.ZodBoolean>;
+        url: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    methods: z.ZodArray<z.ZodEnum<{
+        merge: "merge";
+        rebase: "rebase";
+        squash: "squash";
+    }>>;
+    defaultMethod: z.ZodNullable<z.ZodEnum<{
+        merge: "merge";
+        rebase: "rebase";
+        squash: "squash";
+    }>>;
+    eligibility: z.ZodEnum<{
+        blocked: "blocked";
+        pending: "pending";
+        ready: "ready";
+        terminal: "terminal";
+        unauthorized: "unauthorized";
+        unknown: "unknown";
+    }>;
+    blockers: z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>>;
+    canMerge: z.ZodBoolean;
+    canOverride: z.ZodBoolean;
+}, z.core.$strip>;
+export type GithubPrMergeState = z.infer<typeof githubPrMergeStateSchema>;
+/** `GET /api/v1/github/prs/:number/merge-state` — 200 either way; the reason is the degrade. */
+export declare const githubPrMergeStateResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    available: z.ZodLiteral<true>;
+    mergeState: z.ZodObject<{
+        number: z.ZodNumber;
+        title: z.ZodString;
+        url: z.ZodString;
+        state: z.ZodEnum<{
+            closed: "closed";
+            merged: "merged";
+            open: "open";
+        }>;
+        isDraft: z.ZodBoolean;
+        headRef: z.ZodString;
+        baseRef: z.ZodString;
+        headSha: z.ZodString;
+        mergeable: z.ZodEnum<{
+            conflicting: "conflicting";
+            mergeable: "mergeable";
+            unknown: "unknown";
+        }>;
+        reviewDecision: z.ZodEnum<{
+            approved: "approved";
+            "changes-requested": "changes-requested";
+            "review-required": "review-required";
+            unknown: "unknown";
+        }>;
+        checks: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            state: z.ZodEnum<{
+                failing: "failing";
+                passing: "passing";
+                pending: "pending";
+                unknown: "unknown";
+            }>;
+            required: z.ZodNullable<z.ZodBoolean>;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        methods: z.ZodArray<z.ZodEnum<{
+            merge: "merge";
+            rebase: "rebase";
+            squash: "squash";
+        }>>;
+        defaultMethod: z.ZodNullable<z.ZodEnum<{
+            merge: "merge";
+            rebase: "rebase";
+            squash: "squash";
+        }>>;
+        eligibility: z.ZodEnum<{
+            blocked: "blocked";
+            pending: "pending";
+            ready: "ready";
+            terminal: "terminal";
+            unauthorized: "unauthorized";
+            unknown: "unknown";
+        }>;
+        blockers: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strip>>;
+        canMerge: z.ZodBoolean;
+        canOverride: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, z.core.$strip>], "available">;
+export type GithubPrMergeStateResponse = z.infer<typeof githubPrMergeStateResponseSchema>;
+/**
+ * `POST /api/v1/github/prs/:number/merge` — the 200 branch only. Every refusal (403/404/409/502)
+ * is an `ApiError`, so `merged` is pinned to `true` here rather than a boolean to re-check.
+ */
+export declare const githubMergeResponseSchema: z.ZodObject<{
+    merged: z.ZodLiteral<true>;
+    number: z.ZodNumber;
+    url: z.ZodString;
+    method: z.ZodEnum<{
+        merge: "merge";
+        rebase: "rebase";
+        squash: "squash";
+    }>;
+    mergeCommitSha: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type GithubMergeResponse = z.infer<typeof githubMergeResponseSchema>;
+/** One changed file of a pull request's diff. */
+export declare const githubPrChangeSchema: z.ZodObject<{
+    path: z.ZodString;
+    previousPath: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        added: "added";
+        changed: "changed";
+        copied: "copied";
+        modified: "modified";
+        removed: "removed";
+        renamed: "renamed";
+    }>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    patch: z.ZodOptional<z.ZodString>;
+    patchUnavailableReason: z.ZodOptional<z.ZodEnum<{
+        binary: "binary";
+        "not-provided": "not-provided";
+        "too-large": "too-large";
+    }>>;
+    truncated: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GithubPrChange = z.infer<typeof githubPrChangeSchema>;
+/** `GET /api/v1/github/prs/:number/changes` — bounded, read-only PR file changes. */
+export declare const githubPrChangesDataSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    available: z.ZodLiteral<true>;
+    number: z.ZodNumber;
+    headSha: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        previousPath: z.ZodOptional<z.ZodString>;
+        status: z.ZodEnum<{
+            added: "added";
+            changed: "changed";
+            copied: "copied";
+            modified: "modified";
+            removed: "removed";
+            renamed: "renamed";
+        }>;
+        additions: z.ZodNumber;
+        deletions: z.ZodNumber;
+        patch: z.ZodOptional<z.ZodString>;
+        patchUnavailableReason: z.ZodOptional<z.ZodEnum<{
+            binary: "binary";
+            "not-provided": "not-provided";
+            "too-large": "too-large";
+        }>>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    additions: z.ZodNumber;
+    deletions: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    available: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, z.core.$strip>], "available">;
+export type GithubPrChangesData = z.infer<typeof githubPrChangesDataSchema>;

package/dist/contract/health.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+/** The three agent backends a run can be dispatched to. */
+export declare const runnerSchema: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    opencode: "opencode";
+}>;
+export type Runner = z.infer<typeof runnerSchema>;
+/** Git facts about the project root, or `null` when it is not a repository. */
+export declare const repoInfoSchema: z.ZodObject<{
+    root: z.ZodString;
+    branch: z.ZodString;
+    remote: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RepoInfo = z.infer<typeof repoInfoSchema>;
+/** One probed CLI behind the Tools menu. */
+export declare const backendCheckSchema: z.ZodObject<{
+    name: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        gh: "gh";
+        git: "git";
+        opencode: "opencode";
+    }>;
+    available: z.ZodBoolean;
+    version: z.ZodOptional<z.ZodString>;
+    hint: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type BackendCheck = z.infer<typeof backendCheckSchema>;
+export declare const forgeInfoSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"github">;
+    available: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ForgeInfo = z.infer<typeof forgeInfoSchema>;
+/** Server-side feature switches the cockpit reads once at boot. */
+export declare const capabilitiesSchema: z.ZodObject<{
+    localHandoff: z.ZodBoolean;
+    followups: z.ZodBoolean;
+    singleProject: z.ZodBoolean;
+    tokenMetrics: z.ZodBoolean;
+    tokenUsageMetrics: z.ZodBoolean;
+    costMetrics: z.ZodBoolean;
+}, z.core.$strip>;
+export type Capabilities = z.infer<typeof capabilitiesSchema>;
+/**
+ * `GET /api/v1/health` — the CORS-open discovery endpoint (BACKWARD_COMPATIBILITY.md §2).
+ *
+ * Additive fields only: this is the most externally-depended-on JSON in the app.
+ */
+export declare const healthResponseSchema: z.ZodObject<{
+    version: z.ZodString;
+    latestVersion: z.ZodOptional<z.ZodString>;
+    repoRoot: z.ZodString;
+    repo: z.ZodNullable<z.ZodObject<{
+        root: z.ZodString;
+        branch: z.ZodString;
+        remote: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    checks: z.ZodArray<z.ZodObject<{
+        name: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            gh: "gh";
+            git: "git";
+            opencode: "opencode";
+        }>;
+        available: z.ZodBoolean;
+        version: z.ZodOptional<z.ZodString>;
+        hint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    defaultRunner: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        opencode: "opencode";
+    }>;
+    forge: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodLiteral<"github">;
+        available: z.ZodOptional<z.ZodBoolean>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    capabilities: z.ZodObject<{
+        localHandoff: z.ZodBoolean;
+        followups: z.ZodBoolean;
+        singleProject: z.ZodBoolean;
+        tokenMetrics: z.ZodBoolean;
+        tokenUsageMetrics: z.ZodBoolean;
+        costMetrics: z.ZodBoolean;
+    }, z.core.$strip>;
+    projects: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    bootProject: z.ZodString;
+}, z.core.$strip>;
+export type HealthResponse = z.infer<typeof healthResponseSchema>;

package/dist/contract/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The cezar API contract. See `../README.md` — one zod definition per shape, its TypeScript type
+ * inferred from it, shared by the server, the api-client and the cockpit.
+ */
+export * from './events.ts';
+export * from './health.ts';
+export * from './runs.ts';
+export * from './repo.ts';
+export * from './github.ts';
+export * from './projects.ts';
+export * from './workspace.ts';
+export * from './workflows.ts';
+export * from './skills.ts';
+export * from './agent-config.ts';
+export * from './automations.ts';