toolroll 0.9.36 → 0.9.37

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

@@ -0,0 +1,328 @@
+/**
+ * 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 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>;
+    readonly teammate_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 teammate_soul: z.ZodObject<{
+        teammate: z.ZodInt;
+        soul: z.ZodString;
+    }, z.core.$strict>;
+    readonly teammate_state: z.ZodObject<{
+        teammate: z.ZodInt;
+        state: z.ZodEnum<{
+            active: "active";
+            paused: "paused";
+            removed: "removed";
+        }>;
+    }, z.core.$strict>;
+    readonly teammate_note: z.ZodObject<{
+        teammate: z.ZodInt;
+        note: z.ZodString;
+    }, z.core.$strict>;
+    readonly teammate_answer: z.ZodObject<{
+        question: z.ZodInt;
+        choice: z.ZodOptional<z.ZodUnknown>;
+        text: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>;
+    readonly teammate_tools: z.ZodObject<{
+        teammate: 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 teammate_memory: z.ZodObject<{
+        teammate: z.ZodInt;
+        memory: z.ZodInt;
+        change: z.ZodEnum<{
+            edit: "edit";
+            forget: "forget";
+        }>;
+        text: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>;
+    readonly teammate_routine: z.ZodObject<{
+        teammate: 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 teammate_undo: z.ZodObject<{
+        teammate: 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>;
+    /** 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>;
+};
+export type ChatActionOperation = keyof typeof chatActionRequestSchemas;
+export declare const CHAT_ACTION_OPERATIONS: [ChatActionOperation, ...ChatActionOperation[]];
+export type ChatActionRequest<O extends ChatActionOperation = ChatActionOperation> = z.infer<(typeof chatActionRequestSchemas)[O]>;
+/** 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<{
+        decision_record: "decision_record";
+        decision_retire: "decision_retire";
+        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";
+        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";
+        result_accept: "result_accept";
+        scope_approve: "scope_approve";
+        skill_disable: "skill_disable";
+        skill_enable: "skill_enable";
+        skill_import: "skill_import";
+        skill_restore: "skill_restore";
+        skill_test: "skill_test";
+        task_cancel: "task_cancel";
+        task_resume: "task_resume";
+        teammate_answer: "teammate_answer";
+        teammate_create: "teammate_create";
+        teammate_memory: "teammate_memory";
+        teammate_note: "teammate_note";
+        teammate_routine: "teammate_routine";
+        teammate_soul: "teammate_soul";
+        teammate_state: "teammate_state";
+        teammate_tools: "teammate_tools";
+        teammate_undo: "teammate_undo";
+        tool_add: "tool_add";
+        tool_remove: "tool_remove";
+    }>;
+    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;
+};
+/** Legacy readers checked only the envelope. Confirmation still prepares the request again before acting. */
+export declare function readSharedAction(input: unknown): ContractResult<SharedAction>;

package/dist/contracts/chat-actions.js

@@ -0,0 +1,133 @@
+/**
+ * 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 { parseContract, readVersioned, versioned } from "./contract.js";
+/** An id the store minted: a positive safe integer. */
+const id = z.int().min(1);
+const words = z.string();
+/** A drawing, trigger or script: read by its own contract when the action is prepared. */
+const nested = z.unknown();
+const skillFile = z.strictObject({ path: z.string(), base64: z.string() });
+/** An object whose keys its own reader knows (a script draft, an action's staleness fence). */
+const anyObject = z.object({}).catchall(z.unknown());
+/**
+ * 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 const chatActionRequestSchemas = {
+    skill_import: z.strictObject({ repo: words, content: words.optional(), files: z.array(skillFile).optional() }),
+    skill_enable: z.strictObject({ repo: words, version: words }),
+    skill_disable: z.strictObject({ repo: words, version: words }),
+    skill_restore: z.strictObject({ repo: words, restore: id }),
+    skill_test: z.strictObject({ repo: words, version: words, sample: words, nonce: words }),
+    knowledge_instructions: z.strictObject({ repo: words, instructions: words.optional() }),
+    knowledge_save: z.strictObject({ repo: words, title: words, content: words, id: words.optional() }),
+    knowledge_remove: z.strictObject({ repo: words, id: words }),
+    knowledge_restore: z.strictObject({ repo: words, restore: id }),
+    tool_add: z.strictObject({
+        repo: words, catalog: z.unknown().optional(), name: z.unknown().optional(), command: z.unknown().optional(), args: z.unknown().optional(),
+        url: z.unknown().optional(), secrets: z.unknown().optional(), about: z.unknown().optional(),
+    }),
+    tool_remove: z.strictObject({ repo: words, name: words }),
+    flow_create: z.strictObject({ repo: words, name: words, definition: nested, trigger: nested.optional() }),
+    flow_starter: z.strictObject({ repo: words, starter: words }),
+    flow_edit: z.strictObject({ flow: id, name: words.optional(), definition: nested.optional() }),
+    flow_card_add: z.strictObject({ flow: id, title: words, description: z.unknown().optional(), zone: words.optional() }),
+    flow_card_move: z.strictObject({ card: id, zone: words }),
+    flow_card_approve: z.strictObject({ card: id, note: words.optional() }),
+    flow_card_send_back: z.strictObject({ card: id, note: words.optional() }),
+    /** An option by its number (from 1), or a reply that becomes the note. */
+    flow_card_choose: z.strictObject({ card: id, choice: z.int().nullable().optional(), note: z.unknown().optional() }),
+    flow_card_cancel: z.strictObject({ card: id }),
+    flow_card_comment: z.strictObject({ card: id, note: words }),
+    flow_card_assign: z.strictObject({ card: id, owner: words.nullable().optional() }),
+    flow_card_watch: z.strictObject({ card: id, watching: z.unknown().optional() }),
+    flow_script_save: z.strictObject({ repo: words, script: anyObject }),
+    flow_trigger_add: z.strictObject({ flow: id, trigger: nested }),
+    flow_trigger_pause: z.strictObject({ trigger: id }),
+    flow_trigger_resume: z.strictObject({ trigger: id }),
+    flow_trigger_remove: z.strictObject({ trigger: id }),
+    teammate_create: z.strictObject({ repo: words, template: z.unknown().optional(), name: z.unknown().optional(), soul: z.unknown().optional() }),
+    teammate_soul: z.strictObject({ teammate: id, soul: words }),
+    teammate_state: z.strictObject({ teammate: id, state: z.enum(["active", "paused", "removed"]) }),
+    teammate_note: z.strictObject({ teammate: id, note: words }),
+    teammate_answer: z.strictObject({ question: id, choice: z.unknown().optional(), text: z.unknown().optional() }),
+    teammate_tools: z.strictObject({
+        teammate: id, tool: words, change: z.enum(["grant", "revoke", "rule"]), action: z.unknown().optional(), use: z.unknown().optional(),
+        limitField: z.unknown().optional(), limitOver: z.unknown().optional(), undoWith: z.unknown().optional(),
+    }),
+    teammate_memory: z.strictObject({ teammate: id, memory: id, change: z.enum(["edit", "forget"]), text: z.unknown().optional() }),
+    teammate_routine: z.strictObject({ teammate: id, change: z.enum(["add", "remove"]), routine: z.unknown().optional(), schedule: z.unknown().optional(), text: z.unknown().optional() }),
+    teammate_undo: z.strictObject({ teammate: id, call: id }),
+    kit_setup: z.strictObject({ repo: words, kit: words }),
+    decision_record: z.strictObject({ repo: words, claim: words, why: words, supersedes: id.optional(), source: words.optional() }),
+    decision_retire: z.strictObject({ repo: words, decision: id, reason: words }),
+    /** The line, and (from 1) the line it replaces; 0 or none adds it. */
+    lead_about_you: z.strictObject({ line: words, replaces: z.int().min(0).optional() }),
+    scope_approve: z.strictObject({ task: words }),
+    result_accept: z.strictObject({ task: words, run: id }),
+    task_cancel: z.strictObject({ task: words }),
+    task_resume: z.strictObject({ task: words, run: id }),
+};
+export const CHAT_ACTION_OPERATIONS = Object.keys(chatActionRequestSchemas);
+/** The fields each action takes, from its schema. */
+export const CHAT_ACTION_FIELDS = Object.fromEntries(CHAT_ACTION_OPERATIONS.map(operation => [operation, Object.keys(chatActionRequestSchemas[operation].shape)]));
+const isOperation = (value) => typeof value === "string" && Object.hasOwn(chatActionRequestSchemas, value);
+/** One action's data, refused by path (`card: required`, `payload: unknown key 'cards' (did you mean card?)`). */
+export function readChatActionRequest(operation, input) {
+    return parseContract(chatActionRequestSchemas[operation], input);
+}
+export 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 const sharedActionSchema = versioned(SHARED_ACTION_VERSION, {
+    operation: z.enum(CHAT_ACTION_OPERATIONS),
+    request: anyObject,
+    repo: z.string(),
+    title: z.string(),
+    terms: z.array(z.string()),
+    stamp: z.string(),
+    state: anyObject,
+});
+const SHARED_ACTION_FIELDS = Object.keys(sharedActionSchema.shape).filter(field => field !== "version");
+/**
+ * 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 function upgradeUnversionedSharedAction(body) {
+    const out = { version: SHARED_ACTION_VERSION };
+    for (const field of SHARED_ACTION_FIELDS)
+        if (Object.hasOwn(body, field))
+            out[field] = body[field];
+    return out;
+}
+export const SHARED_ACTION_UPGRADES = { 0: upgradeUnversionedSharedAction };
+const under = (prefix, issues) => issues.map(issue => {
+    const path = issue.path === "payload" ? prefix : `${prefix}.${issue.path}`;
+    return { ...issue, path, line: `${path}${issue.line.slice(issue.path.length)}` };
+});
+/** Legacy readers checked only the envelope. Confirmation still prepares the request again before acting. */
+export function readSharedAction(input) {
+    const read = readVersioned(sharedActionSchema, input, SHARED_ACTION_UPGRADES);
+    if (!read.ok)
+        return read;
+    if (!isOperation(read.value.operation))
+        return { ok: false, issues: [{ path: "operation", kind: "bad-value", line: "operation: not an action" }] };
+    if (!Object.hasOwn(input, "version") || input["version"] === 0)
+        return read;
+    const request = readChatActionRequest(read.value.operation, read.value.request);
+    return request.ok ? read : { ok: false, issues: under("request", request.issues) };
+}

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

@@ -0,0 +1,59 @@
+/**
+ * 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-callback-rows.js

@@ -0,0 +1,46 @@
+/**
+ * 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 { parseContract } from "./contract.js";
+const when = z.string();
+/** A proposal card's button (chat-delivery.ts), with the part's message and the event's binding, channel and thread. */
+export const proposalActionRowSchema = z.strictObject({
+    token: z.string(),
+    part: z.int(),
+    proposal: z.int(),
+    phase: z.enum(["confirm", "dismiss", "yes", "cancel"]),
+    expires: when,
+    consumed: when.nullable(),
+    message: z.string().nullable(),
+    binding: z.int().nullable(),
+    channel: z.string(),
+    thread: z.string(),
+});
+export function readProposalActionRow(row) {
+    return parseContract(proposalActionRowSchema, row);
+}
+export const DECIDE_ACTS = ["accept", "changes", "retry", "approve", "not-now", "merge"];
+export const DECIDE_PHASES = ["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 const decideActionRowSchema = z.strictObject({
+    token: z.string().regex(/^d:[a-f0-9]{24}$/),
+    channel: z.string(),
+    binding: z.int(),
+    chat: z.string(),
+    message: z.string().nullable(),
+    act: z.enum(DECIDE_ACTS),
+    phase: z.enum(DECIDE_PHASES),
+    task_id: z.string(),
+    run: z.int().nullable(),
+    digest: z.string(),
+    created_at: when,
+    expires_at: when,
+    consumed_at: when.nullable(),
+});
+export function readDecideActionRow(row) {
+    return parseContract(decideActionRowSchema, row);
+}