toolroll 0.9.52 → 0.9.54

package/dist/cli.d.ts

@@ -80,6 +80,8 @@ export declare function extractOutputFlag(argv: readonly string[]): {
     error: string;
 };
 export declare function main(argv: readonly string[], write?: Write, mainOptions?: MainOptions): Promise<number>;
+/** What every former `toolroll routine …` command says now (v115; kept for this release only). */
+export declare const ROUTINES_MOVED = "Routines are now scheduled flows: see `toolroll flows list` (your routines were moved there).";
 export declare function partitionRoots(roots: readonly string[], exists: (path: string) => boolean): {
     present: string[];
     missing: string[];

package/dist/cli.js

@@ -255,7 +255,6 @@ export const OPERATE_COMMANDS = new Set([
     "publish",
     "reconcile",
     "run",
-    "routine",
     "flows",
     "config", "chat", "proposals", "mode", "chat-approval", "people", "tokens", "keys",
     "setup",
@@ -263,7 +262,6 @@ export const OPERATE_COMMANDS = new Set([
     "intake",
     "providers",
     "template",
-    "contest",
     "webhook",
     "sync",
 ]);
@@ -383,7 +381,17 @@ export async function main(argv, write = line => console.log(line), mainOptions
     }
     return code;
 }
+/** What every former `toolroll routine …` command says now (v115; kept for this release only). */
+export const ROUTINES_MOVED = "Routines are now scheduled flows: see `toolroll flows list` (your routines were moved there).";
+function routinesMoved(argv, write) {
+    write(argv.includes("--json") ? envelopeJson({ ok: true, command: "routine", message: ROUTINES_MOVED }) : ROUTINES_MOVED);
+    return 0;
+}
 async function dispatch(argv, write, mainOptions) {
+    // v115: routines became scheduled flows. Every old `routine …` invocation answers with one line pointing there —
+    // hidden from help and the contract, before anything remote or local opens, changing nothing.
+    if (argv[0] === "routine")
+        return routinesMoved(argv, write);
     // A saved API token sends commands marked remote to the central server, before anything local opens.
     if (argv[0] === 'health')
         return runHealthCommand(argv.slice(1), write, mainOptions.team ?? mainOptions.remote);

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

@@ -1,13 +1,17 @@
 /**
- * What Slack, Discord and Teams keep between steps (chat-delivery-state.ts): one schema for a received event's body
+ * What every chat app keeps between steps (chat-delivery-state.ts, and Telegram's store methods): one schema for a received event's body
  * (`chat_event.payload`, by the event's kind) and one for a planned message part (`chat_part.payload`), the message a
  * button rides and the content a delivery repaints. Both are saved with `version`; a body or part saved before they
  * carried one reads as it did then (its known fields; a reader then passed any others by unread).
  *
- * An event body lives only until the event is handled (then it is `{}`); a part lives as long as its message.
+ * An event body lives only until the event is handled (then it is `{}`; a Telegram message keeps its words as its
+ * record until its chat is unpaired); a part lives as long as its message.
  */
 import { z } from "zod";
 import { type ContractResult } from "./contract.js";
+/** A Toolroll button's one-time token, as every chat app carries it: 32 hex, or `d:` and 24 hex for a decide button
+ * (chat-decide.ts: a result's, plan's, failure's or pull request's own buttons). */
+export declare const CHAT_BUTTON_TOKEN: RegExp;
 /** One planned message part, as delivery reads it. */
 export declare const chatContentShape: {
     text: z.ZodString;
@@ -78,6 +82,31 @@ export declare const chatContentShape: {
     }, z.core.$strict>>;
     /** The lead's own reply, already shaped (reply-shape.ts): the channel renders its bold anchors and labelled links in its own format. */
     voice: z.ZodOptional<z.ZodLiteral<true>>;
+    /** Telegram: the person's message the first reply part answers. */
+    replyTo: z.ZodOptional<z.ZodString>;
+    /** Telegram: the part's buttons exactly as sent, their tokens minted with the part (a resend carries the same ones). */
+    keyboard: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        callback_data: z.ZodString;
+    }, z.core.$loose>>>>;
+    /** Telegram: a proposal card, still one after its proposal is gone. */
+    card: z.ZodOptional<z.ZodLiteral<true>>;
+    /** A result's, plan's, failure's or pull request's own buttons (chat-decide.ts), minted with the part: each an act's
+     * one-time token or a link. They ride the message once it is sent. */
+    decide: z.ZodOptional<z.ZodObject<{
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            label: z.ZodString;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            label: z.ZodString;
+            link: z.ZodObject<{
+                label: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>;
+    /** The "What should change?" this part asks (chat-decide.ts): a reply to its message is the feedback. */
+    prompt: z.ZodOptional<z.ZodInt>;
 };
 export declare const chatContentSchema: z.ZodObject<{
     text: z.ZodString;
@@ -138,6 +167,25 @@ export declare const chatContentSchema: z.ZodObject<{
         options: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
     voice: z.ZodOptional<z.ZodLiteral<true>>;
+    replyTo: z.ZodOptional<z.ZodString>;
+    keyboard: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        callback_data: z.ZodString;
+    }, z.core.$loose>>>>;
+    card: z.ZodOptional<z.ZodLiteral<true>>;
+    decide: z.ZodOptional<z.ZodObject<{
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            label: z.ZodString;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            label: z.ZodString;
+            link: z.ZodObject<{
+                label: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>;
+    prompt: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 export type ChatContent = z.infer<typeof chatContentSchema>;
 export declare const CHAT_PART_VERSION = 1;
@@ -201,6 +249,25 @@ export declare const savedChatPartSchema: z.ZodObject<{
         options: z.ZodArray<z.ZodString>;
     }, z.core.$strict>>;
     voice: z.ZodOptional<z.ZodLiteral<true>>;
+    replyTo: z.ZodOptional<z.ZodString>;
+    keyboard: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        callback_data: z.ZodString;
+    }, z.core.$loose>>>>;
+    card: z.ZodOptional<z.ZodLiteral<true>>;
+    decide: z.ZodOptional<z.ZodObject<{
+        rows: z.ZodArray<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            label: z.ZodString;
+            token: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            label: z.ZodString;
+            link: z.ZodObject<{
+                label: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>;
+    prompt: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 /** A saved part's content (`version` is the saved form's, not the content's). */
 export declare function readChatPart(raw: string): ContractResult<ChatContent>;
@@ -227,6 +294,8 @@ export declare const chatMessageBodySchema: z.ZodObject<{
         run: z.ZodNullable<z.ZodInt>;
     }, z.core.$strict>>;
     lead: z.ZodOptional<z.ZodLiteral<true>>;
+    context: z.ZodOptional<z.ZodString>;
+    request: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 /**
  * A button: the one-time token it carried, or, when the app's callback came from the paired person but its data

package/dist/contracts/chat-content.js

@@ -1,15 +1,19 @@
 /**
- * What Slack, Discord and Teams keep between steps (chat-delivery-state.ts): one schema for a received event's body
+ * What every chat app keeps between steps (chat-delivery-state.ts, and Telegram's store methods): one schema for a received event's body
  * (`chat_event.payload`, by the event's kind) and one for a planned message part (`chat_part.payload`), the message a
  * button rides and the content a delivery repaints. Both are saved with `version`; a body or part saved before they
  * carried one reads as it did then (its known fields; a reader then passed any others by unread).
  *
- * An event body lives only until the event is handled (then it is `{}`); a part lives as long as its message.
+ * An event body lives only until the event is handled (then it is `{}`; a Telegram message keeps its words as its
+ * record until its chat is unpaired); a part lives as long as its message.
  */
 import { z } from "zod";
 import { parseContract, readVersioned, versioned } from "./contract.js";
 const id = z.int().min(1);
 const link = z.strictObject({ label: z.string(), path: z.string() });
+/** A Toolroll button's one-time token, as every chat app carries it: 32 hex, or `d:` and 24 hex for a decide button
+ * (chat-decide.ts: a result's, plan's, failure's or pull request's own buttons). */
+export const CHAT_BUTTON_TOKEN = /^(?:[a-f0-9]{32}|d:[a-f0-9]{24})$/;
 /** One planned message part, as delivery reads it. */
 export const chatContentShape = {
     text: z.string(),
@@ -39,6 +43,17 @@ export const chatContentShape = {
     ask: z.strictObject({ turn: id, options: z.array(z.string()) }).optional(),
     /** The lead's own reply, already shaped (reply-shape.ts): the channel renders its bold anchors and labelled links in its own format. */
     voice: z.literal(true).optional(),
+    /** Telegram: the person's message the first reply part answers. */
+    replyTo: z.string().optional(),
+    /** Telegram: the part's buttons exactly as sent, their tokens minted with the part (a resend carries the same ones). */
+    keyboard: z.array(z.array(z.looseObject({ text: z.string(), callback_data: z.string() }))).optional(),
+    /** Telegram: a proposal card, still one after its proposal is gone. */
+    card: z.literal(true).optional(),
+    /** A result's, plan's, failure's or pull request's own buttons (chat-decide.ts), minted with the part: each an act's
+     * one-time token or a link. They ride the message once it is sent. */
+    decide: z.strictObject({ rows: z.array(z.array(z.union([z.strictObject({ label: z.string(), token: z.string().regex(CHAT_BUTTON_TOKEN) }), z.strictObject({ label: z.string(), link })]))) }).optional(),
+    /** The "What should change?" this part asks (chat-decide.ts): a reply to its message is the feedback. */
+    prompt: id.optional(),
 };
 export const chatContentSchema = z.strictObject(chatContentShape);
 export const CHAT_PART_VERSION = 1;
@@ -92,12 +107,16 @@ export const chatMessageBodySchema = versioned(CHAT_EVENT_VERSION, {
     unsupported: z.string().optional(),
     about: z.strictObject({ task: z.string(), run: z.int().nullable() }).optional(),
     lead: z.literal(true).optional(),
+    /** Telegram: the server-authored context its turn carries (the exact task or result a reply bound to). */
+    context: z.string().optional(),
+    /** Telegram: the request identity the lead's engine receipts the turn under. */
+    request: z.string().optional(),
 });
 /**
  * A button: the one-time token it carried, or, when the app's callback came from the paired person but its data
  * couldn't be read, the path-named line saying why — answered plainly, and nothing is done.
  */
-export const chatTokenBodySchema = versioned(CHAT_EVENT_VERSION, { token: z.string().regex(/^[a-f0-9]{32}$/, { error: "must be a Toolroll button token" }) });
+export const chatTokenBodySchema = versioned(CHAT_EVENT_VERSION, { token: z.string().regex(CHAT_BUTTON_TOKEN, { error: "must be a Toolroll button token" }) });
 export const chatProblemBodySchema = versioned(CHAT_EVENT_VERSION, { problem: z.string().min(1) });
 export const chatActionBodySchema = z.union([chatTokenBodySchema, chatProblemBodySchema]);
 /** A notice carries its parts, not a body. */

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

@@ -1,6 +1,13 @@
 /**
- * The Slack, Discord and Teams receipt tables (chat-delivery-state.ts keeps their rows). A leaf: it imports nothing, so
- * the store can create these tables without loading the chat state modules that themselves import the store.
+ * The one set of chat tables every chat app shares (v116): Telegram, Slack, Discord and Teams keep their pairings,
+ * received events, planned message parts, buttons, rooms and delivery receipts here, each row keyed by `provider`.
+ * A row's identity is (provider, id): ids carried over from the per-app tables keep their numbers, and nothing infers
+ * the app from an id. A leaf: it imports nothing, so the store creates these tables without loading the chat modules.
  */
-export declare const chatSchema: (channel: "slack" | "discord" | "teams") => string;
-export declare const chatTables: (channel: "slack" | "discord" | "teams") => string[];
+export declare const CHAT_PROVIDERS: readonly ["telegram", "slack", "discord", "teams"];
+export type ChatProvider = (typeof CHAT_PROVIDERS)[number];
+export declare const isChatProvider: (value: unknown) => value is ChatProvider;
+export declare const CHAT_SCHEMA: string;
+/** Every shared chat table, parents before children. */
+export declare const CHAT_TABLES: readonly ["chat_binding", "chat_pair", "chat_event", "chat_part", "chat_action", "chat_progress", "chat_runtime", "chat_room", "chat_meta", "chat_flow_action", "chat_flow_prompt", "chat_flow_choice", "chat_flow_note", "chat_question_action", "chat_question_prompt", "chat_ask_action", "chat_message_ref", "chat_note_draft", "chat_digest"];
+export type ChatTable = (typeof CHAT_TABLES)[number];

package/dist/contracts/chat-tables.js

@@ -1,129 +1,197 @@
 /**
- * The Slack, Discord and Teams receipt tables (chat-delivery-state.ts keeps their rows). A leaf: it imports nothing, so
- * the store can create these tables without loading the chat state modules that themselves import the store.
+ * The one set of chat tables every chat app shares (v116): Telegram, Slack, Discord and Teams keep their pairings,
+ * received events, planned message parts, buttons, rooms and delivery receipts here, each row keyed by `provider`.
+ * A row's identity is (provider, id): ids carried over from the per-app tables keep their numbers, and nothing infers
+ * the app from an id. A leaf: it imports nothing, so the store creates these tables without loading the chat modules.
  */
-const CHAT_SCHEMA = `
+export const CHAT_PROVIDERS = ["telegram", "slack", "discord", "teams"];
+export const isChatProvider = (value) => CHAT_PROVIDERS.includes(value);
+const PROVIDER = `provider TEXT NOT NULL CHECK (provider IN (${CHAT_PROVIDERS.map(one => `'${one}'`).join(",")}))`;
+export const CHAT_SCHEMA = `
+-- One person's chat in one app, speaking as one approver generation. Revoked, never deleted.
+-- installation: the bot (Telegram) or workspace app; member: the app's user id; channel: their private chat.
 CREATE TABLE IF NOT EXISTS chat_binding (
- id INTEGER PRIMARY KEY AUTOINCREMENT, installation TEXT NOT NULL,
- team TEXT NOT NULL, app TEXT NOT NULL, member TEXT NOT NULL, channel TEXT NOT NULL,
- approver TEXT NOT NULL, generation INTEGER NOT NULL, created TEXT NOT NULL, revoked TEXT
-);
-CREATE UNIQUE INDEX IF NOT EXISTS chat_one_binding_member ON chat_binding(installation, member) WHERE revoked IS NULL;
+ ${PROVIDER}, id INTEGER NOT NULL, installation TEXT NOT NULL, team TEXT NOT NULL, app TEXT NOT NULL,
+ member TEXT NOT NULL, channel TEXT NOT NULL, approver TEXT NOT NULL, generation INTEGER NOT NULL,
+ created TEXT NOT NULL, created_by TEXT, pair_event TEXT, revoked TEXT, revoked_by TEXT,
+ PRIMARY KEY (provider, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS chat_binding_live ON chat_binding(provider, installation, member) WHERE revoked IS NULL;
+CREATE INDEX IF NOT EXISTS chat_binding_approver ON chat_binding(provider, approver) WHERE revoked IS NULL;
+-- One-time pairing codes, by hash. installation NULL: any installation of the app (a Telegram code works on its bot).
 CREATE TABLE IF NOT EXISTS chat_pair (
- hash TEXT PRIMARY KEY, installation TEXT NOT NULL, approver TEXT NOT NULL,
- generation INTEGER NOT NULL, expires TEXT NOT NULL, consumed TEXT
+ ${PROVIDER}, hash TEXT NOT NULL, installation TEXT, approver TEXT NOT NULL, generation INTEGER NOT NULL,
+ created TEXT, created_by TEXT, expires TEXT NOT NULL, consumed TEXT, consumed_channel TEXT, consumed_member TEXT, consumed_event TEXT,
+ PRIMARY KEY (provider, hash)
 );
+-- Everything an app sent us, once each (the key is the idempotency). kind 'update' is an applied (or pushed and
+-- waiting) Telegram update; 'message' is a message the lead answers, queued to running to done or failed.
+-- session: the lead session its turn was dispatched under, a pointer to its receipt (never an authority).
 CREATE TABLE IF NOT EXISTS chat_event (
- id TEXT PRIMARY KEY, installation TEXT NOT NULL, binding INTEGER REFERENCES chat_binding(id),
- kind TEXT NOT NULL CHECK(kind IN ('message','action','pair','notice')),
+ ${PROVIDER}, id TEXT NOT NULL, installation TEXT NOT NULL, binding INTEGER,
+ kind TEXT NOT NULL CHECK (kind IN ('message','action','pair','notice','update')),
  channel TEXT NOT NULL, member TEXT NOT NULL, ts TEXT NOT NULL, thread TEXT NOT NULL,
- payload TEXT NOT NULL, created TEXT NOT NULL,
- session INTEGER REFERENCES mate_session(id), state TEXT NOT NULL DEFAULT 'queued' CHECK(state IN ('queued','done','dropped')),
- next_at TEXT, problem TEXT
-);
-CREATE INDEX IF NOT EXISTS chat_pending_event ON chat_event(installation,state,next_at);
+ payload TEXT NOT NULL, created TEXT NOT NULL, session INTEGER,
+ state TEXT NOT NULL DEFAULT 'queued' CHECK (state IN ('queued','running','done','failed','dropped')),
+ next_at TEXT, problem TEXT, claim_owner TEXT, claim_until TEXT, attempts INTEGER NOT NULL DEFAULT 0,
+ turn INTEGER, started TEXT, finished TEXT, result TEXT, reply TEXT,
+ PRIMARY KEY (provider, id),
+ FOREIGN KEY (provider, binding) REFERENCES chat_binding(provider, id)
+);
+CREATE INDEX IF NOT EXISTS chat_event_pending ON chat_event(provider, installation, state, next_at);
+CREATE INDEX IF NOT EXISTS chat_event_binding ON chat_event(provider, binding, state);
+-- What we send, planned before any send and marked sent only on the app's own message id.
 CREATE TABLE IF NOT EXISTS chat_part (
- id INTEGER PRIMARY KEY AUTOINCREMENT, event TEXT NOT NULL REFERENCES chat_event(id), ordinal INTEGER NOT NULL,
- payload TEXT NOT NULL, state TEXT NOT NULL DEFAULT 'pending' CHECK(state IN ('pending','sent','dropped')),
+ ${PROVIDER}, id INTEGER NOT NULL, event TEXT NOT NULL, ordinal INTEGER NOT NULL, payload TEXT NOT NULL,
+ state TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','sent','dropped')),
  message TEXT, file TEXT, uploaded INTEGER NOT NULL DEFAULT 0, attempts INTEGER NOT NULL DEFAULT 0,
- uncertain INTEGER NOT NULL DEFAULT 0, next_at TEXT, problem TEXT, created TEXT NOT NULL,
- UNIQUE(event,ordinal)
-);
+ uncertain INTEGER NOT NULL DEFAULT 0, next_at TEXT, problem TEXT, created TEXT NOT NULL, sent TEXT,
+ PRIMARY KEY (provider, id), UNIQUE (provider, event, ordinal),
+ FOREIGN KEY (provider, event) REFERENCES chat_event(provider, id)
+);
+CREATE INDEX IF NOT EXISTS chat_part_pending ON chat_part(provider, state, next_at);
+CREATE INDEX IF NOT EXISTS chat_part_message ON chat_part(provider, message);
+-- A lead proposal's buttons (proposal), or a builder decision's (decision, option_id), one opaque token each.
+-- A button rides its planned part, or (Telegram) the binding, chat and message it was placed on.
 CREATE TABLE IF NOT EXISTS chat_action (
- token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
- proposal INTEGER NOT NULL REFERENCES mate_proposal(id), phase TEXT NOT NULL CHECK(phase IN ('confirm','dismiss','yes','cancel')),
- expires TEXT NOT NULL, consumed TEXT
-);
+ ${PROVIDER}, token TEXT NOT NULL, part INTEGER, binding INTEGER, chat TEXT, message TEXT,
+ proposal INTEGER REFERENCES mate_proposal(id) ON DELETE CASCADE,
+ decision INTEGER REFERENCES decision(id) ON DELETE CASCADE, option_id TEXT, note_digest TEXT,
+ phase TEXT NOT NULL CHECK (phase IN ('confirm','dismiss','yes','cancel','choose')),
+ created TEXT, expires TEXT, consumed TEXT,
+ PRIMARY KEY (provider, token),
+ CHECK ((proposal IS NULL) <> (decision IS NULL)),
+ FOREIGN KEY (provider, part) REFERENCES chat_part(provider, id)
+);
+CREATE INDEX IF NOT EXISTS chat_action_part ON chat_action(provider, part);
+CREATE INDEX IF NOT EXISTS chat_action_proposal ON chat_action(proposal);
+CREATE INDEX IF NOT EXISTS chat_action_decision ON chat_action(decision);
 CREATE TABLE IF NOT EXISTS chat_progress (
- binding INTEGER NOT NULL REFERENCES chat_binding(id), run INTEGER NOT NULL REFERENCES run(id),
- part INTEGER NOT NULL REFERENCES chat_part(id), digest TEXT NOT NULL,
- PRIMARY KEY(binding,run)
+ ${PROVIDER}, binding INTEGER NOT NULL, run INTEGER NOT NULL REFERENCES run(id), part INTEGER NOT NULL, digest TEXT NOT NULL,
+ PRIMARY KEY (provider, binding, run),
+ FOREIGN KEY (provider, binding) REFERENCES chat_binding(provider, id),
+ FOREIGN KEY (provider, part) REFERENCES chat_part(provider, id)
 );
+-- One live worker per installation (lease, its generation and the poll cursor), its connection and retry state,
+-- the newest notification its notices started from, and where (Telegram) pushes updates.
 CREATE TABLE IF NOT EXISTS chat_runtime (
- installation TEXT PRIMARY KEY, owner TEXT, lease_until TEXT, connected TEXT,
- problem TEXT, retry_at TEXT, notification INTEGER NOT NULL DEFAULT 0
+ ${PROVIDER}, installation TEXT NOT NULL, owner TEXT, lease_until TEXT, generation INTEGER NOT NULL DEFAULT 0,
+ cursor INTEGER NOT NULL DEFAULT 0, heartbeat TEXT, connected TEXT, problem TEXT, retry_at TEXT,
+ notification INTEGER NOT NULL DEFAULT 0, push_url TEXT, push_at TEXT, push_problem TEXT,
+ PRIMARY KEY (provider, installation)
 );
-`;
-/** v73: a chat's place in the shared team conversations — a channel follows one
- * conversation, a DM may select one. Rows are revoked, never deleted. */
-const CHAT_ROOM_SCHEMA = `
+-- A chat's place in the shared team conversations: a group follows one conversation, a private chat may select one.
 CREATE TABLE IF NOT EXISTS chat_room (
- id INTEGER PRIMARY KEY AUTOINCREMENT, installation TEXT NOT NULL, chat TEXT NOT NULL,
- kind TEXT NOT NULL CHECK(kind IN ('group','private')), conversation TEXT NOT NULL,
- binding INTEGER NOT NULL REFERENCES chat_binding(id),
- bound_by TEXT NOT NULL, bound TEXT NOT NULL, cursor INTEGER NOT NULL DEFAULT 0,
- revoked TEXT, revoked_by TEXT
-);
-CREATE UNIQUE INDEX IF NOT EXISTS chat_room_live ON chat_room(installation, chat) WHERE revoked IS NULL;
-CREATE UNIQUE INDEX IF NOT EXISTS chat_room_group ON chat_room(conversation) WHERE revoked IS NULL AND kind='group';
+ ${PROVIDER}, id INTEGER NOT NULL, installation TEXT NOT NULL, chat TEXT NOT NULL,
+ kind TEXT NOT NULL CHECK (kind IN ('group','private')), conversation TEXT NOT NULL REFERENCES team_conversation(id),
+ binding INTEGER NOT NULL, bound_by TEXT NOT NULL, bound TEXT NOT NULL, cursor INTEGER NOT NULL DEFAULT 0,
+ revoked TEXT, revoked_by TEXT,
+ PRIMARY KEY (provider, id),
+ FOREIGN KEY (provider, binding) REFERENCES chat_binding(provider, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS chat_room_live ON chat_room(provider, installation, chat) WHERE revoked IS NULL;
+CREATE UNIQUE INDEX IF NOT EXISTS chat_room_group ON chat_room(provider, conversation) WHERE revoked IS NULL AND kind = 'group';
+-- Small transport facts an app must remember per chat (a Teams service URL). Never credentials.
 CREATE TABLE IF NOT EXISTS chat_meta (
- installation TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, updated TEXT NOT NULL,
- PRIMARY KEY(installation, key)
+ ${PROVIDER}, installation TEXT NOT NULL, key TEXT NOT NULL, value TEXT NOT NULL, updated TEXT NOT NULL,
+ PRIMARY KEY (provider, installation, key)
 );
-`;
-/** v88: flow decisions in the chat app, as on Telegram (telegram-flow.ts).
- * A button is one opaque token for one visit (card, entry) of one card, on
- * the part it rides; Edit and Send back open a prompt the person's next
- * message in their DM answers. */
-const CHAT_FLOW_SCHEMA = `
+-- A flow decision's buttons (Approve, Edit, Send back, and the Yes or Cancel Approve arms) for one visit of one card.
 CREATE TABLE IF NOT EXISTS chat_flow_action (
- token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
+ ${PROVIDER}, token TEXT NOT NULL, part INTEGER, binding INTEGER, chat TEXT, message TEXT,
  card INTEGER NOT NULL REFERENCES flow_card(id), entry INTEGER NOT NULL,
- action TEXT NOT NULL CHECK(action IN ('approve','edit','send-back')), expires TEXT NOT NULL, consumed TEXT
+ action TEXT NOT NULL CHECK (action IN ('approve','edit','send-back','yes','cancel')),
+ created TEXT, expires TEXT NOT NULL, consumed TEXT,
+ PRIMARY KEY (provider, token),
+ FOREIGN KEY (provider, part) REFERENCES chat_part(provider, id)
 );
 CREATE INDEX IF NOT EXISTS chat_flow_action_visit ON chat_flow_action(card, entry);
+CREATE INDEX IF NOT EXISTS chat_flow_action_part ON chat_flow_action(provider, part);
+-- Edit and Send back wait for the person's next message (or, on Telegram, a reply to the prompt message).
 CREATE TABLE IF NOT EXISTS chat_flow_prompt (
- id INTEGER PRIMARY KEY AUTOINCREMENT, binding INTEGER NOT NULL REFERENCES chat_binding(id),
+ ${PROVIDER}, id INTEGER NOT NULL, binding INTEGER NOT NULL, chat TEXT, message TEXT,
  card INTEGER NOT NULL REFERENCES flow_card(id), entry INTEGER NOT NULL,
- mode TEXT NOT NULL CHECK(mode IN ('edit','send-back')), created TEXT NOT NULL, expires TEXT NOT NULL, consumed TEXT
+ mode TEXT NOT NULL CHECK (mode IN ('edit','send-back')), created TEXT NOT NULL, expires TEXT NOT NULL, consumed TEXT,
+ PRIMARY KEY (provider, id)
 );
-CREATE INDEX IF NOT EXISTS chat_flow_prompt_open ON chat_flow_prompt(binding, consumed);
-`;
-/** A flow's "Person chooses" zone in the chat app (flow-send.ts): one button per option (choice is its index, label its words
- * when sent) for one visit of one card, on the part it rides. A reply in that notice's thread is the note; chat_flow_note
- * is "Use this as your note?" Yes / No about one other message (held: its event; words: what it said, kept only until
- * answered, as an event's own payload is cleared once it is handled), asked once per visit.
- * Never in CHAT_TABLES: an older database has no such table until this schema creates it. */
-const CHAT_FLOW_CHOICE_SCHEMA = `
+CREATE INDEX IF NOT EXISTS chat_flow_prompt_open ON chat_flow_prompt(provider, binding, consumed);
+CREATE UNIQUE INDEX IF NOT EXISTS chat_flow_prompt_message ON chat_flow_prompt(provider, chat, message) WHERE message IS NOT NULL;
+-- A flow's "Person chooses" buttons: one per option (choice is its index, label its words when sent).
 CREATE TABLE IF NOT EXISTS chat_flow_choice (
- token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
+ ${PROVIDER}, token TEXT NOT NULL, part INTEGER, binding INTEGER, chat TEXT, message TEXT,
  card INTEGER NOT NULL REFERENCES flow_card(id), entry INTEGER NOT NULL,
- choice INTEGER NOT NULL, label TEXT NOT NULL, expires TEXT NOT NULL, consumed TEXT
+ choice INTEGER NOT NULL, label TEXT NOT NULL, created TEXT, expires TEXT NOT NULL, consumed TEXT,
+ PRIMARY KEY (provider, token),
+ FOREIGN KEY (provider, part) REFERENCES chat_part(provider, id)
 );
 CREATE INDEX IF NOT EXISTS chat_flow_choice_visit ON chat_flow_choice(card, entry);
+CREATE INDEX IF NOT EXISTS chat_flow_choice_part ON chat_flow_choice(provider, part);
+-- "Use this as your note?" Yes / No about the person's message held (its event; words kept only until answered).
 CREATE TABLE IF NOT EXISTS chat_flow_note (
- token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
+ ${PROVIDER}, token TEXT NOT NULL, part INTEGER NOT NULL,
  card INTEGER NOT NULL REFERENCES flow_card(id), entry INTEGER NOT NULL,
- held TEXT NOT NULL, words TEXT, answer TEXT NOT NULL CHECK(answer IN ('yes','no')), expires TEXT NOT NULL, consumed TEXT
+ held TEXT NOT NULL, words TEXT, answer TEXT NOT NULL CHECK (answer IN ('yes','no')), expires TEXT NOT NULL, consumed TEXT,
+ PRIMARY KEY (provider, token),
+ FOREIGN KEY (provider, part) REFERENCES chat_part(provider, id)
 );
 CREATE INDEX IF NOT EXISTS chat_flow_note_visit ON chat_flow_note(card, entry);
-`;
-/** v93: a teammate's question in the chat app. One button per option (choice)
- * and one to answer in words (choice NULL); that one opens a prompt the
- * person's next message in their DM answers. Never in CHAT_TABLES: an older
- * database has no such tables until this schema creates them. */
-const CHAT_QUESTION_SCHEMA = `
+-- A teammate's question: one button per option and one to answer in words (choice NULL).
 CREATE TABLE IF NOT EXISTS chat_question_action (
- token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id),
- question INTEGER NOT NULL REFERENCES teammate_question(id), choice TEXT, expires TEXT NOT NULL, consumed TEXT
+ ${PROVIDER}, token TEXT NOT NULL, part INTEGER, binding INTEGER, chat TEXT, message TEXT,
+ question INTEGER NOT NULL REFERENCES teammate_question(id), choice TEXT, created TEXT, expires TEXT NOT NULL, consumed TEXT,
+ PRIMARY KEY (provider, token),
+ FOREIGN KEY (provider, part) REFERENCES chat_part(provider, id)
 );
 CREATE INDEX IF NOT EXISTS chat_question_action_question ON chat_question_action(question);
 CREATE TABLE IF NOT EXISTS chat_question_prompt (
- id INTEGER PRIMARY KEY AUTOINCREMENT, binding INTEGER NOT NULL REFERENCES chat_binding(id),
- question INTEGER NOT NULL REFERENCES teammate_question(id), created TEXT NOT NULL, expires TEXT NOT NULL, consumed TEXT
+ ${PROVIDER}, id INTEGER NOT NULL, binding INTEGER NOT NULL, chat TEXT, message TEXT,
+ question INTEGER NOT NULL REFERENCES teammate_question(id), created TEXT NOT NULL, expires TEXT NOT NULL, consumed TEXT,
+ PRIMARY KEY (provider, id)
 );
-CREATE INDEX IF NOT EXISTS chat_question_prompt_open ON chat_question_prompt(binding, consumed);
-`;
-/** The lead's question to its owner (ask_owner) in the chat app: one button per option (choice is its index) and one for
- * "Something else" (choice NULL). A tap sends the option as the owner's next message. Never in CHAT_TABLES. */
-const CHAT_ASK_SCHEMA = `
+CREATE INDEX IF NOT EXISTS chat_question_prompt_open ON chat_question_prompt(provider, binding, consumed);
+CREATE UNIQUE INDEX IF NOT EXISTS chat_question_prompt_message ON chat_question_prompt(provider, chat, message) WHERE message IS NOT NULL;
+-- The lead's question to its owner (ask_owner): one button per option and one for "Something else" (choice NULL).
 CREATE TABLE IF NOT EXISTS chat_ask_action (
- token TEXT PRIMARY KEY, part INTEGER NOT NULL REFERENCES chat_part(id) ON DELETE CASCADE,
- turn INTEGER NOT NULL, choice INTEGER, expires TEXT NOT NULL, consumed TEXT
+ ${PROVIDER}, token TEXT NOT NULL, part INTEGER NOT NULL, turn INTEGER NOT NULL, choice INTEGER, expires TEXT NOT NULL, consumed TEXT,
+ PRIMARY KEY (provider, token),
+ FOREIGN KEY (provider, part) REFERENCES chat_part(provider, id) ON DELETE CASCADE
 );
 CREATE INDEX IF NOT EXISTS chat_ask_action_turn ON chat_ask_action(turn);
+-- What one sent message carried, so a reply to it is about exactly that: a notification (kind 'notification', one row
+-- per notification it showed), a builder decision ('decision') or the task a status showed ('task').
+CREATE TABLE IF NOT EXISTS chat_message_ref (
+ ${PROVIDER}, binding INTEGER NOT NULL, chat TEXT NOT NULL, message TEXT NOT NULL,
+ kind TEXT NOT NULL CHECK (kind IN ('notification','decision','task')),
+ notification INTEGER REFERENCES notification(id), destination TEXT, project TEXT,
+ task_ref INTEGER REFERENCES task_ref(id), task_id TEXT, run INTEGER,
+ decision INTEGER REFERENCES decision(id) ON DELETE CASCADE, created TEXT NOT NULL,
+ CHECK ((kind = 'notification') = (notification IS NOT NULL AND destination IS NOT NULL)),
+ CHECK ((kind = 'decision') = (decision IS NOT NULL)),
+ CHECK (kind <> 'task' OR task_id IS NOT NULL)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS chat_message_ref_notification ON chat_message_ref(provider, binding, chat, message, notification) WHERE kind = 'notification';
+CREATE UNIQUE INDEX IF NOT EXISTS chat_message_ref_one ON chat_message_ref(provider, binding, chat, message, kind) WHERE kind <> 'notification';
+CREATE INDEX IF NOT EXISTS chat_message_ref_destination ON chat_message_ref(destination, notification);
+CREATE INDEX IF NOT EXISTS chat_message_ref_task ON chat_message_ref(destination, task_ref) WHERE kind = 'notification';
+-- A note typed as a reply to a builder decision, held until a tap answers with it. Only a later event replaces it.
+CREATE TABLE IF NOT EXISTS chat_note_draft (
+ ${PROVIDER}, id INTEGER NOT NULL, binding INTEGER NOT NULL,
+ decision INTEGER NOT NULL REFERENCES decision(id) ON DELETE CASCADE, event INTEGER NOT NULL,
+ message TEXT NOT NULL, reply_to TEXT NOT NULL, note TEXT NOT NULL,
+ state TEXT NOT NULL DEFAULT 'pending' CHECK (state IN ('pending','armed','superseded','consumed','discarded')),
+ created TEXT NOT NULL, expires TEXT NOT NULL,
+ PRIMARY KEY (provider, id),
+ FOREIGN KEY (provider, binding) REFERENCES chat_binding(provider, id)
+);
+CREATE UNIQUE INDEX IF NOT EXISTS chat_note_draft_live ON chat_note_draft(provider, binding, decision) WHERE state IN ('pending','armed');
+-- Away mode: routine facts wait and go as one digest every every_ms (null: each fact as it lands).
+CREATE TABLE IF NOT EXISTS chat_digest (
+ ${PROVIDER}, every_ms INTEGER, set_by TEXT, set_at TEXT, last_sent_at TEXT,
+ PRIMARY KEY (provider)
+);
 `;
-const CHAT_TABLES = [
+/** Every shared chat table, parents before children. */
+export const CHAT_TABLES = [
     "chat_binding",
     "chat_pair",
     "chat_event",
@@ -131,6 +199,16 @@ const CHAT_TABLES = [
     "chat_action",
     "chat_progress",
     "chat_runtime",
+    "chat_room",
+    "chat_meta",
+    "chat_flow_action",
+    "chat_flow_prompt",
+    "chat_flow_choice",
+    "chat_flow_note",
+    "chat_question_action",
+    "chat_question_prompt",
+    "chat_ask_action",
+    "chat_message_ref",
+    "chat_note_draft",
+    "chat_digest",
 ];
-export const chatSchema = (channel) => (CHAT_SCHEMA + CHAT_ROOM_SCHEMA + CHAT_FLOW_SCHEMA + CHAT_FLOW_CHOICE_SCHEMA + CHAT_QUESTION_SCHEMA + CHAT_ASK_SCHEMA).replaceAll("chat_", `${channel}_`);
-export const chatTables = (channel) => CHAT_TABLES.map((name) => name.replace("chat_", `${channel}_`));

package/dist/contracts/cli.d.ts

@@ -563,7 +563,6 @@ export declare const COMMAND_OUTPUTS: {
         approval: z.ZodObject<{
             approved: z.ZodBoolean;
         }, z.core.$loose>;
-        risk: z.ZodString;
         route: z.ZodUnknown;
         runs: z.ZodArray<z.ZodUnknown>;
         deliverable: z.ZodString;
@@ -684,18 +683,6 @@ export declare const COMMAND_OUTPUTS: {
         reason: z.ZodString;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>], "ok">;
-    readonly "routine list": z.ZodDiscriminatedUnion<[z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<true>;
-        command: z.ZodLiteral<"routine list">;
-        routines: z.ZodArray<z.ZodUnknown>;
-    }, z.core.$loose>, z.ZodObject<{
-        envelopeVersion: z.ZodLiteral<1>;
-        ok: z.ZodLiteral<false>;
-        command: z.ZodLiteral<"routine list">;
-        reason: z.ZodString;
-        message: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>], "ok">;
     readonly "incident list": z.ZodDiscriminatedUnion<[z.ZodObject<{
         envelopeVersion: z.ZodLiteral<1>;
         ok: z.ZodLiteral<true>;

package/dist/contracts/cli.js

@@ -140,7 +140,6 @@ const taskShowOutput = answers("task show", {
     position: z.unknown(),
     reservedFor: nullable(str),
     approval: z.looseObject({ approved: z.boolean() }),
-    risk: str,
     route: z.unknown(),
     runs: list,
     deliverable: str,
@@ -188,7 +187,6 @@ export const COMMAND_OUTPUTS = {
     "flows show": answers("flows show", { flow: z.looseObject({ id: int, name: str, repo: str, project: str, readable: z.boolean(), zones: list, triggers: list }) }),
     grants: answers("grants", { count: int, grants: list }),
     "runner list": answers("runner list", { count: int, runners: list }),
-    "routine list": answers("routine list", { routines: list }),
     "incident list": answers("incident list", { incidents: list }),
     "outbox list": answers("outbox list", { notifications: rows({ id: int, kind: str, subject: str, createdAt: str }) }),
     // A pass with failed deliveries answers ok: false with its counts and no reason.