toolroll 0.9.103 → 0.9.105

package/dist/contracts/chat-actions.d.ts

@@ -1,465 +0,0 @@
-/**
- * Shared chat actions (chat-actions.ts): one schema for each action's data — what the lead proposes and what a saved
- * proposal carries after `prepareSharedAction` has checked and rewritten it — and one for the saved proposal itself.
- * The allowed fields (`CHAT_ACTION_FIELDS`) and the request types are derived from these; what JSON Schema can't say
- * (credentials and control characters in text, each field's length, a zone or option that exists, who may act) runs
- * in `prepareSharedAction` after parsing, with its own named refusal.
- *
- * A flow drawing, trigger or script inside a request is read by its own contract (flows.ts `validateFlowDefinition`,
- * flow-triggers.ts `validateTriggerConfig`, flow-scripts.ts `validateScript`) when the action is prepared, in every
- * vocabulary those accept; here it is only "a value".
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/**
- * Each action's data, field order as the lead reads it in `get_actions`. Fields a branch ignores or reads through
- * its own validator stay unknown: 0.9.36 accepted null and other non-string values there. Preparation still checks
- * the selected branch and saves the same request bytes. No schema defaults or coercion may change its stamp.
- */
-export declare const chatActionRequestSchemas: {
-    readonly skill_import: z.ZodObject<{
-        repo: z.ZodString;
-        content: z.ZodOptional<z.ZodString>;
-        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            path: z.ZodString;
-            base64: z.ZodString;
-        }, z.core.$strict>>>;
-    }, z.core.$strict>;
-    readonly skill_enable: z.ZodObject<{
-        repo: z.ZodString;
-        version: z.ZodString;
-    }, z.core.$strict>;
-    readonly skill_disable: z.ZodObject<{
-        repo: z.ZodString;
-        version: z.ZodString;
-    }, z.core.$strict>;
-    readonly skill_restore: z.ZodObject<{
-        repo: z.ZodString;
-        restore: z.ZodInt;
-    }, z.core.$strict>;
-    readonly skill_test: z.ZodObject<{
-        repo: z.ZodString;
-        version: z.ZodString;
-        sample: z.ZodString;
-        nonce: z.ZodString;
-    }, z.core.$strict>;
-    readonly knowledge_instructions: z.ZodObject<{
-        repo: z.ZodString;
-        instructions: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly knowledge_save: z.ZodObject<{
-        repo: z.ZodString;
-        title: z.ZodString;
-        content: z.ZodString;
-        id: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly knowledge_remove: z.ZodObject<{
-        repo: z.ZodString;
-        id: z.ZodString;
-    }, z.core.$strict>;
-    readonly knowledge_restore: z.ZodObject<{
-        repo: z.ZodString;
-        restore: z.ZodInt;
-    }, z.core.$strict>;
-    readonly tool_add: z.ZodObject<{
-        repo: z.ZodString;
-        catalog: z.ZodOptional<z.ZodUnknown>;
-        name: z.ZodOptional<z.ZodUnknown>;
-        command: z.ZodOptional<z.ZodUnknown>;
-        args: z.ZodOptional<z.ZodUnknown>;
-        url: z.ZodOptional<z.ZodUnknown>;
-        secrets: z.ZodOptional<z.ZodUnknown>;
-        about: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly tool_remove: z.ZodObject<{
-        repo: z.ZodString;
-        name: z.ZodString;
-    }, z.core.$strict>;
-    readonly flow_create: z.ZodObject<{
-        repo: z.ZodString;
-        name: z.ZodString;
-        definition: z.ZodUnknown;
-        trigger: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly flow_starter: z.ZodObject<{
-        repo: z.ZodString;
-        starter: z.ZodString;
-    }, z.core.$strict>;
-    readonly sweep_cancel_rest: z.ZodObject<{
-        sweep: z.ZodInt;
-    }, z.core.$strict>;
-    readonly sweep_file: z.ZodObject<{
-        repo: z.ZodString;
-        title: z.ZodString;
-        brief: z.ZodString;
-        items: z.ZodArray<z.ZodObject<{
-            title: z.ZodString;
-            item: z.ZodString;
-        }, z.core.$strict>>;
-        acceptance: z.ZodArray<z.ZodUnknown>;
-        maxParallel: z.ZodNumber;
-    }, z.core.$strict>;
-    readonly flow_edit: z.ZodObject<{
-        flow: z.ZodInt;
-        name: z.ZodOptional<z.ZodString>;
-        definition: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly flow_card_add: z.ZodObject<{
-        flow: z.ZodInt;
-        title: z.ZodString;
-        description: z.ZodOptional<z.ZodUnknown>;
-        zone: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly flow_card_move: z.ZodObject<{
-        card: z.ZodInt;
-        zone: z.ZodString;
-    }, z.core.$strict>;
-    readonly flow_card_approve: z.ZodObject<{
-        card: z.ZodInt;
-        note: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly flow_card_send_back: z.ZodObject<{
-        card: z.ZodInt;
-        note: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    /** An option by its number (from 1), or a reply that becomes the note. */
-    readonly flow_card_choose: z.ZodObject<{
-        card: z.ZodInt;
-        choice: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
-        note: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly flow_card_cancel: z.ZodObject<{
-        card: z.ZodInt;
-    }, z.core.$strict>;
-    readonly flow_card_comment: z.ZodObject<{
-        card: z.ZodInt;
-        note: z.ZodString;
-    }, z.core.$strict>;
-    readonly flow_card_assign: z.ZodObject<{
-        card: z.ZodInt;
-        owner: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strict>;
-    readonly flow_card_watch: z.ZodObject<{
-        card: z.ZodInt;
-        watching: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly flow_script_save: z.ZodObject<{
-        repo: z.ZodString;
-        script: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
-    }, z.core.$strict>;
-    readonly flow_trigger_add: z.ZodObject<{
-        flow: z.ZodInt;
-        trigger: z.ZodUnknown;
-    }, z.core.$strict>;
-    readonly flow_trigger_pause: z.ZodObject<{
-        trigger: z.ZodInt;
-    }, z.core.$strict>;
-    readonly flow_trigger_resume: z.ZodObject<{
-        trigger: z.ZodInt;
-    }, z.core.$strict>;
-    readonly flow_trigger_remove: z.ZodObject<{
-        trigger: z.ZodInt;
-    }, z.core.$strict>;
-    /** Browser use in the flow's script zones (flow-browser.ts): allowing it takes the person's own password in the secure screen. */
-    readonly flow_browser: z.ZodObject<{
-        flow: z.ZodInt;
-    }, z.core.$strict>;
-    readonly flow_browser_off: z.ZodObject<{
-        flow: z.ZodInt;
-    }, z.core.$strict>;
-    readonly subagent_create: z.ZodObject<{
-        repo: z.ZodString;
-        template: z.ZodOptional<z.ZodUnknown>;
-        name: z.ZodOptional<z.ZodUnknown>;
-        soul: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly subagent_soul: z.ZodObject<{
-        subagent: z.ZodInt;
-        soul: z.ZodString;
-    }, z.core.$strict>;
-    readonly subagent_state: z.ZodObject<{
-        subagent: z.ZodInt;
-        state: z.ZodEnum<{
-            active: "active";
-            paused: "paused";
-            removed: "removed";
-        }>;
-    }, z.core.$strict>;
-    readonly subagent_note: z.ZodObject<{
-        subagent: z.ZodInt;
-        note: z.ZodString;
-    }, z.core.$strict>;
-    /** D5: the lead delegates — "ask Rosa to …" — as a card on the subagent's desk. */
-    readonly subagent_ask: z.ZodObject<{
-        subagent: z.ZodInt;
-        text: z.ZodString;
-    }, z.core.$strict>;
-    readonly subagent_answer: z.ZodObject<{
-        question: z.ZodInt;
-        choice: z.ZodOptional<z.ZodUnknown>;
-        text: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly subagent_tools: z.ZodObject<{
-        subagent: z.ZodInt;
-        tool: z.ZodString;
-        change: z.ZodEnum<{
-            grant: "grant";
-            revoke: "revoke";
-            rule: "rule";
-        }>;
-        action: z.ZodOptional<z.ZodUnknown>;
-        use: z.ZodOptional<z.ZodUnknown>;
-        limitField: z.ZodOptional<z.ZodUnknown>;
-        limitOver: z.ZodOptional<z.ZodUnknown>;
-        undoWith: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly subagent_memory: z.ZodObject<{
-        subagent: z.ZodInt;
-        memory: z.ZodInt;
-        change: z.ZodEnum<{
-            edit: "edit";
-            forget: "forget";
-        }>;
-        text: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly subagent_routine: z.ZodObject<{
-        subagent: z.ZodInt;
-        change: z.ZodEnum<{
-            add: "add";
-            remove: "remove";
-        }>;
-        routine: z.ZodOptional<z.ZodUnknown>;
-        schedule: z.ZodOptional<z.ZodUnknown>;
-        text: z.ZodOptional<z.ZodUnknown>;
-    }, z.core.$strict>;
-    readonly subagent_undo: z.ZodObject<{
-        subagent: z.ZodInt;
-        call: z.ZodInt;
-    }, z.core.$strict>;
-    readonly kit_setup: z.ZodObject<{
-        repo: z.ZodString;
-        kit: z.ZodString;
-    }, z.core.$strict>;
-    readonly decision_record: z.ZodObject<{
-        repo: z.ZodString;
-        claim: z.ZodString;
-        why: z.ZodString;
-        supersedes: z.ZodOptional<z.ZodInt>;
-        source: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly decision_retire: z.ZodObject<{
-        repo: z.ZodString;
-        decision: z.ZodInt;
-        reason: z.ZodString;
-    }, z.core.$strict>;
-    readonly suggestion_not_now: z.ZodObject<{
-        repo: z.ZodString;
-        suggestion: z.ZodString;
-    }, z.core.$strict>;
-    readonly trial_stop: z.ZodObject<{
-        repo: z.ZodString;
-        trial: z.ZodInt;
-    }, z.core.$strict>;
-    readonly code_map_switch: z.ZodObject<{
-        repo: z.ZodString;
-        on: z.ZodBoolean;
-    }, z.core.$strict>;
-    readonly mode_revoke: z.ZodObject<{
-        repo: z.ZodString;
-    }, z.core.$strict>;
-    readonly provider_resume: z.ZodObject<{
-        provider: z.ZodString;
-    }, z.core.$strict>;
-    readonly worker_note: z.ZodObject<{
-        runner: z.ZodString;
-        note: z.ZodString;
-    }, z.core.$strict>;
-    readonly lead_identity: z.ZodObject<{
-        name: z.ZodString;
-        persona: z.ZodString;
-    }, z.core.$strict>;
-    readonly task_archive: z.ZodObject<{
-        task: z.ZodString;
-        reason: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    readonly task_restore: z.ZodObject<{
-        task: z.ZodString;
-    }, z.core.$strict>;
-    readonly flow_archive: z.ZodObject<{
-        flow: z.ZodInt;
-    }, z.core.$strict>;
-    readonly flow_unattended_off: z.ZodObject<{
-        flow: z.ZodInt;
-    }, z.core.$strict>;
-    readonly incident_resolve: z.ZodObject<{
-        incident: z.ZodInt;
-    }, z.core.$strict>;
-    readonly finding_send: z.ZodObject<{
-        task: z.ZodString;
-        summary: z.ZodOptional<z.ZodString>;
-        file: z.ZodOptional<z.ZodString>;
-        line: z.ZodOptional<z.ZodInt>;
-        pointer: z.ZodOptional<z.ZodString>;
-        run: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly finding_resend: z.ZodObject<{
-        finding: z.ZodInt;
-    }, z.core.$strict>;
-    readonly task_reopen: z.ZodObject<{
-        task: z.ZodString;
-    }, z.core.$strict>;
-    readonly revision_accept: z.ZodObject<{
-        task: z.ZodString;
-        revision: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly revision_reject: z.ZodObject<{
-        task: z.ZodString;
-        revision: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly flow_unattended: z.ZodObject<{
-        flow: z.ZodInt;
-        days: z.ZodInt;
-        budget: z.ZodOptional<z.ZodString>;
-        runs: z.ZodOptional<z.ZodString>;
-        include: z.ZodOptional<z.ZodArray<z.ZodInt>>;
-    }, z.core.$strict>;
-    readonly memory_decide: z.ZodObject<{
-        repo: z.ZodString;
-        proposal: z.ZodInt;
-        decision: z.ZodEnum<{
-            accept: "accept";
-            reject: "reject";
-        }>;
-    }, z.core.$strict>;
-    readonly code_map_holdout_end: z.ZodObject<{
-        repo: z.ZodString;
-    }, z.core.$strict>;
-    /** The line, and (from 1) the line it replaces; 0 or none adds it. */
-    readonly lead_about_you: z.ZodObject<{
-        line: z.ZodString;
-        replaces: z.ZodOptional<z.ZodInt>;
-    }, z.core.$strict>;
-    readonly scope_approve: z.ZodObject<{
-        task: z.ZodString;
-    }, z.core.$strict>;
-    readonly result_accept: z.ZodObject<{
-        task: z.ZodString;
-        run: z.ZodInt;
-    }, z.core.$strict>;
-    readonly task_cancel: z.ZodObject<{
-        task: z.ZodString;
-    }, z.core.$strict>;
-    readonly task_resume: z.ZodObject<{
-        task: z.ZodString;
-        run: z.ZodInt;
-    }, z.core.$strict>;
-    /** One-step start from chat: the project and the preview the lead's turn loop prepared (never the model's id). */
-    readonly task_start: z.ZodObject<{
-        repo: z.ZodString;
-        preview: z.ZodString;
-    }, z.core.$strict>;
-};
-export type ChatActionOperation = keyof typeof chatActionRequestSchemas;
-export declare const CHAT_ACTION_OPERATIONS: [ChatActionOperation, ...ChatActionOperation[]];
-/** The fields each action takes, from its schema. */
-export declare const CHAT_ACTION_FIELDS: Record<ChatActionOperation, readonly string[]>;
-/** One action's data, refused by path (`card: required`, `payload: unknown key 'cards' (did you mean card?)`). */
-export declare function readChatActionRequest(operation: ChatActionOperation, input: unknown): ContractResult<Record<string, unknown>>;
-export declare const SHARED_ACTION_VERSION = 1;
-/**
- * A prepared action as a proposal saves it: the action, its checked request, the project, the card's title and
- * terms, the stamp that proves nothing changed before it is confirmed, and the state the stamp was taken over (each
- * action's own staleness fence, read back only by that action).
- */
-export declare const sharedActionSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    operation: z.ZodEnum<{
-        code_map_holdout_end: "code_map_holdout_end";
-        code_map_switch: "code_map_switch";
-        decision_record: "decision_record";
-        decision_retire: "decision_retire";
-        finding_resend: "finding_resend";
-        finding_send: "finding_send";
-        flow_archive: "flow_archive";
-        flow_browser: "flow_browser";
-        flow_browser_off: "flow_browser_off";
-        flow_card_add: "flow_card_add";
-        flow_card_approve: "flow_card_approve";
-        flow_card_assign: "flow_card_assign";
-        flow_card_cancel: "flow_card_cancel";
-        flow_card_choose: "flow_card_choose";
-        flow_card_comment: "flow_card_comment";
-        flow_card_move: "flow_card_move";
-        flow_card_send_back: "flow_card_send_back";
-        flow_card_watch: "flow_card_watch";
-        flow_create: "flow_create";
-        flow_edit: "flow_edit";
-        flow_script_save: "flow_script_save";
-        flow_starter: "flow_starter";
-        flow_trigger_add: "flow_trigger_add";
-        flow_trigger_pause: "flow_trigger_pause";
-        flow_trigger_remove: "flow_trigger_remove";
-        flow_trigger_resume: "flow_trigger_resume";
-        flow_unattended: "flow_unattended";
-        flow_unattended_off: "flow_unattended_off";
-        incident_resolve: "incident_resolve";
-        kit_setup: "kit_setup";
-        knowledge_instructions: "knowledge_instructions";
-        knowledge_remove: "knowledge_remove";
-        knowledge_restore: "knowledge_restore";
-        knowledge_save: "knowledge_save";
-        lead_about_you: "lead_about_you";
-        lead_identity: "lead_identity";
-        memory_decide: "memory_decide";
-        mode_revoke: "mode_revoke";
-        provider_resume: "provider_resume";
-        result_accept: "result_accept";
-        revision_accept: "revision_accept";
-        revision_reject: "revision_reject";
-        scope_approve: "scope_approve";
-        skill_disable: "skill_disable";
-        skill_enable: "skill_enable";
-        skill_import: "skill_import";
-        skill_restore: "skill_restore";
-        skill_test: "skill_test";
-        subagent_answer: "subagent_answer";
-        subagent_ask: "subagent_ask";
-        subagent_create: "subagent_create";
-        subagent_memory: "subagent_memory";
-        subagent_note: "subagent_note";
-        subagent_routine: "subagent_routine";
-        subagent_soul: "subagent_soul";
-        subagent_state: "subagent_state";
-        subagent_tools: "subagent_tools";
-        subagent_undo: "subagent_undo";
-        suggestion_not_now: "suggestion_not_now";
-        sweep_cancel_rest: "sweep_cancel_rest";
-        sweep_file: "sweep_file";
-        task_archive: "task_archive";
-        task_cancel: "task_cancel";
-        task_reopen: "task_reopen";
-        task_restore: "task_restore";
-        task_resume: "task_resume";
-        task_start: "task_start";
-        tool_add: "tool_add";
-        tool_remove: "tool_remove";
-        trial_stop: "trial_stop";
-        worker_note: "worker_note";
-    }>;
-    request: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
-    repo: z.ZodString;
-    title: z.ZodString;
-    terms: z.ZodArray<z.ZodString>;
-    stamp: z.ZodString;
-    state: z.ZodObject<{}, z.core.$catchall<z.ZodUnknown>>;
-}, z.core.$strict>;
-export type SharedAction = z.infer<typeof sharedActionSchema>;
-/**
- * A proposal saved before it carried `version` (every one through 0.9.36), as version 1. Its reader took the fields
- * it knew and passed any others through unread, so this keeps exactly the known fields.
- */
-export declare function upgradeUnversionedSharedAction(body: Record<string, unknown>): Record<string, unknown>;
-export declare const SHARED_ACTION_UPGRADES: {
-    readonly 0: typeof upgradeUnversionedSharedAction;
-};
-export declare function readSharedAction(given: unknown): ContractResult<SharedAction>;

package/dist/contracts/chat-callback-rows.d.ts

@@ -1,59 +0,0 @@
-/**
- * The saved side of a chat button: the row its one-time token names. A proposal card's buttons in Slack, Discord and
- * Teams (`chat_action`, read with the part and event it rides) and a result's, plan's, failure's or pull request's own
- * buttons (`chat_decide_action`, chat-decide.ts). SQLite's own CHECKs bound them when written; these say what a
- * reader may rely on, so a row that isn't that is refused by column, never read as a guess.
- */
-import { z } from "zod";
-import { type ContractResult } from "./contract.js";
-/** A proposal card's button (chat-delivery.ts), with the part's message and the event's binding, channel and thread. */
-export declare const proposalActionRowSchema: z.ZodObject<{
-    token: z.ZodString;
-    part: z.ZodInt;
-    proposal: z.ZodInt;
-    phase: z.ZodEnum<{
-        cancel: "cancel";
-        confirm: "confirm";
-        dismiss: "dismiss";
-        yes: "yes";
-    }>;
-    expires: z.ZodString;
-    consumed: z.ZodNullable<z.ZodString>;
-    message: z.ZodNullable<z.ZodString>;
-    binding: z.ZodNullable<z.ZodInt>;
-    channel: z.ZodString;
-    thread: z.ZodString;
-}, z.core.$strict>;
-export type ProposalActionRow = z.infer<typeof proposalActionRowSchema>;
-export declare function readProposalActionRow(row: unknown): ContractResult<ProposalActionRow>;
-export declare const DECIDE_ACTS: readonly ["accept", "changes", "retry", "approve", "not-now", "merge"];
-export declare const DECIDE_PHASES: readonly ["offer", "yes", "cancel"];
-/** A decide button (chat-decide.ts): who and where it was sent, what it does to which task and run, and the stamp it holds. */
-export declare const decideActionRowSchema: z.ZodObject<{
-    token: z.ZodString;
-    channel: z.ZodString;
-    binding: z.ZodInt;
-    chat: z.ZodString;
-    message: z.ZodNullable<z.ZodString>;
-    act: z.ZodEnum<{
-        accept: "accept";
-        approve: "approve";
-        changes: "changes";
-        merge: "merge";
-        "not-now": "not-now";
-        retry: "retry";
-    }>;
-    phase: z.ZodEnum<{
-        cancel: "cancel";
-        offer: "offer";
-        yes: "yes";
-    }>;
-    task_id: z.ZodString;
-    run: z.ZodNullable<z.ZodInt>;
-    digest: z.ZodString;
-    created_at: z.ZodString;
-    expires_at: z.ZodString;
-    consumed_at: z.ZodNullable<z.ZodString>;
-}, z.core.$strict>;
-export type DecideActionRow = z.infer<typeof decideActionRowSchema>;
-export declare function readDecideActionRow(row: unknown): ContractResult<DecideActionRow>;

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

@@ -1,91 +0,0 @@
-/**
- * A Toolroll card as it is kept and shown (docs/plans/toolroll-cards.md): what a card's spec became once Toolroll filled
- * it from its own records. Every value here was written by Toolroll; the one exception is a `text` block, which a person
- * reads as a plain paragraph labelled as the lead's note, never as data. A saved card is read back through this
- * schema before any renderer sees it.
- */
-import { z } from "zod";
-export declare const CARD_LIMITS: {
-    readonly blocks: 8;
-    readonly columns: 6;
-    readonly rows: 20;
-    readonly points: 12;
-    readonly facts: 10;
-    readonly buttons: 4;
-    readonly actions: 4;
-    readonly cell: 80;
-    readonly label: 40;
-    readonly heading: 80;
-    readonly text: 600;
-    readonly note: 400;
-    readonly notes: 12;
-};
-export declare const CARD_CHART_TYPES: readonly ["bar", "pie", "line", "area"];
-export type CardChartType = (typeof CARD_CHART_TYPES)[number];
-export declare const chatCardSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    title: z.ZodString;
-    asOf: z.ZodString;
-    repos: z.ZodArray<z.ZodString>;
-    blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        kind: z.ZodLiteral<"text">;
-        text: z.ZodString;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"divider">;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"facts">;
-        heading: z.ZodString;
-        items: z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            value: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"table">;
-        heading: z.ZodString;
-        origin: z.ZodEnum<{
-            records: "records";
-            report: "report";
-        }>;
-        columns: z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            numeric: z.ZodBoolean;
-        }, z.core.$strict>>;
-        rows: z.ZodArray<z.ZodArray<z.ZodString>>;
-        more: z.ZodInt;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"notes">;
-        heading: z.ZodString;
-        origin: z.ZodEnum<{
-            records: "records";
-            report: "report";
-        }>;
-        items: z.ZodArray<z.ZodString>;
-        more: z.ZodInt;
-    }, z.core.$strict>, z.ZodObject<{
-        kind: z.ZodLiteral<"chart">;
-        heading: z.ZodString;
-        chart: z.ZodEnum<{
-            area: "area";
-            bar: "bar";
-            line: "line";
-            pie: "pie";
-        }>;
-        points: z.ZodArray<z.ZodObject<{
-            label: z.ZodString;
-            value: z.ZodNumber;
-            shown: z.ZodString;
-        }, z.core.$strict>>;
-    }, z.core.$strict>], "kind">>;
-    buttons: z.ZodArray<z.ZodObject<{
-        label: z.ZodString;
-        path: z.ZodString;
-    }, z.core.$strict>>;
-    actions: z.ZodArray<z.ZodObject<{
-        proposal: z.ZodInt;
-        label: z.ZodString;
-    }, z.core.$strict>>;
-}, z.core.$strict>;
-export type ChatCard = z.infer<typeof chatCardSchema>;
-export type ChatCardBlock = ChatCard["blocks"][number];
-/** A saved card, or null: it was changed, or a build that wrote it knew another shape. */
-export declare function readChatCard(value: unknown): ChatCard | null;