toolroll 0.9.104 → 0.9.105

package/dist/contracts/cli.d.ts

@@ -1,987 +0,0 @@
-/**
- * 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>;
-/** The remote policy every command row states; see `remote` below. */
-export declare const REMOTE_POLICIES: readonly ["yes", "no", "step-up"];
-export type RemotePolicy = typeof REMOTE_POLICIES[number];
-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>>>;
-    remote: z.ZodEnum<{
-        no: "no";
-        "step-up": "step-up";
-        yes: "yes";
-    }>;
-}, 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>>>;
-            remote: z.ZodEnum<{
-                no: "no";
-                "step-up": "step-up";
-                yes: "yes";
-            }>;
-        }, 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>>;
-        figures: z.ZodOptional<z.ZodObject<{
-            waitingOnYou: z.ZodNumber;
-            running: z.ZodNumber;
-            queued: z.ZodNumber;
-            done: z.ZodNumber;
-        }, 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>>>;
-        laptop: z.ZodOptional<z.ZodObject<{
-            running: z.ZodBoolean;
-            url: z.ZodNullable<z.ZodString>;
-            pid: z.ZodNullable<z.ZodNumber>;
-            background: z.ZodEnum<{
-                off: "off";
-                on: "on";
-                "other-service": "other-service";
-            }>;
-        }, 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 health: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"health">;
-        health: z.ZodObject<{
-            version: z.ZodLiteral<1>;
-            windowSeconds: z.ZodLiteral<300>;
-            uptimeSeconds: z.ZodNumber;
-            requests: z.ZodObject<{
-                count: z.ZodNumber;
-                p50Ms: z.ZodNullable<z.ZodNumber>;
-                p99Ms: z.ZodNullable<z.ZodNumber>;
-                maxMs: z.ZodNullable<z.ZodNumber>;
-                totalMs: z.ZodNumber;
-            }, z.core.$loose>;
-            routes: z.ZodRecord<z.ZodEnum<{
-                assets: "assets";
-                auth: "auth";
-                chat: "chat";
-                cli: "cli";
-                console: "console";
-                decisions: "decisions";
-                flows: "flows";
-                health: "health";
-                live: "live";
-                mcp: "mcp";
-                metrics: "metrics";
-                other: "other";
-                projects: "projects";
-                results: "results";
-                sessions: "sessions";
-                settings: "settings";
-                tasks: "tasks";
-                team: "team";
-            }> & z.core.$partial, z.ZodObject<{
-                count: z.ZodNumber;
-                p50Ms: z.ZodNullable<z.ZodNumber>;
-                p99Ms: z.ZodNullable<z.ZodNumber>;
-                maxMs: z.ZodNullable<z.ZodNumber>;
-                totalMs: z.ZodNumber;
-            }, z.core.$loose>>;
-            eventLoop: z.ZodObject<{
-                count: z.ZodNumber;
-                p50Ms: z.ZodNullable<z.ZodNumber>;
-                p99Ms: z.ZodNullable<z.ZodNumber>;
-                maxMs: z.ZodNullable<z.ZodNumber>;
-                totalMs: z.ZodNumber;
-            }, z.core.$loose>;
-            writes: z.ZodObject<{
-                wait: z.ZodObject<{
-                    count: z.ZodNumber;
-                    p50Ms: z.ZodNullable<z.ZodNumber>;
-                    p99Ms: z.ZodNullable<z.ZodNumber>;
-                    maxMs: z.ZodNullable<z.ZodNumber>;
-                    totalMs: z.ZodNumber;
-                }, z.core.$loose>;
-                hold: z.ZodObject<{
-                    count: z.ZodNumber;
-                    p50Ms: z.ZodNullable<z.ZodNumber>;
-                    p99Ms: z.ZodNullable<z.ZodNumber>;
-                    maxMs: z.ZodNullable<z.ZodNumber>;
-                    totalMs: z.ZodNumber;
-                }, z.core.$loose>;
-                statement: z.ZodObject<{
-                    count: z.ZodNumber;
-                    p50Ms: z.ZodNullable<z.ZodNumber>;
-                    p99Ms: z.ZodNullable<z.ZodNumber>;
-                    maxMs: z.ZodNullable<z.ZodNumber>;
-                    totalMs: z.ZodNumber;
-                }, z.core.$loose>;
-            }, z.core.$loose>;
-            streams: z.ZodObject<{
-                open: z.ZodNumber;
-                queuedBytes: z.ZodNumber;
-                maxQueuedBytes: z.ZodNumber;
-            }, z.core.$loose>;
-            budgetRefusals: z.ZodNumber;
-        }, z.core.$loose>;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"health">;
-        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>;
-        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 ship": z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"task ship">;
-        task: z.ZodString;
-        pullRequest: z.ZodNumber;
-        githubRepo: z.ZodString;
-        head: z.ZodString;
-        observedAt: z.ZodString;
-        status: z.ZodEnum<{
-            failing: "failing";
-            none: "none";
-            passing: "passing";
-            running: "running";
-        }>;
-        checks: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            workflow: z.ZodNullable<z.ZodString>;
-            state: z.ZodEnum<{
-                cancelled: "cancelled";
-                failed: "failed";
-                neutral: "neutral";
-                passed: "passed";
-                queued: "queued";
-                running: "running";
-                skipped: "skipped";
-            }>;
-            startedAt: z.ZodNullable<z.ZodString>;
-            completedAt: z.ZodNullable<z.ZodString>;
-            url: z.ZodNullable<z.ZodString>;
-            kind: z.ZodEnum<{
-                run: "run";
-                status: "status";
-            }>;
-            seconds: z.ZodNullable<z.ZodNumber>;
-        }, z.core.$loose>>;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"task ship">;
-        reason: z.ZodString;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>], "ok">;
-    readonly "task ready": z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"task ready">;
-        taskId: z.ZodString;
-        activeTaskId: z.ZodString;
-        run: z.ZodNullable<z.ZodNumber>;
-        head: z.ZodNullable<z.ZodString>;
-        answer: z.ZodEnum<{
-            merged: "merged";
-            no: "no";
-            "not-yet": "not-yet";
-            yes: "yes";
-        }>;
-        sentence: z.ZodString;
-        rows: z.ZodArray<z.ZodObject<{
-            key: z.ZodEnum<{
-                build: "build";
-                checks: "checks";
-                comments: "comments";
-                conflicts: "conflicts";
-                plan: "plan";
-                "pr-ci": "pr-ci";
-                "pull-request": "pull-request";
-                release: "release";
-                requirements: "requirements";
-                "up-to-date": "up-to-date";
-            }>;
-            label: z.ZodString;
-            mark: z.ZodEnum<{
-                no: "no";
-                skip: "skip";
-                unknown: "unknown";
-                waiting: "waiting";
-                yes: "yes";
-            }>;
-            say: z.ZodString;
-            act: z.ZodNullable<z.ZodObject<{
-                kind: z.ZodEnum<{
-                    fix: "fix";
-                    retry: "retry";
-                    "run-checks": "run-checks";
-                }>;
-            }, z.core.$loose>>;
-        }, z.core.$loose>>;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"task ready">;
-        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>;
-            unattended: z.ZodNullable<z.ZodObject<{
-                until: z.ZodString;
-                signedBy: z.ZodString;
-                budgetMicrousd: z.ZodNullable<z.ZodNumber>;
-                dailyRunCap: z.ZodNullable<z.ZodNumber>;
-                runsToday: z.ZodNumber;
-                covers: z.ZodArray<z.ZodString>;
-            }, z.core.$loose>>;
-        }, 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 "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 audit: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"audit">;
-        filters: z.ZodObject<{
-            person: z.ZodNullable<z.ZodString>;
-            token: z.ZodNullable<z.ZodString>;
-            source: z.ZodNullable<z.ZodEnum<{
-                api: "api";
-                mcp: "mcp";
-            }>>;
-            since: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>;
-        actions: z.ZodArray<z.ZodObject<{
-            id: z.ZodNumber;
-            at: z.ZodString;
-            person: z.ZodString;
-            token: z.ZodNullable<z.ZodString>;
-            source: z.ZodEnum<{
-                api: "api";
-                mcp: "mcp";
-            }>;
-            kind: z.ZodEnum<{
-                command: "command";
-                tool: "tool";
-            }>;
-            name: z.ZodString;
-            command: z.ZodString;
-            tool: z.ZodNullable<z.ZodString>;
-            repo: z.ZodNullable<z.ZodString>;
-            taskId: z.ZodNullable<z.ZodString>;
-            outcome: z.ZodEnum<{
-                error: "error";
-                ok: "ok";
-                refused: "refused";
-            }>;
-            reason: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>>;
-        limit: z.ZodNumber;
-        nextCursor: z.ZodNullable<z.ZodString>;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"audit">;
-        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">;
-    readonly welcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"welcome">;
-        agent: z.ZodObject<{
-            done: z.ZodBoolean;
-            checking: z.ZodBoolean;
-            agents: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                name: z.ZodString;
-                state: z.ZodString;
-                command: z.ZodNullable<z.ZodString>;
-                inUse: z.ZodBoolean;
-                canUse: z.ZodBoolean;
-            }, z.core.$loose>>;
-            inUse: z.ZodNullable<z.ZodString>;
-            buildsWith: z.ZodNullable<z.ZodString>;
-        }, z.core.$loose>;
-        project: z.ZodObject<{
-            done: z.ZodBoolean;
-            projects: z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                path: z.ZodString;
-            }, z.core.$loose>>;
-            sample: z.ZodNullable<z.ZodString>;
-            notTakingWork: z.ZodBoolean;
-        }, z.core.$loose>;
-        task: z.ZodObject<{
-            done: z.ZodBoolean;
-            open: z.ZodBoolean;
-            starters: z.ZodArray<z.ZodObject<{
-                label: z.ZodString;
-                draft: z.ZodString;
-                href: z.ZodString;
-            }, z.core.$loose>>;
-        }, z.core.$loose>;
-        next: z.ZodNullable<z.ZodEnum<{
-            agent: "agent";
-            project: "project";
-            task: "task";
-        }>>;
-        left: z.ZodNumber;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"welcome">;
-        reason: z.ZodString;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>], "ok">;
-    readonly "password set": z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"password set">;
-        account: z.ZodString;
-        generation: z.ZodNumber;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"password set">;
-        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;