toolroll 0.9.33 → 0.9.36

package/dist/contracts/contract.js

@@ -0,0 +1,308 @@
+/**
+ * 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 { limitRule, TEXT_LIMITS } 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.
+ */
+export function limited(field, limitKey) {
+    const limit = TEXT_LIMITS[limitKey];
+    const unit = limitKey.endsWith("Bytes") ? "bytes" : "characters";
+    return z.string().max(limit, { error: `over ${limit.toLocaleString("en-US")} ${unit}` }).describe(limitRule(field, limit, unit));
+}
+/** A versioned payload envelope: a strict object whose `version` is exactly `version`. */
+export function versioned(version, shape) {
+    return z.strictObject({ version: z.literal(version), ...shape });
+}
+/** `["steps", 0, "routes", 0, "goesTo"]` as `steps[0].routes[0].goesTo`. */
+export function pathOf(path) {
+    let out = "";
+    for (const part of path) {
+        if (typeof part === "number")
+            out += `[${part}]`;
+        else
+            out += out === "" ? String(part) : `.${String(part)}`;
+    }
+    return out === "" ? "payload" : out;
+}
+function got(input) {
+    if (input === null)
+        return "null";
+    if (Array.isArray(input))
+        return "an array";
+    return typeof input === "object" ? "an object" : `a ${typeof input}`;
+}
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** The keys an object schema allows at `path` in `input`, following arrays, wrappers and (by its discriminator) a union. */
+function keysAt(schema, input, path) {
+    let node = schema, value = input;
+    for (let at = 0; node !== undefined;) {
+        const def = node._zod.def;
+        if (def.type === "optional" || def.type === "nullable" || def.type === "readonly") {
+            node = def["innerType"];
+            continue;
+        }
+        if (def.type === "lazy") {
+            node = def["getter"]();
+            continue;
+        }
+        if (def.type === "union") {
+            const options = def["options"];
+            const by = def["discriminator"];
+            const wanted = by !== undefined && isRecord(value) ? value[by] : undefined;
+            node = options.find(option => {
+                const shape = option._zod.def["shape"];
+                if (shape === undefined)
+                    return false;
+                if (by === undefined)
+                    return true;
+                const literal = shape[by]?._zod.def;
+                return literal !== undefined && literal["values"]?.includes(wanted) === true;
+            });
+            continue;
+        }
+        if (at === path.length)
+            return def.type === "object" ? Object.keys(def["shape"]) : null;
+        const part = path[at++];
+        if (def.type === "array" && typeof part === "number") {
+            node = def["element"];
+            value = Array.isArray(value) ? value[part] : undefined;
+            continue;
+        }
+        if (def.type === "object" && typeof part === "string") {
+            const shape = def["shape"];
+            node = shape[part] ?? def["catchall"];
+            value = isRecord(value) ? value[part] : undefined;
+            continue;
+        }
+        return null;
+    }
+    return null;
+}
+/** Edit distance, for "did you mean" (short strings only). */
+function distance(a, b) {
+    const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i++) {
+        let last = row[0];
+        row[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const was = row[j];
+            row[j] = Math.min(row[j] + 1, row[j - 1] + 1, last + (a[i - 1] === b[j - 1] ? 0 : 1));
+            last = was;
+        }
+    }
+    return row[b.length];
+}
+/** The allowed key an unknown one most likely meant, or null. */
+function suggestion(key, known, options) {
+    if (known === null || known.length === 0)
+        return null;
+    const alias = options.aliases?.[key]?.find(one => known.includes(one));
+    if (alias !== undefined)
+        return alias;
+    const close = known
+        .map(one => ({ one, far: one.toLowerCase() === key.toLowerCase() ? 0 : distance(one.toLowerCase(), key.toLowerCase()) }))
+        .filter(({ one, far }) => far <= (Math.min(one.length, key.length) >= 6 ? 2 : 1))
+        .sort((a, b) => a.far - b.far);
+    return close[0]?.one ?? null;
+}
+function issuesOf(issue, where = {}) {
+    const at = pathOf(issue.path);
+    const one = (kind, what) => ({ path: at, kind, line: `${at}: ${what}` });
+    switch (issue.code) {
+        case "unrecognized_keys": {
+            const known = where.schema === undefined ? null : keysAt(where.schema, where.input, issue.path);
+            return issue.keys.map(key => {
+                const meant = suggestion(key, known, where.options ?? {});
+                return { path: at, kind: "unknown-key", line: `${at}: unknown key '${key}'${meant === null ? "" : ` (did you mean ${meant}?)`}` };
+            });
+        }
+        case "invalid_type": {
+            const missing = "input" in issue ? issue.input === undefined : / received undefined$/.test(issue.message);
+            // A null where a value belongs is a value left out.
+            if (missing || ("input" in issue && issue.input === null && issue.expected !== "null"))
+                return [one("required", "required")];
+            const expected = issue.expected === "array" ? "an array" : issue.expected === "object" ? "an object" : issue.expected === "null" ? "null" : `a ${issue.expected}`;
+            return [one("wrong-type", `must be ${expected}${"input" in issue ? ` (got ${got(issue.input)})` : ""}`)];
+        }
+        case "too_big":
+            if (issue.origin === "array" || issue.origin === "set")
+                return [one("too-many", `at most ${String(issue.maximum)} items`)];
+            if (issue.origin === "number" || issue.origin === "int" || issue.origin === "bigint")
+                return [one("bad-value", `at most ${String(issue.maximum)}`)];
+            return [one("too-long", issue.origin === "string" && issue.message.startsWith("over ") ? issue.message : `at most ${String(issue.maximum)}${issue.origin === "string" ? " characters" : ""}`)];
+        case "too_small":
+            if (issue.origin === "string" && Number(issue.minimum) === 1)
+                return [one("empty", "must not be empty")];
+            if (issue.origin === "array" || issue.origin === "set")
+                return [one("too-few", `at least ${String(issue.minimum)} item${Number(issue.minimum) === 1 ? "" : "s"}`)];
+            if (issue.origin === "number" || issue.origin === "int" || issue.origin === "bigint")
+                return [one("bad-value", `at least ${String(issue.minimum)}`)];
+            return [one("too-few", `at least ${String(issue.minimum)}`)];
+        case "invalid_value":
+            return [one("bad-value", `must be ${issue.values.length === 1 ? JSON.stringify(issue.values[0]) : `one of ${issue.values.map(value => JSON.stringify(value)).join(", ")}`}`)];
+        case "invalid_union": {
+            // A discriminated union names its choices (`steps[0].kind: must be one of "inbox", "task", ...`).
+            const by = issue.discriminator, options = issue.options;
+            if (typeof by === "string" && Array.isArray(options)) {
+                const given = "input" in issue && isRecord(issue.input) ? issue.input[by] : undefined;
+                const path = at === "payload" || issue.path.at(-1) === by ? at : `${at}.${by}`;
+                const line = given === undefined || given === null ? "required" : `must be one of ${options.map(value => JSON.stringify(value)).join(", ")}`;
+                return [{ path, kind: given === undefined || given === null ? "required" : "bad-value", line: `${path}: ${line}` }];
+            }
+            return [one("invalid", "does not match any allowed shape")];
+        }
+        case "invalid_format":
+            // A pattern's own words say what it wants (`must be a short id: lowercase letters, numbers and dashes`).
+            return [one("bad-value", issue.message.startsWith("Invalid") ? `must match ${issue.format === "regex" ? issue.pattern ?? "its pattern" : issue.format}` : issue.message)];
+        default:
+            return [one("invalid", issue.message)];
+    }
+}
+/**
+ * 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 function contractIssues(error, where = {}) {
+    return error.issues.flatMap(issue => issuesOf(issue, where));
+}
+/** A Zod error as path-named lines: `steps[0].routes[0].goesTo: required`, `routes[0]: unknown key 'to'`. */
+export function contractError(error, where = {}) {
+    return contractIssues(error, where).map(issue => issue.line);
+}
+/**
+ * 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 function contractProblemOf(issue) {
+    const at = issue.path;
+    const reason = (() => {
+        switch (issue.kind) {
+            case "required":
+            case "empty":
+            case "too-few":
+                return `missing-${at}`;
+            case "too-long":
+                return `${at}-too-long`;
+            case "too-many":
+                return `${at}-too-many`;
+            case "unknown-key":
+                return `${at}-unknown-key`;
+            case "newer-version":
+                return "newer-version";
+            default:
+                return `bad-${at}`;
+        }
+    })();
+    return { reason, message: issue.line };
+}
+/** Parse with the input reported, so a missing field reads `required` rather than a wrong type. */
+export function parseContract(schema, input, options = {}) {
+    const parsed = schema.safeParse(input, { reportInput: true });
+    return parsed.success ? { ok: true, value: parsed.data } : { ok: false, issues: contractIssues(parsed.error, { schema, input, options }) };
+}
+/**
+ * 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 function readVersioned(schema, input, upgrades = {}, options = {}) {
+    const current = schema.shape.version.value;
+    if (typeof input !== "object" || input === null || Array.isArray(input)) {
+        return { ok: false, issues: [{ path: "payload", kind: "wrong-type", line: `payload: must be an object (got ${got(input)})` }] };
+    }
+    const body = input;
+    const version = Object.prototype.hasOwnProperty.call(body, "version") ? body["version"] : 0;
+    if (version === current)
+        return parseContract(schema, body, options);
+    if (typeof version === "number" && Number.isInteger(version) && version > current) {
+        return { ok: false, issues: [{ path: "version", kind: "newer-version", line: `version: made by a newer Toolroll (version ${version}; this one reads up to ${current})` }] };
+    }
+    const upgrade = typeof version === "number" ? upgrades[version] : undefined;
+    if (upgrade === undefined) {
+        return { ok: false, issues: [{ path: "version", kind: "bad-value", line: `version: unknown version ${JSON.stringify(version)} (this Toolroll reads ${current}${Object.keys(upgrades).length === 0 ? "" : ` and ${Object.keys(upgrades).join(", ")}`})` }] };
+    }
+    return parseContract(schema, upgrade(body), options);
+}
+/** The Zod node kinds a model-facing schema may use: each says exactly what its JSON Schema says. */
+const MODEL_FACING_TYPES = new Set(["string", "number", "int", "boolean", "null", "literal", "enum", "array", "object", "optional", "nullable", "union", "tuple", "record", "lazy", "readonly", "unknown", "any"]);
+/** Checks that only constrain (never rewrite) and that JSON Schema can state. */
+const MODEL_FACING_CHECKS = new Set(["max_length", "min_length", "length_equals", "greater_than", "less_than", "multiple_of", "number_format", "string_format", "size_equals", "max_size", "min_size"]);
+/** Every node of a schema graph, refusing a refinement, transform, preprocess or unknown node by its schema path. */
+function assertModelFacing(schema, at, seen) {
+    if (seen.has(schema))
+        return;
+    seen.add(schema);
+    const def = schema._zod.def;
+    const where = at === "" ? "the schema" : at;
+    if (def.type === "pipe") {
+        const into = def["in"]?._zod.def.type;
+        const out = def["out"]?._zod.def.type;
+        const what = into === "transform" ? "preprocess" : out === "transform" ? "transform" : "pipe";
+        throw new Error(`toModelSchema: ${where} uses ${what}; a model-facing schema must be JSON-Schema-exact — check it in plain code after parsing`);
+    }
+    if (def.type === "transform")
+        throw new Error(`toModelSchema: ${where} uses transform; a model-facing schema must be JSON-Schema-exact — check it in plain code after parsing`);
+    if (!MODEL_FACING_TYPES.has(def.type))
+        throw new Error(`toModelSchema: ${where} uses a ${def.type} node, which a model-facing schema may not use`);
+    for (const check of def.checks ?? []) {
+        const kind = check._zod.def.check;
+        if (kind === "custom")
+            throw new Error(`toModelSchema: ${where} uses refine or superRefine; a model-facing schema must be JSON-Schema-exact — check it in plain code after parsing`);
+        if (!MODEL_FACING_CHECKS.has(kind))
+            throw new Error(`toModelSchema: ${where} uses a ${kind} check, which rewrites or cannot be stated in JSON Schema`);
+    }
+    const child = (value, path) => assertModelFacing(value, path, seen);
+    const join = (key) => (at === "" ? key : `${at}.${key}`);
+    switch (def.type) {
+        case "object":
+            for (const [key, value] of Object.entries(def["shape"]))
+                child(value, join(key));
+            // A strict object's catchall is `never` (additionalProperties: false); any other catchall is a schema too.
+            if (def["catchall"] !== undefined && def["catchall"]._zod.def.type !== "never")
+                child(def["catchall"], join("*"));
+            break;
+        case "array":
+            child(def["element"], `${at}[]`);
+            break;
+        case "optional":
+        case "nullable":
+        case "readonly":
+            child(def["innerType"], at);
+            break;
+        case "union":
+            def["options"].forEach((option, index) => child(option, `${at}|${index}`));
+            break;
+        case "tuple":
+            def["items"].forEach((item, index) => child(item, `${at}[${index}]`));
+            if (def["rest"] !== undefined && def["rest"] !== null)
+                child(def["rest"], `${at}[]`);
+            break;
+        case "record":
+            child(def["keyType"], `${at}{key}`);
+            child(def["valueType"], `${at}{}`);
+            break;
+        case "lazy":
+            child(def["getter"](), at);
+            break;
+    }
+}
+/**
+ * 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 function toModelSchema(schema) {
+    assertModelFacing(schema, "", new Set());
+    const { $schema: _dialect, ...json } = z.toJSONSchema(schema, { target: "draft-2020-12", unrepresentable: "throw" });
+    return json;
+}

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

@@ -0,0 +1,325 @@
+/**
+ * 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 ["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"];
+export declare const proposeFlowInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        add_card: "add_card";
+        add_trigger: "add_trigger";
+        approve: "approve";
+        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";
+        unfollow: "unfollow";
+    }>;
+    repo: z.ZodOptional<z.ZodString>;
+    flow: z.ZodOptional<z.ZodInt>;
+    card: z.ZodOptional<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]>>;
+        teammate: 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">;
+        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<"teammate">;
+        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>>>;
+        teammate: 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>;
+export type ProposeFlowInput = z.infer<typeof proposeFlowInputSchema>;
+/** 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>>;