toolroll 0.9.41 → 0.9.43

package/dist/contracts/cli.d.ts

@@ -0,0 +1,736 @@
+/**
+ * The CLI's machine contract (docs/plans/zod-revamp.md, item 14): one schema for the `--json` envelope, one for each
+ * declared command's answer, and one for a row of the declared command guide that `contract --commands` dumps.
+ *
+ * Answers are what Toolroll writes and consumers are told to ignore keys they don't recognize, so every object here is
+ * loose. A command answers with its own success shape or a refusal (`ok: false` with a stable `reason`). The commands
+ * named in COMMAND_OUTPUTS describe their top-level fields; every other declared command is held to the envelope with
+ * its own `command` name. An answer that disagrees is logged on stderr and written exactly as it was: the check never
+ * changes, reorders or refuses the bytes a command writes.
+ */
+import { z } from "zod";
+import { type EnvelopePayload } from "../envelope.js";
+/** Every `--json` answer: `envelopeVersion` first, then `ok` and `command`; a refusal adds `reason` and `message`. */
+export declare const envelopeSchema: z.ZodObject<{
+    envelopeVersion: z.ZodLiteral<1>;
+    ok: z.ZodBoolean;
+    command: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    message: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type Envelope = z.infer<typeof envelopeSchema>;
+export declare const commandFlagSchema: z.ZodReadonly<z.ZodObject<{
+    name: z.ZodString;
+    takesValue: z.ZodBoolean;
+    meaning: z.ZodString;
+}, z.core.$loose>>;
+export type CommandFlag = z.infer<typeof commandFlagSchema>;
+export declare const commandRowSchema: z.ZodReadonly<z.ZodObject<{
+    invocation: z.ZodString;
+    envelopeCommand: z.ZodOptional<z.ZodString>;
+    synopsis: z.ZodString;
+    audience: z.ZodEnum<{
+        agent: "agent";
+        operator: "operator";
+    }>;
+    agentMayInvoke: z.ZodBoolean;
+    mutation: z.ZodEnum<{
+        "identity-idempotent": "identity-idempotent";
+        keyed: "keyed";
+        none: "none";
+        unkeyed: "unkeyed";
+    }>;
+    positionals: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        name: z.ZodString;
+        required: z.ZodBoolean;
+        meaning: z.ZodString;
+    }, z.core.$loose>>>>>;
+    flags: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+        name: z.ZodString;
+        takesValue: z.ZodBoolean;
+        meaning: z.ZodString;
+    }, z.core.$loose>>>>>;
+    notableReasons: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    inputSchema: z.ZodOptional<z.ZodCustom<{
+        type: 'object';
+        additionalProperties: false;
+        required: readonly string[];
+        properties: Record<string, {
+            type: 'string' | 'integer' | readonly ['string', 'null'];
+            minLength?: number;
+            maxLength?: number;
+            pattern?: string;
+            minimum?: number;
+            maximum?: number;
+            maxBytes?: number;
+            nonblank?: boolean;
+            const?: number;
+        }>;
+    }, {
+        type: 'object';
+        additionalProperties: false;
+        required: readonly string[];
+        properties: Record<string, {
+            type: 'string' | 'integer' | readonly ['string', 'null'];
+            minLength?: number;
+            maxLength?: number;
+            pattern?: string;
+            minimum?: number;
+            maximum?: number;
+            maxBytes?: number;
+            nonblank?: boolean;
+            const?: number;
+        }>;
+    }>>;
+}, z.core.$loose>>;
+export type CommandRow = z.infer<typeof commandRowSchema>;
+/**
+ * The commands whose answers name their fields: the most-used ones (contract, the no-verb scan, status,
+ * integrations, task, flows, ready) and the plain lists. Keyed by the envelope's `command`.
+ */
+export declare const COMMAND_OUTPUTS: {
+    readonly contract: z.ZodUnion<readonly [z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"contract">;
+        capabilities: z.ZodArray<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"contract">;
+        schemaVersion: z.ZodNumber;
+        notes: z.ZodRecord<z.ZodString, z.ZodString>;
+        commands: z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            invocation: z.ZodString;
+            envelopeCommand: z.ZodOptional<z.ZodString>;
+            synopsis: z.ZodString;
+            audience: z.ZodEnum<{
+                agent: "agent";
+                operator: "operator";
+            }>;
+            agentMayInvoke: z.ZodBoolean;
+            mutation: z.ZodEnum<{
+                "identity-idempotent": "identity-idempotent";
+                keyed: "keyed";
+                none: "none";
+                unkeyed: "unkeyed";
+            }>;
+            positionals: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                name: z.ZodString;
+                required: z.ZodBoolean;
+                meaning: z.ZodString;
+            }, z.core.$loose>>>>>;
+            flags: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+                name: z.ZodString;
+                takesValue: z.ZodBoolean;
+                meaning: z.ZodString;
+            }, z.core.$loose>>>>>;
+            notableReasons: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+            inputSchema: z.ZodOptional<z.ZodCustom<{
+                type: 'object';
+                additionalProperties: false;
+                required: readonly string[];
+                properties: Record<string, {
+                    type: 'string' | 'integer' | readonly ['string', 'null'];
+                    minLength?: number;
+                    maxLength?: number;
+                    pattern?: string;
+                    minimum?: number;
+                    maximum?: number;
+                    maxBytes?: number;
+                    nonblank?: boolean;
+                    const?: number;
+                }>;
+            }, {
+                type: 'object';
+                additionalProperties: false;
+                required: readonly string[];
+                properties: Record<string, {
+                    type: 'string' | 'integer' | readonly ['string', 'null'];
+                    minLength?: number;
+                    maxLength?: number;
+                    pattern?: string;
+                    minimum?: number;
+                    maximum?: number;
+                    maxBytes?: number;
+                    nonblank?: boolean;
+                    const?: number;
+                }>;
+            }>>;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"contract">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>]>;
+    readonly scan: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"scan">;
+        scannedAt: z.ZodString;
+        roots: z.ZodArray<z.ZodString>;
+        missingRoots: z.ZodArray<z.ZodString>;
+        remoteRead: z.ZodBoolean;
+        repos: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"scan">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly status: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"status">;
+        generatedAt: z.ZodString;
+        running: z.ZodObject<{
+            count: z.ZodNumber;
+            phases: z.ZodArray<z.ZodObject<{
+                phase: z.ZodString;
+                count: z.ZodNumber;
+            }, z.core.$loose>>;
+            tasks: z.ZodArray<z.ZodObject<{
+                task: z.ZodString;
+                run: z.ZodNumber;
+                phase: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+        queued: z.ZodObject<{
+            count: z.ZodNumber;
+            reasons: z.ZodArray<z.ZodObject<{
+                reason: z.ZodString;
+                count: z.ZodNumber;
+            }, z.core.$loose>>;
+            tasks: z.ZodArray<z.ZodObject<{
+                task: z.ZodString;
+                reason: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+        waitingForReview: z.ZodObject<{
+            count: z.ZodNumber;
+            results: z.ZodArray<z.ZodObject<{
+                task: z.ZodString;
+                run: z.ZodNullable<z.ZodNumber>;
+                check: z.ZodObject<{
+                    status: z.ZodString;
+                    exitCode: z.ZodNullable<z.ZodNumber>;
+                    suites: z.ZodUnknown;
+                }, z.core.$loose>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+        releaseCheck: z.ZodNullable<z.ZodObject<{
+            task: z.ZodString;
+            run: z.ZodNumber;
+            finishedAt: z.ZodNullable<z.ZodString>;
+            check: z.ZodObject<{
+                status: z.ZodString;
+                exitCode: z.ZodNullable<z.ZodNumber>;
+                suites: z.ZodUnknown;
+            }, z.core.$loose>;
+        }, z.core.$loose>>;
+        planWindows: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            plan: z.ZodNullable<z.ZodString>;
+            observedAt: z.ZodString;
+        }, z.core.$loose>>;
+        signIn: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            reason: z.ZodString;
+            command: z.ZodString;
+            since: z.ZodString;
+        }, z.core.$loose>>;
+        tasks: z.ZodArray<z.ZodObject<{
+            task: z.ZodString;
+            title: z.ZodString;
+            headline: z.ZodString;
+            sentence: z.ZodString;
+        }, z.core.$loose>>;
+        lead: z.ZodNullable<z.ZodObject<{
+            owner: z.ZodString;
+            doing: z.ZodString;
+            at: z.ZodString;
+            task: z.ZodNullable<z.ZodString>;
+            line: z.ZodString;
+        }, z.core.$loose>>;
+        projects: z.ZodArray<z.ZodObject<{
+            repo: z.ZodString;
+            name: z.ZodString;
+            running: z.ZodNumber;
+            limit: z.ZodNumber;
+        }, z.core.$loose>>;
+        update: z.ZodOptional<z.ZodObject<{
+            current: z.ZodString;
+            latest: z.ZodString;
+            security: z.ZodBoolean;
+            updateCommand: z.ZodString;
+            url: z.ZodString;
+        }, z.core.$loose>>;
+        integrations: z.ZodOptional<z.ZodObject<{
+            broken: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                name: z.ZodString;
+                fix: z.ZodNullable<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+        updateWaiting: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+        unsentReplies: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            since: z.ZodString;
+            error: z.ZodNullable<z.ZodString>;
+            retry: z.ZodString;
+        }, z.core.$loose>>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"status">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly integrations: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"integrations">;
+        integrations: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            group: z.ZodEnum<{
+                agents: "agents";
+                chat: "chat";
+                code: "code";
+                mail: "mail";
+                monitoring: "monitoring";
+                tools: "tools";
+            }>;
+            name: z.ZodString;
+            state: z.ZodEnum<{
+                broken: "broken";
+                connected: "connected";
+                "not-set-up": "not-set-up";
+            }>;
+            account: z.ZodNullable<z.ZodString>;
+            detail: z.ZodNullable<z.ZodString>;
+            checked: z.ZodBoolean;
+            checkedAt: z.ZodNullable<z.ZodString>;
+            lastSuccessAt: z.ZodNullable<z.ZodString>;
+            lastError: z.ZodNullable<z.ZodString>;
+            lastErrorAt: z.ZodNullable<z.ZodString>;
+            usedBy: z.ZodArray<z.ZodString>;
+            action: z.ZodObject<{
+                kind: z.ZodEnum<{
+                    fix: "fix";
+                    setup: "setup";
+                    test: "test";
+                }>;
+                label: z.ZodString;
+            }, z.core.$loose>;
+            custom: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$loose>>;
+        counts: z.ZodObject<{
+            connected: z.ZodNumber;
+            "not-set-up": z.ZodNumber;
+            broken: z.ZodNumber;
+        }, z.core.$loose>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"integrations">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly ready: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"ready">;
+        count: z.ZodNumber;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            state: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"ready">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"ready">;
+        reason: z.ZodLiteral<"empty">;
+        message: z.ZodString;
+        count: z.ZodNumber;
+        tasks: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>]>;
+    readonly "task add": z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task add">;
+        task: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            state: z.ZodEnum<{
+                cancelled: "cancelled";
+                done: "done";
+                failed: "failed";
+                queued: "queued";
+                running: "running";
+            }>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            priority: z.ZodNumber;
+        }, z.core.$loose>;
+        repo: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task add">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task add">;
+        id: z.ZodString;
+        backend: z.ZodString;
+        mirror: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task add">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">]>;
+    readonly "task list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task list">;
+        count: z.ZodNumber;
+        tasks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            rootId: z.ZodString;
+            activeTaskId: z.ZodString;
+            title: z.ZodString;
+            repo: z.ZodNullable<z.ZodString>;
+            state: z.ZodString;
+            status: z.ZodObject<{
+                token: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$loose>;
+        }, z.core.$loose>>;
+        totals: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        nextCursor: z.ZodNullable<z.ZodString>;
+        limit: z.ZodNumber;
+        view: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "task show": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task show">;
+        task: z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            state: z.ZodEnum<{
+                cancelled: "cancelled";
+                done: "done";
+                failed: "failed";
+                queued: "queued";
+                running: "running";
+            }>;
+            createdAt: z.ZodString;
+            updatedAt: z.ZodString;
+            priority: z.ZodNumber;
+        }, z.core.$loose>;
+        work: z.ZodObject<{
+            taskId: z.ZodString;
+            state: z.ZodString;
+        }, z.core.$loose>;
+        assignment: z.ZodUnknown;
+        ref: z.ZodNumber;
+        blockedBy: z.ZodArray<z.ZodUnknown>;
+        position: z.ZodUnknown;
+        reservedFor: z.ZodNullable<z.ZodString>;
+        approval: z.ZodObject<{
+            approved: z.ZodBoolean;
+        }, z.core.$loose>;
+        risk: z.ZodString;
+        route: z.ZodUnknown;
+        runs: z.ZodArray<z.ZodUnknown>;
+        deliverable: z.ZodString;
+        proofReasons: z.ZodArray<z.ZodUnknown>;
+        proofMatrix: z.ZodArray<z.ZodUnknown>;
+        proofAccepted: z.ZodBoolean;
+        stops: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task show">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "task hold": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task hold">;
+        id: z.ZodString;
+        reason: z.ZodString;
+        until: z.ZodNullable<z.ZodString>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task hold">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "task unhold": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task unhold">;
+        id: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task unhold">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "task wait": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"task wait">;
+        task: z.ZodString;
+        outcome: z.ZodString;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"task wait">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "flows list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"flows list">;
+        flows: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+            repo: z.ZodString;
+            project: z.ZodString;
+            zones: z.ZodArray<z.ZodString>;
+            triggers: z.ZodNumber;
+            cardsWaiting: z.ZodNumber;
+            needDecision: z.ZodNumber;
+        }, z.core.$loose>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"flows list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "flows show": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"flows show">;
+        flow: z.ZodObject<{
+            id: z.ZodNumber;
+            name: z.ZodString;
+            repo: z.ZodString;
+            project: z.ZodString;
+            readable: z.ZodBoolean;
+            zones: z.ZodArray<z.ZodUnknown>;
+            triggers: z.ZodArray<z.ZodUnknown>;
+        }, z.core.$loose>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"flows show">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly grants: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"grants">;
+        count: z.ZodNumber;
+        grants: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"grants">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "runner list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"runner list">;
+        count: z.ZodNumber;
+        runners: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"runner list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "routine list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"routine list">;
+        routines: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"routine list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "incident list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"incident list">;
+        incidents: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"incident list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "outbox list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"outbox list">;
+        notifications: z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            kind: z.ZodString;
+            subject: z.ZodString;
+            createdAt: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"outbox list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "outbox deliver": z.ZodUnion<readonly [z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodBoolean;
+        command: z.ZodLiteral<"outbox deliver">;
+        delivered: z.ZodNumber;
+        failed: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"outbox deliver">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>]>;
+    readonly "approver list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"approver list">;
+        approvers: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"approver list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "coordinator list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"coordinator list">;
+        coordinators: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"coordinator list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "cap list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"cap list">;
+        repo: z.ZodString;
+        capabilities: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"cap list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly gaps: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"gaps">;
+        repo: z.ZodString;
+        gaps: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"gaps">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly reap: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"reap">;
+        count: z.ZodNumber;
+        released: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"reap">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "skills list": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"skills list">;
+        guides: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            title: z.ZodString;
+            oneLiner: z.ZodString;
+        }, z.core.$loose>>;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"skills list">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+};
+/** The schema for `command`'s answer: its own when it names its fields, else the envelope under its own name. */
+export declare function commandOutputSchema(command: string): z.ZodType;
+/** One declared command: its guide row exactly as `contract --commands` dumps it, and its answer's schema. */
+export type CommandEntry = {
+    readonly guide: CommandRow;
+    readonly output: z.ZodType;
+};
+/** Pair each guide row, in order, with the schema of the answer it names (the envelope command, else the invocation). */
+export declare function commandEntries(guide: readonly CommandRow[]): readonly CommandEntry[];
+/** Path-named lines for each way `envelope` (as written, version first) disagrees with its command's schema; empty when it agrees. */
+export declare function envelopeProblems(envelope: unknown): string[];
+/**
+ * Serialize one envelope with the unchanged `envelopeJson`, after checking the value it writes. A disagreement is
+ * logged on stderr and the envelope is written as it was; nothing here throws into a command's path.
+ */
+export declare function checkedEnvelopeJson(payload: EnvelopePayload): string;