toolroll 0.9.53 → 0.9.54

package/dist/chat-quiet.d.ts

@@ -11,6 +11,9 @@ export type QuietView = {
     also?: PhoneTaskLink[];
     target?: DecideTarget;
 };
+/** What still wants a person who pairs after it landed, in every chat app: an open decision or an unresolved attention
+ * notice. Routine history is never replayed to a chat that just arrived (store.ts WANTED_BEFORE_PAIRING, the same rule). */
+export declare function wantedBeforePairing(row: Pick<Notification, "dedupeKey" | "pushClass" | "resolvedAt">): boolean;
 export declare function needsPerson(row: Pick<Notification, "dedupeKey" | "kind" | "pushClass" | "recipient">): boolean;
 /** A fact about one placed task: in quiet mode it lands on that task's card. */
 export declare function isTaskFact(row: Pick<Notification, "taskRef" | "taskId" | "project">): row is typeof row & {

package/dist/chat-quiet.js

@@ -20,6 +20,11 @@ const NEEDED_KINDS = new Set([
     "acceptance-ready", "acceptance-evidence", "flow-decision", "flow-card", "plan-ready", "report-ready",
     "stale-approval", "security-release", "secret-detected",
 ]);
+/** What still wants a person who pairs after it landed, in every chat app: an open decision or an unresolved attention
+ * notice. Routine history is never replayed to a chat that just arrived (store.ts WANTED_BEFORE_PAIRING, the same rule). */
+export function wantedBeforePairing(row) {
+    return row.resolvedAt === null && (row.dedupeKey.startsWith("decision:") || row.pushClass === "attention");
+}
 export function needsPerson(row) {
     if (row.recipient !== null)
         return true;

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/discord-callback.js

@@ -5,6 +5,7 @@
  * message whose button can't be read is answered with why (`data.custom_id: not a Toolroll button`), and nothing is done.
  */
 import { z } from "zod";
+import { CHAT_BUTTON_TOKEN } from "./chat-content.js";
 import { parseContract } from "./contract.js";
 const user = z.object({ id: z.string() });
 /** The interaction around a tap (type 3: a message component): the app, the person, the channel, the message. */
@@ -22,7 +23,7 @@ export const discordComponentInteractionSchema = z.object({
 });
 /** Toolroll's button data: `so_` and a one-time token. */
 export const discordButtonSchema = z.object({
-    custom_id: z.string().regex(/^so_[a-f0-9]{32}$/, { error: "not a Toolroll button" }),
+    custom_id: z.string().regex(new RegExp(`^so_${CHAT_BUTTON_TOKEN.source.slice(1)}`), { error: "not a Toolroll button" }),
 });
 export function readDiscordComponentInteraction(body) {
     return parseContract(discordComponentInteractionSchema, body);

package/dist/contracts/slack-callback.js

@@ -6,11 +6,12 @@
  */
 import { z } from "zod";
 import { parseContract } from "./contract.js";
+import { CHAT_BUTTON_TOKEN } from "./chat-content.js";
 /** Toolroll's buttons: toolroll_* since the rename; standing_orders_* buttons on older messages still work. */
-export const SLACK_BUTTON_ACTION = /^(?:toolroll|standing_orders)_(?:confirm|dismiss|yes|cancel|flow_approve|flow_edit|flow_send_back|flow_choose_[0-3]|flow_note_(?:yes|no)|question_choice|question_words)$/;
+export const SLACK_BUTTON_ACTION = /^(?:toolroll|standing_orders)_(?:confirm|dismiss|yes|cancel|flow_approve|flow_edit|flow_send_back|flow_choose_[0-3]|flow_note_(?:yes|no)|question_choice|question_words|decide_[0-9]{1,2})$/;
 /** A link button opens its page in Slack's own client; Slack still reports the tap, and there is nothing to do. */
 export const SLACK_LINK_ACTION = /^(?:toolroll|standing_orders)_link(?:_[0-9]+)?$/;
-const token = z.string().regex(/^[a-f0-9]{32}$/, { error: "must be a Toolroll button token" });
+const token = z.string().regex(CHAT_BUTTON_TOKEN, { error: "must be a Toolroll button token" });
 /** The interaction around a tap: who, and the message the button is on. */
 export const slackBlockActionsSchema = z.object({
     type: z.literal("block_actions"),

package/dist/contracts/store-json.d.ts

@@ -155,10 +155,6 @@ declare const STORE_COLUMN_VALUES: {
             note: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$loose>>;
     }, z.core.$loose>;
-    readonly "telegram_conversation_part.keyboard_json": z.ZodArray<z.ZodArray<z.ZodObject<{
-        text: z.ZodString;
-        callback_data: z.ZodString;
-    }, z.core.$loose>>>;
     readonly "publication_grant.capabilities": z.ZodArray<z.ZodEnum<{
         "open-pr": "open-pr";
         "push-branch": "push-branch";
@@ -254,7 +250,7 @@ declare const STORE_COLUMN_VALUES: {
 export type StoreColumn = keyof typeof STORE_COLUMN_VALUES;
 export type StoreColumnValue<C extends StoreColumn> = z.infer<(typeof STORE_COLUMN_VALUES)[C]>;
 /** Every JSON column the store reads itself, by `table.column`. */
-export declare const STORE_COLUMNS: ("approval_policy.protected_paths" | "backend_grant.mutations" | "backend_grant.paths" | "coordinator_proposal.outcome_json" | "coordinator_proposal.payload_json" | "criterion_review.screenshots_json" | "decision.options" | "flow_card.source_json" | "flow_comment.mentions_json" | "lead_config.about_json" | "mate_ask.options_json" | "mate_proposal.outcome_json" | "mate_proposal.payload_json" | "mutation.result" | "operating_mode.terms_json" | "plan_revision.changed_fields" | "proof_verdict.matrix_json" | "proof_verdict.reasons_json" | "publication_grant.capabilities" | "repair_chain.unresolved_json" | "run_check.suites_json" | "run_checkpoint.snapshot_json" | "run_tool.tools_json" | "runner.agents" | "runner.repos" | "task_ref.capability_requirements" | "task_ref.zones" | "task_scope.acceptance_json" | "task_scope.touches" | "teammate_call.input_json" | "teammate_event.detail_json" | "teammate_question.options_json" | "teammate_suggestion.evidence_json" | "teammate_suggestion.rule_json" | "teammate_suggestion.was_json" | "teammate_tool.actions_json" | "teammate_tool.rules_json" | "telegram_conversation_part.keyboard_json" | "tool_seal.tools_json")[];
+export declare const STORE_COLUMNS: ("approval_policy.protected_paths" | "backend_grant.mutations" | "backend_grant.paths" | "coordinator_proposal.outcome_json" | "coordinator_proposal.payload_json" | "criterion_review.screenshots_json" | "decision.options" | "flow_card.source_json" | "flow_comment.mentions_json" | "lead_config.about_json" | "mate_ask.options_json" | "mate_proposal.outcome_json" | "mate_proposal.payload_json" | "mutation.result" | "operating_mode.terms_json" | "plan_revision.changed_fields" | "proof_verdict.matrix_json" | "proof_verdict.reasons_json" | "publication_grant.capabilities" | "repair_chain.unresolved_json" | "run_check.suites_json" | "run_checkpoint.snapshot_json" | "run_tool.tools_json" | "runner.agents" | "runner.repos" | "task_ref.capability_requirements" | "task_ref.zones" | "task_scope.acceptance_json" | "task_scope.touches" | "teammate_call.input_json" | "teammate_event.detail_json" | "teammate_question.options_json" | "teammate_suggestion.evidence_json" | "teammate_suggestion.rule_json" | "teammate_suggestion.was_json" | "teammate_tool.actions_json" | "teammate_tool.rules_json" | "tool_seal.tools_json")[];
 /** A SQL projection, not a physical column; replay it separately after its owning column. */
 export declare const STORE_PROJECTIONS: readonly ["run_tool.tools_json.fence"];
 /** These readers historically only parsed JSON. Shape errors must not change their values or catch boundaries. */

package/dist/contracts/store-json.js

@@ -16,7 +16,6 @@ import { decisionOptionSchema } from "./decision.js";
 import { scopeTermsSchema, storedRubricSchema } from "./scope.js";
 import { criterionEvidenceSchema, proofCriterionSchema } from "./proof.js";
 import { sharedActionSchema } from "./chat-actions.js";
-import { telegramCallbackButtonSchema } from "./telegram-callback.js";
 import { readVersioned, versioned } from "./contract.js";
 /** Dynamic tool arguments, event details and operation results have no common field contract. */
 const savedObject = z.looseObject({});
@@ -53,7 +52,6 @@ const savedProgressSchema = z.looseObject({
         id: z.string(), state: z.enum(["pending", "current", "completed", "blocked"]), note: z.string().nullable().optional(),
     })),
 });
-const savedKeyboardSchema = z.array(z.array(telegramCallbackButtonSchema.extend({ callback_data: z.string() }).loose()));
 const savedMatrixRowSchema = proofCriterionSchema.pick({ id: true, statement: true }).extend({
     id: z.string(), statement: z.string(), requiredEvidence: savedList, state: z.string(), detail: savedList,
     answered: z.array(criterionEvidenceSchema.extend({ ref: z.string() }).loose()).optional(),
@@ -88,7 +86,6 @@ const STORE_COLUMN_VALUES = {
     "mutation.result": z.unknown(),
     "plan_revision.changed_fields": z.array(z.string()),
     "run_checkpoint.snapshot_json": savedProgressSchema,
-    "telegram_conversation_part.keyboard_json": savedKeyboardSchema,
     "publication_grant.capabilities": z.array(z.enum(["push-branch", "open-pr"])),
     "task_ref.zones": savedList,
     "task_ref.capability_requirements": savedList,
@@ -115,7 +112,7 @@ export const LEGACY_JSON_COLUMNS = [
     "teammate_event.detail_json", "task_scope.touches", "task_scope.acceptance_json",
     "operating_mode.terms_json", "decision.options", "run_tool.tools_json",
     "run_tool.tools_json.fence", "mate_ask.options_json", "mutation.result", "plan_revision.changed_fields",
-    "run_checkpoint.snapshot_json", "telegram_conversation_part.keyboard_json", "publication_grant.capabilities",
+    "run_checkpoint.snapshot_json", "publication_grant.capabilities",
     "coordinator_proposal.payload_json", "coordinator_proposal.outcome_json",
     "mate_proposal.payload_json", "mate_proposal.outcome_json",
 ];