toolroll 0.9.104 → 0.9.105

package/dist/contracts/contract.d.ts

@@ -1,92 +0,0 @@
-/**
- * The one way Toolroll describes a contract (docs/plans/zod-revamp.md): one Zod schema, and everything else — the
- * TypeScript type, the runtime check, the JSON Schema a model gets, the text limits — derived from it.
- *
- * The helpers here hold the ground rules every contract shares: limits come from TEXT_LIMITS, persisted payloads are
- * versioned, refusals name the path, and a model-facing schema is exactly what its JSON Schema says (no refinements or
- * transforms; those checks run in plain code after parsing, with a named error).
- */
-import { z } from "zod";
-import { type TextLimitKey } from "../text-limits.js";
-/**
- * A string bounded by its TEXT_LIMITS entry, never a literal. The limit rule rides along as the field's description,
- * so a model reads the bound before it writes. Zod counts UTF-16 code units; for a limit named in bytes this is the
- * schema's necessary bound (a string within N bytes is within N code units), and the byte count itself is checked in
- * plain code after parsing. `shorten: false` is for a contract with no shorten turn (a parked decision): its
- * description states the bound without promising one.
- */
-export declare function limited(field: string, limitKey: TextLimitKey, options?: {
-    shorten?: boolean;
-}): z.ZodString;
-/** A versioned payload envelope: a strict object whose `version` is exactly `version`. */
-export declare function versioned<V extends number, S extends z.ZodRawShape>(version: V, shape: S): z.ZodObject<{
-    version: z.ZodLiteral<V>;
-} & S extends infer T ? { -readonly [P in keyof T]: T[P]; } : never, z.core.$strict>;
-/** One path-named refusal: where, what kind, and the line a person (or the repair turn) reads. */
-export type ContractIssue = {
-    /** `steps[0].routes[0].goesTo`; `payload` for the top level. */
-    path: string;
-    kind: "required" | "empty" | "unknown-key" | "too-long" | "too-many" | "too-few" | "wrong-type" | "bad-value" | "newer-version" | "invalid";
-    /** The line itself: `steps[0].routes[0].goesTo: required`. */
-    line: string;
-};
-/** `["steps", 0, "routes", 0, "goesTo"]` as `steps[0].routes[0].goesTo`. */
-export declare function pathOf(path: readonly PropertyKey[]): string;
-/**
- * How a contract names a key it doesn't know: the keys a person or model often writes for one it does (`onFail` for
- * `ifFails`, `to` for `goesTo`), tried in order against the keys allowed at that place. Without one that fits, a key
- * spelled close to an allowed one (a case or a letter or two off) is suggested.
- */
-export type ContractOptions = {
-    aliases?: Readonly<Record<string, readonly string[]>>;
-    /** Report explicit null as a wrong value; omitted keeps the historical wording for existing contracts. */
-    distinguishNull?: boolean;
-};
-type Where = {
-    schema?: z.ZodType;
-    input?: unknown;
-    options?: ContractOptions;
-};
-/**
- * A Zod error as path-named issues, in the error's own order. Given the schema and input it came from, an unknown key
- * also says which allowed key it most likely meant (`unknown key 'onFail' (did you mean ifFails?)`).
- */
-export declare function contractIssues(error: z.ZodError, where?: Where): ContractIssue[];
-/** A Zod error as path-named lines: `steps[0].routes[0].goesTo: required`, `routes[0]: unknown key 'to'`. */
-export declare function contractError(error: z.ZodError, where?: Where): string[];
-/** A refusal as a reader reports it: a stable reason code, and the path-named line as the message. */
-export type ContractProblem = {
-    reason: string;
-    message: string;
-};
-/**
- * A contract issue as a problem with a reason code built from its path — `missing-goal`, `criteria[0].how-too-long`,
- * `checks-too-many`, `payload-unknown-key`, `bad-version`, `newer-version` — so callers that branch on a reason, and
- * durable outcomes that recorded one, read the same as before the contract.
- */
-export declare function contractProblemOf(issue: ContractIssue): ContractProblem;
-export type ContractResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    issues: ContractIssue[];
-};
-/** Parse with the input reported, so a missing field reads `required` rather than a wrong type. */
-export declare function parseContract<T>(schema: z.ZodType<T>, input: unknown, options?: ContractOptions): ContractResult<T>;
-/**
- * Read a versioned payload. The current version parses as itself; an older known version (0 for a payload saved
- * before it carried `version`) is upgraded by its adapter and then parsed by the same schema; a newer version is
- * refused plainly; anything else is an unknown version.
- */
-export declare function readVersioned<T>(schema: z.ZodType<T> & {
-    shape: {
-        version: z.ZodLiteral<number>;
-    };
-}, input: unknown, upgrades?: Readonly<Record<number, (payload: Record<string, unknown>) => unknown>>, options?: ContractOptions): ContractResult<T>;
-/**
- * The JSON Schema a model gets for `schema` (Claude's `--json-schema`). Throws when the schema uses refine,
- * superRefine, transform or preprocess anywhere: what a model is told must be everything the schema checks.
- */
-export declare function toModelSchema(schema: z.ZodType): Record<string, unknown>;
-export {};

package/dist/contracts/decision.d.ts

@@ -1,45 +0,0 @@
-/**
- * A parked decision (§7): one schema for the question an agent puts to a person — its recap, the question, two to six
- * options each saying whether it can be undone, and the option it recommends. Agents hand it back as a file (the park
- * mailbox); `DECISION_MODEL_SCHEMA` is exported for the scout contract migration to wire into structured output.
- * `parseDecision` (decision.ts) reads decisions through `readDecisionPayload`. The options are what the `decision`
- * row keeps. The existing unversioned format ignores unknown fields, including a field named `version`.
- *
- * What JSON Schema cannot say runs after parsing, in decision.ts, each with a path-named error: text is not blank once
- * trimmed, carries no control characters (a label or assignee is one line), option ids are unique, the recommendation
- * names one of them, and a deadline is a timestamp.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** How many options fit on one screen, and the fewest that make a decision. */
-export declare const DECISION_OPTIONS_MIN = 2;
-export declare const DECISION_OPTIONS_MAX = 6;
-/** Option ids travel in URLs, CLI arguments, and CAS updates — they are identifiers, not prose. */
-export declare const OPTION_ID: RegExp;
-/** One option: its id, a one-line label, what choosing it does, and whether it can be undone (never defaulted). */
-export declare const decisionOptionSchema: z.ZodObject<{
-    id: z.ZodString;
-    label: z.ZodString;
-    consequence: z.ZodString;
-    reversible: z.ZodBoolean;
-}, z.core.$strip>;
-export type DecisionOption = z.infer<typeof decisionOptionSchema>;
-export declare const decisionSchema: z.ZodObject<{
-    urgency: z.ZodLiteral<"blocking">;
-    recap: z.ZodString;
-    question: z.ZodString;
-    options: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        label: z.ZodString;
-        consequence: z.ZodString;
-        reversible: z.ZodBoolean;
-    }, z.core.$strip>>;
-    recommendation: z.ZodString;
-    assignee: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    deadline: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strip>;
-export type DecisionPayload = z.infer<typeof decisionSchema>;
-/** The decision schema for the scout migration's question branch. */
-export declare const DECISION_MODEL_SCHEMA: Readonly<Record<string, unknown>>;
-/** Read the existing decision format, ignoring keys it never used. */
-export declare function readDecisionPayload(input: unknown): ContractResult<DecisionPayload>;

package/dist/contracts/diff-stat.d.ts

@@ -1,58 +0,0 @@
-/**
- * The terminal diff-stat (`terminal-diff-stat.json`): one schema for what `parseNumstat` and `budgetedStatJson`
- * write, and the two candidate-inventory reads that use it as a gate's evidence. Toolroll writes it from typed values
- * in its own key order and never rewrites it, so the stored bytes (and every sha256 bound to them) stay as written.
- *
- * Both reads take only the fields their checks use and ignore the rest, exactly as the hand-written checks did: a
- * legacy gate's endpoints, and a saved assessment's file list. Whether those fields match the run is plain code after
- * parsing; anything the schema refuses was refused before too.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** One file's row. null additions/deletions = binary. */
-export declare const diffStatFileSchema: z.ZodObject<{
-    path: z.ZodString;
-    additions: z.ZodNullable<z.ZodInt>;
-    deletions: z.ZodNullable<z.ZodInt>;
-    renamedFrom: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const diffStatSchema: z.ZodObject<{
-    schema: z.ZodLiteral<1>;
-    base: z.ZodString;
-    head: z.ZodString;
-    fileCount: z.ZodInt;
-    additions: z.ZodInt;
-    deletions: z.ZodInt;
-    binaryCount: z.ZodInt;
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-        additions: z.ZodNullable<z.ZodInt>;
-        deletions: z.ZodNullable<z.ZodInt>;
-        renamedFrom: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    filesTruncated: z.ZodBoolean;
-}, z.core.$strip>;
-export type DiffStat = z.infer<typeof diffStatSchema>;
-export type DiffStatFile = z.infer<typeof diffStatFileSchema>;
-/** What a legacy gate reads of its candidate inventory. `base` may be null, as a run without a base revision has. */
-export declare const candidateEndpointsSchema: z.ZodObject<{
-    head: z.ZodString;
-    filesTruncated: z.ZodBoolean;
-    base: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-/** What a saved assessment reads: the inventory's identity and every changed path. */
-export declare const savedInventorySchema: z.ZodObject<{
-    schema: z.ZodLiteral<1>;
-    base: z.ZodString;
-    head: z.ZodString;
-    fileCount: z.ZodInt;
-    filesTruncated: z.ZodBoolean;
-    files: z.ZodArray<z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-/** A legacy gate's endpoints, from the inventory's parsed JSON (the gate names unreadable JSON itself). */
-export declare function readCandidateEndpoints(input: unknown): ContractResult<z.infer<typeof candidateEndpointsSchema>>;
-/** The changed paths of a complete inventory for exactly this candidate, or null: wrong identity, a cut or
- * miscounted list, or a path named twice. */
-export declare function savedInventoryPaths(text: string, head: string, base: string): Set<string> | null;

package/dist/contracts/discord-callback.d.ts

@@ -1,45 +0,0 @@
-/**
- * A Discord button tap (discord-chat.ts `receiveDiscord`): the component interaction Discord sends over the gateway,
- * and the button data Toolroll put on it. The interaction is Discord's, so fields Toolroll doesn't read are ignored;
- * the button's `custom_id` (`so_` and a one-time token) is Toolroll's. A tap from the paired person on Toolroll's own
- * message whose button can't be read is answered with why (`data.custom_id: not a Toolroll button`), and nothing is done.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** The interaction around a tap (type 3: a message component): the app, the person, the channel, the message. */
-export declare const discordComponentInteractionSchema: z.ZodObject<{
-    type: z.ZodLiteral<3>;
-    id: z.ZodString;
-    application_id: z.ZodString;
-    channel_id: z.ZodString;
-    guild_id: z.ZodOptional<z.ZodString>;
-    channel: z.ZodObject<{
-        type: z.ZodInt;
-    }, z.core.$strip>;
-    member: z.ZodOptional<z.ZodObject<{
-        user: z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>>;
-    user: z.ZodOptional<z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>>;
-    message: z.ZodObject<{
-        id: z.ZodString;
-        channel_id: z.ZodString;
-        author: z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>;
-    }, z.core.$strip>;
-    data: z.ZodObject<{
-        custom_id: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type DiscordComponentInteraction = z.infer<typeof discordComponentInteractionSchema>;
-/** Toolroll's button data: `so_` and a one-time token. */
-export declare const discordButtonSchema: z.ZodObject<{
-    custom_id: z.ZodString;
-}, z.core.$strip>;
-export declare function readDiscordComponentInteraction(body: unknown): ContractResult<DiscordComponentInteraction>;
-/** The tapped button's one-time token. */
-export declare function readDiscordButtonToken(interaction: DiscordComponentInteraction): ContractResult<string>;

package/dist/contracts/flow-card.d.ts

@@ -1,53 +0,0 @@
-/**
- * A flow card's state (docs/plans/zod-revamp.md, item 8): what the flow engine, its steps and its Send to me and
- * Person chooses zones read and write (flow-engine.ts, flow-steps.ts, flow-send.ts), as the store keeps it in
- * `flow_card`. Its columns are versioned by the database's own schema version; the one payload in it, what finished
- * zones handed on (`outputs_json`), carries its own version (stage-output.ts).
- *
- * `flowCardSchema` is the card as read; `flowCardChangeSchema` what one update may change. Where it came from
- * (`source_json`, written by triggers) keeps its own type in the store.
- */
-import { z } from "zod";
-export declare const FLOW_CARD_STATES: readonly ["active", "done", "cancelled"];
-export declare const flowCardSchema: z.ZodObject<{
-    id: z.ZodInt;
-    flow: z.ZodInt;
-    title: z.ZodString;
-    description: z.ZodNullable<z.ZodString>;
-    stage: z.ZodString;
-    entry: z.ZodInt;
-    state: z.ZodEnum<{
-        active: "active";
-        cancelled: "cancelled";
-        done: "done";
-    }>;
-    task: z.ZodNullable<z.ZodString>;
-    primaryTask: z.ZodNullable<z.ZodString>;
-    note: z.ZodNullable<z.ZodString>;
-    waiting: z.ZodNullable<z.ZodString>;
-    outputs: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
-    attached: z.ZodObject<{}, z.core.$catchall<z.ZodString>>;
-    createdBy: z.ZodString;
-    createdKind: z.ZodEnum<{
-        automation: "automation";
-        person: "person";
-    }>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-    owner: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type FlowCardFields = z.infer<typeof flowCardSchema>;
-/** What one update of a card may change; whatever is left out stays as it is. Outputs replace the card's whole;
- * an attachment goes with the output it belongs to. */
-export declare const flowCardChangeSchema: z.ZodObject<{
-    task: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    primaryTask: z.ZodOptional<z.ZodString>;
-    waiting: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    outputs: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodString>>>;
-    attached: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodString>>>;
-    state: z.ZodOptional<z.ZodEnum<{
-        cancelled: "cancelled";
-        done: "done";
-    }>>;
-}, z.core.$strict>;
-export type FlowCardChange = z.infer<typeof flowCardChangeSchema>;

package/dist/contracts/flow-propose.d.ts

@@ -1,334 +0,0 @@
-/**
- * The lead's `propose_flow` input (docs/plans/zod-revamp.md, item 3): one schema, built from the flow contract's own
- * step and trigger schemas, that is both the JSON Schema the lead is given and the check its call is read with
- * (mate-tools.ts). The lead-tools contract (item 5) imports it from here rather than restating it.
- */
-import { z } from "zod";
-export declare const PROPOSE_FLOW_OPERATIONS: readonly ["archive", "turn_off_unattended", "allow_unattended", "create", "edit", "add_card", "move_card", "approve", "send_back", "choose", "cancel_card", "comment", "assign", "follow", "unfollow", "save_script", "add_trigger", "pause_trigger", "resume_trigger", "remove_trigger", "kit", "starter", "allow_browser", "turn_off_browser"];
-export declare const proposeFlowInputSchema: z.ZodObject<{
-    operation: z.ZodEnum<{
-        add_card: "add_card";
-        add_trigger: "add_trigger";
-        allow_browser: "allow_browser";
-        allow_unattended: "allow_unattended";
-        approve: "approve";
-        archive: "archive";
-        assign: "assign";
-        cancel_card: "cancel_card";
-        choose: "choose";
-        comment: "comment";
-        create: "create";
-        edit: "edit";
-        follow: "follow";
-        kit: "kit";
-        move_card: "move_card";
-        pause_trigger: "pause_trigger";
-        remove_trigger: "remove_trigger";
-        resume_trigger: "resume_trigger";
-        save_script: "save_script";
-        send_back: "send_back";
-        starter: "starter";
-        turn_off_browser: "turn_off_browser";
-        turn_off_unattended: "turn_off_unattended";
-        unfollow: "unfollow";
-    }>;
-    repo: z.ZodOptional<z.ZodString>;
-    flow: z.ZodOptional<z.ZodInt>;
-    card: z.ZodOptional<z.ZodInt>;
-    days: z.ZodOptional<z.ZodInt>;
-    budget: z.ZodOptional<z.ZodString>;
-    runs: z.ZodOptional<z.ZodString>;
-    include: z.ZodOptional<z.ZodArray<z.ZodInt>>;
-    kit: z.ZodOptional<z.ZodEnum<{
-        [x: string]: string;
-    }>>;
-    starter: z.ZodOptional<z.ZodEnum<{
-        "ci-fix": "ci-fix";
-        "issue-task": "issue-task";
-        overnight: "overnight";
-        "plane-review": "plane-review";
-    }>>;
-    name: z.ZodOptional<z.ZodString>;
-    template: z.ZodOptional<z.ZodEnum<{
-        [x: string]: string;
-    }>>;
-    steps: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<readonly [z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"inbox">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        thenMoveTo: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"task">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        instructions: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        planning: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            required: "required";
-            skip: "skip";
-        }>>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        repo: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"report">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        instructions: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"approval">;
-        decider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        ifFails: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        subagent: z.ZodOptional<z.ZodString>;
-        thenMoveTo: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"check">;
-        browser: z.ZodOptional<z.ZodBoolean>;
-        ifFails: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            answer: z.ZodString;
-            goesTo: z.ZodString;
-        }, z.core.$strict>>>;
-        runIn: z.ZodOptional<z.ZodEnum<{
-            copy: "copy";
-            folder: "folder";
-        }>>;
-        script: z.ZodOptional<z.ZodString>;
-        secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"pull-request">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        merge: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-            merge: "merge";
-            rebase: "rebase";
-            squash: "squash";
-        }>]>>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"update">;
-        close: z.ZodOptional<z.ZodBoolean>;
-        ifFails: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"notify">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        message: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"sort">;
-        alsoNote: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            id: z.ZodOptional<z.ZodString>;
-            question: z.ZodString;
-            kind: z.ZodOptional<z.ZodEnum<{
-                score: "score";
-                "yes-no": "yes-no";
-            }>>;
-            levels: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>>;
-        answers: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            answer: z.ZodString;
-            means: z.ZodOptional<z.ZodString>;
-            goesTo: z.ZodString;
-        }, z.core.$strict>>>;
-        ifNotSure: z.ZodOptional<z.ZodString>;
-        question: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        sureAt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"draft">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        instructions: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"request">;
-        body: z.ZodOptional<z.ZodString>;
-        headers: z.ZodOptional<z.ZodObject<{}, z.core.$catchall<z.ZodString>>>;
-        ifFails: z.ZodOptional<z.ZodString>;
-        method: z.ZodOptional<z.ZodEnum<{
-            DELETE: "DELETE";
-            GET: "GET";
-            PATCH: "PATCH";
-            POST: "POST";
-            PUT: "PUT";
-        }>>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        url: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"email">;
-        body: z.ZodOptional<z.ZodString>;
-        ifFails: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        subject: z.ZodOptional<z.ZodString>;
-        to: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"tool">;
-        args: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>, z.ZodString]>>;
-        ifFails: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        server: z.ZodOptional<z.ZodString>;
-        tool: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"wait">;
-        from: z.ZodOptional<z.ZodString>;
-        ifNoReply: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        timeZone: z.ZodOptional<z.ZodString>;
-        until: z.ZodOptional<z.ZodString>;
-        wait: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        waitFor: z.ZodOptional<z.ZodEnum<{
-            hours: "hours";
-            reply: "reply";
-            time: "time";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"subagent">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        instructions: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        reply: z.ZodOptional<z.ZodBoolean>;
-        routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            answer: z.ZodString;
-            goesTo: z.ZodString;
-        }, z.core.$strict>>>;
-        subagent: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"send">;
-        ifFails: z.ZodOptional<z.ZodString>;
-        next: z.ZodOptional<z.ZodString>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"choose">;
-        ifNoReply: z.ZodOptional<z.ZodString>;
-        ifReplied: z.ZodOptional<z.ZodString>;
-        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            goesTo: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>>;
-        remindAfter: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
-        thenMoveTo: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        title: z.ZodString;
-        kind: z.ZodLiteral<"done">;
-    }, z.core.$strict>], "kind">>>;
-    title: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    zone: z.ZodOptional<z.ZodString>;
-    note: z.ZodOptional<z.ZodString>;
-    choice: z.ZodOptional<z.ZodInt>;
-    trigger: z.ZodOptional<z.ZodInt>;
-    owner: z.ZodOptional<z.ZodString>;
-    script: z.ZodOptional<z.ZodObject<{
-        name: z.ZodOptional<z.ZodString>;
-        about: z.ZodOptional<z.ZodString>;
-        body: z.ZodOptional<z.ZodString>;
-        timeoutMinutes: z.ZodOptional<z.ZodInt>;
-        language: z.ZodOptional<z.ZodEnum<{
-            node: "node";
-            python: "python";
-            shell: "shell";
-        }>>;
-        file: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
-    settings: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        zone: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"button">;
-        label: z.ZodString;
-        questions: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        zone: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"schedule">;
-        schedule: z.ZodString;
-        title: z.ZodOptional<z.ZodString>;
-        description: z.ZodOptional<z.ZodString>;
-        script: z.ZodOptional<z.ZodString>;
-        secrets: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodString]>>;
-    }, z.core.$strict>, z.ZodObject<{
-        zone: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"github">;
-        repo: z.ZodOptional<z.ZodString>;
-        watch: z.ZodOptional<z.ZodEnum<{
-            checks: "checks";
-            issues: "issues";
-            pulls: "pulls";
-        }>>;
-        label: z.ZodOptional<z.ZodString>;
-        branch: z.ZodOptional<z.ZodString>;
-        from: z.ZodOptional<z.ZodEnum<{
-            anyone: "anyone";
-            team: "team";
-        }>>;
-    }, z.core.$strict>, z.ZodObject<{
-        zone: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"linear">;
-        team: z.ZodOptional<z.ZodString>;
-        state: z.ZodOptional<z.ZodString>;
-        label: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        zone: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"flow">;
-        when: z.ZodOptional<z.ZodString>;
-        follow: z.ZodInt;
-    }, z.core.$strict>, z.ZodObject<{
-        zone: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"email">;
-        folder: z.ZodOptional<z.ZodString>;
-        sender: z.ZodOptional<z.ZodString>;
-        subject: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>, z.ZodObject<{
-        zone: z.ZodOptional<z.ZodString>;
-        kind: z.ZodLiteral<"plane-review">;
-        at: z.ZodOptional<z.ZodString>;
-        timeZone: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>], "kind">>;
-}, z.core.$strict>;
-/** What the lead is told propose_flow takes: exactly the schema its call is read with. */
-export declare const PROPOSE_FLOW_MODEL_SCHEMA: Readonly<Record<string, unknown>>;