toolroll 0.9.53 → 0.9.54

package/dist/store.d.ts

@@ -1,3 +1,6 @@
+import { type ChatBinding } from "./chat-core.js";
+import { ChatMessages, TELEGRAM_HOLD_REASONS, TELEGRAM_SKIPPED_ELSEWHERE, TELEGRAM_SKIPPED_OTHER_CHAT, TELEGRAM_SKIPPED_QUIET } from "./chat-messages.js";
+import { isLifecycleNotification, isTelegramProgressNotification, LIFECYCLE_KEY_PREFIX, LIFECYCLE_KINDS, proposalTaskOf, type LifecycleKind } from "./notification-rows.js";
 import { ServerTelemetry } from "./server-telemetry.js";
 import type { DecisionOption } from "./contracts/decision.js";
 import { type SavedToolAction, type SavedToolRule } from "./contracts/store-json.js";
@@ -67,7 +70,7 @@ export declare const MATE_ASK_SCHEMA = "\nCREATE TABLE IF NOT EXISTS mate_ask (\
  * person (shown on the card, and read again by every chat app that delivers it); telegram_flow_choice is one opaque button
  * per option for one visit of one card, placed on the message it rides. A reply to that message is the note
  * (telegram_flow_prompt, mode send-back). The chat apps keep their buttons beside their messages (chat-delivery-state.ts). */
-export declare const FLOW_SEND_SCHEMA = "\nCREATE TABLE IF NOT EXISTS flow_send (\n  card         INTEGER NOT NULL REFERENCES flow_card(id),\n  entry        INTEGER NOT NULL,\n  stage        TEXT NOT NULL,\n  person       TEXT NOT NULL,\n  content_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL,\n  PRIMARY KEY (card, entry)\n);\nCREATE TABLE IF NOT EXISTS telegram_flow_choice (\n  token       TEXT PRIMARY KEY,\n  binding     INTEGER NOT NULL REFERENCES telegram_binding(id) ON DELETE RESTRICT,\n  card        INTEGER NOT NULL REFERENCES flow_card(id),\n  entry       INTEGER NOT NULL,\n  choice      INTEGER NOT NULL,\n  label       TEXT NOT NULL,\n  chat_id     TEXT NOT NULL,\n  message_id  TEXT,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS telegram_flow_choice_visit ON telegram_flow_choice (card, entry);\n";
+export declare const FLOW_SEND_SCHEMA = "\nCREATE TABLE IF NOT EXISTS flow_send (\n  card         INTEGER NOT NULL REFERENCES flow_card(id),\n  entry        INTEGER NOT NULL,\n  stage        TEXT NOT NULL,\n  person       TEXT NOT NULL,\n  content_json TEXT NOT NULL,\n  created_at   TEXT NOT NULL,\n  PRIMARY KEY (card, entry)\n);\n";
 /** An owner's lasting choice to approve plans and merges from their paired chat (chat-approval.ts), for all their
  * projects (scope '*') or one (its path), with the limits they agreed to. Off unless a row says on; a project's own row
  * outranks the all-projects one. `generation` is the account's at the change: a reset password ends it. */
@@ -76,9 +79,6 @@ export declare const FLOW_SEND_SCHEMA = "\nCREATE TABLE IF NOT EXISTS flow_send
  * a finished run's row goes with the live log's own retention (sweepRunActivity). */
 export declare const RUN_ACTIVITY_SCHEMA = "\nCREATE TABLE IF NOT EXISTS run_activity (\n  run  INTEGER PRIMARY KEY REFERENCES run(id) ON DELETE CASCADE,\n  kind TEXT NOT NULL CHECK (kind IN ('session','message','edit','command','read','search','lookup','plan','delegate','tool')),\n  at   TEXT NOT NULL\n);\n";
 export declare const CHAT_APPROVAL_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_approval_setting (\n  approver             TEXT NOT NULL,\n  scope                TEXT NOT NULL,\n  enabled              INTEGER NOT NULL CHECK (enabled IN (0,1)),\n  full_access          INTEGER NOT NULL DEFAULT 0 CHECK (full_access IN (0,1)),\n  attempt_cap_microusd INTEGER CHECK (attempt_cap_microusd IS NULL OR attempt_cap_microusd >= 0),\n  generation           INTEGER NOT NULL,\n  digest               TEXT NOT NULL,\n  updated_by           TEXT NOT NULL,\n  updated_at           TEXT NOT NULL,\n  PRIMARY KEY (approver, scope)\n);\n";
-/** The second tap on a flow decision in Telegram (telegram-flow.ts): Approve arms Yes and Cancel, bound to the binding,
- * chat, message and exact visit of the card; Yes decides it once. */
-export declare const TELEGRAM_FLOW_CONFIRM_SCHEMA = "\nCREATE TABLE IF NOT EXISTS telegram_flow_confirm (\n  token       TEXT PRIMARY KEY,\n  binding     INTEGER NOT NULL,\n  chat_id     TEXT NOT NULL,\n  message_id  TEXT NOT NULL,\n  card        INTEGER NOT NULL,\n  entry       INTEGER NOT NULL,\n  phase       TEXT NOT NULL CHECK (phase IN ('yes','cancel')),\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS telegram_flow_confirm_visit ON telegram_flow_confirm (card, entry);\n";
 export declare const CHAT_DECIDE_SCHEMA = "\nCREATE TABLE IF NOT EXISTS chat_decide_action (\n  token       TEXT PRIMARY KEY,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  message     TEXT,\n  act         TEXT NOT NULL CHECK (act IN ('accept','changes','retry','approve','not-now','merge')),\n  phase       TEXT NOT NULL CHECK (phase IN ('offer','yes','cancel')),\n  task_id     TEXT NOT NULL,\n  run         INTEGER,\n  digest      TEXT NOT NULL,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_action_message ON chat_decide_action (channel, chat, message);\nCREATE TABLE IF NOT EXISTS chat_decide_prompt (\n  id          INTEGER PRIMARY KEY AUTOINCREMENT,\n  channel     TEXT NOT NULL,\n  binding     INTEGER NOT NULL,\n  chat        TEXT NOT NULL,\n  task_id     TEXT NOT NULL,\n  run         INTEGER NOT NULL,\n  digest      TEXT NOT NULL,\n  message     TEXT,\n  created_at  TEXT NOT NULL,\n  expires_at  TEXT NOT NULL,\n  consumed_at TEXT\n);\nCREATE INDEX IF NOT EXISTS chat_decide_prompt_open ON chat_decide_prompt (channel, binding, consumed_at);\n";
 export type MateAsk = {
     turn: number;
@@ -152,7 +152,7 @@ export type SealedLedgerEntry = LedgerEntry & {
         hash: string;
     } | null;
 };
-export declare const SCHEMA_VERSION = 115;
+export declare const SCHEMA_VERSION = 116;
 /** v115: the tables migrateToV115 drops. */
 export declare const V115_DROPPED_TABLES: readonly string[];
 /**
@@ -180,7 +180,10 @@ export declare const V115_DROPPED_TABLES: readonly string[];
  * the routine was approved and running). Its other changes add a column or
  * settle rows in place; a database whose removed features still held a hold
  * to lift or place changes that table's rows and is refused, so it takes the
- * separate procedure.
+ * separate procedure. v116 is the next declared exception: every row of the 70 old
+ * per-app chat tables moves into the shared chat tables keyed by provider, in one
+ * transaction that checks each count before the old tables are dropped; the
+ * rehearsal checks each moved table's rows arrived (HISTORY_RULES).
  */
 export declare const UPDATE_SAFE_MIGRATIONS: readonly number[];
 /** Whether a database settled at `version` reaches this build's schema through update-safe migrations alone. */
@@ -778,14 +781,6 @@ export type FlowTriggerRow = {
     updatedAt: string;
 };
 export type FlowEventOutcome = "created" | "ok" | "fail" | "moved" | "approved" | "sent-back" | "cancelled";
-/** The one task a card is about: a task its confirmation created (a new
- * task, a revision), else the task it names (and, for feedback on a result,
- * that result). Null for a card about no single task. A pointer for
- * replies, never an authority. */
-export declare function proposalTaskOf(proposal: MateProposal | null): {
-    task: string;
-    run: number | null;
-} | null;
 export type MateTurn = {
     id: number;
     approver: string;
@@ -862,23 +857,6 @@ type NotificationInput = {
     /** v83: one person's notification — only their own phone, chats and browsers get it; no channel-wide webhook does. */
     recipient?: string;
 };
-/**
- * Task lifecycle updates (Telegram task updates, 2026-09-16): the CLOSED
- * vocabulary of routine progress facts the shared mutations record beside
- * the change that made them true. None carries a push class — they are
- * digest-eligible progress, never a page — and every one is project-bound
- * through the task it names. A decision, incident, gap, stall, publication
- * or merge page keeps its own producer; nothing here repeats one.
- */
-export declare const LIFECYCLE_KINDS: readonly ["task-filed", "scope-approved", "approval-withdrawn", "task-held", "task-released", "task-queued", "task-requeued", "task-cancelled", "run-started", "run-phase", "check-progress", "run-finished", "run-stopping", "run-stopped", "run-resumed", "review-requested", "review-finished", "acceptance-evidence", "acceptance-ready"];
-export type LifecycleKind = (typeof LIFECYCLE_KINDS)[number];
-/** Every lifecycle dedupe key starts here: `life:<kind>:<identity>:<ordinal>`. */
-export declare const LIFECYCLE_KEY_PREFIX = "life:";
-/** A progress fact, told apart by its durable key — never by display text. */
-export declare function isLifecycleNotification(row: Pick<Notification, "dedupeKey">): boolean;
-/** Only known progress producers can repaint a card. Decisions and urgent
- * incidents keep their own alerts; a routine retry updates its saved attempt. */
-export declare function isTelegramProgressNotification(row: Pick<Notification, "dedupeKey" | "kind" | "pushClass" | "run">): boolean;
 /** A fact that wants a person, durably. */
 export type Notification = {
     id: number;
@@ -3985,6 +3963,8 @@ export declare class Store {
     resolveEpisodes(prefix: string, now: Date): number;
     notificationById(id: number): Notification | null;
     notificationsAfter(id: number, limit?: number): Notification[];
+    /** What landed before a pairing (and at or before `through`) and still wants that person (WANTED_BEFORE_PAIRING). */
+    notificationsWantedBefore(created: string, through: number, limit?: number): Notification[];
     listNotifications(only?: "pending" | "all"): Notification[];
     /**
      * Close a gap's notification episode. Called when its capability verifies:
@@ -4791,7 +4771,9 @@ export declare class Store {
     resolveIncident(id: number, by: string, now: Date): boolean;
     /** The body, for callers already holding the transaction (requeueTask). */
     private resolveIncidentLocked;
-    /** Mint a pairing code's record. The code itself was shown once; this is its hash. */
+    /** The shared chat core, bound to Telegram: the same pairing, rooms and worker rules every chat app keeps. */
+    telegramChat(): ChatMessages;
+    /** Mint a pairing code's record. The code itself was shown once; this is its hash. A Telegram code works on its bot. */
     createTelegramPairing(pairing: {
         codeHash: string;
         approver: string;
@@ -4799,14 +4781,15 @@ export declare class Store {
         ttlMs: number;
     }, now: Date): void;
     /**
-     * Consume a pairing code and create the binding, as one transaction.
+     * Consume a pairing code and create the binding, as one transaction, by the rules every chat app shares
+     * (ChatCore.consumePairing): a replay of the very update that paired finds its finished binding.
      *
-     * The conditional UPDATE is the consumption: exactly one caller ever sees
-     * `changes = 1`, however many pollers race. A replay of the very update
-     * that paired (Telegram redelivers) recognizes the finished binding
-     * instead of failing. Success invalidates every other outstanding code —
-     * a code that was minted and superseded must not still open a door — and
-     * the partial unique index enforces one live binding per bot.
+     * A person's FIRST pairing starts from now (Telegram task updates): every ROUTINE fact already in the outbox is
+     * history for this destination — settled here, in the pairing's own transaction, with a receipt that says it was
+     * skipped, never sent as a backlog to a phone that just arrived. The skip is explicit: no delivered_at, no attempt,
+     * only the `skipped:` receipt — a message no phone received is never reported as delivered (see TELEGRAM_UNSETTLED).
+     * An open decision or an attention-class fact still wants a person and stays pending. A re-pairing after a
+     * revocation keeps the older promise instead: what no phone ever received still waits for whenever pairing happens.
      */
     consumeTelegramPairing(attempt: {
         codeHash: string;
@@ -4825,13 +4808,7 @@ export declare class Store {
     /** The live team-conversation row for one chat, group or private. */
     telegramTeamChat(botId: string, chatId: string): TelegramTeamChat | null;
     listTelegramTeamChats(botId: string): TelegramTeamChat[];
-    /**
-     * Point a chat at a team conversation: an earlier choice for the same chat
-     * is revoked in the same transaction, and delivery starts from now — the
-     * conversation's history is read in the console, never replayed into a
-     * chat that just arrived. A group already following another conversation
-     * elsewhere, or a conversation already followed by another group, refuses.
-     */
+    /** Point a chat at a team conversation (ChatCore.bindRoom: the same rule in every chat app). */
     bindTelegramTeamChat(args: {
         botId: string;
         chatId: string;
@@ -4850,11 +4827,9 @@ export declare class Store {
     /** Forward only: a cursor never moves back, and a revoked row keeps its last position. */
     advanceTelegramTeamCursor(id: number, messageId: number): boolean;
     /**
-     * Every live binding for a bot, oldest first — and only while each
-     * approver's credential generation still matches. A rotation that
-     * somehow missed the sweep reads as no binding at all, which is the
-     * failure direction that fails closed. Several teammates may each hold
-     * one (v72); nothing here ranks them.
+     * Every live binding for a bot, oldest first — and only while each approver's credential generation still matches.
+     * A rotation that somehow missed the sweep reads as no binding at all, which is the failure direction that fails
+     * closed. Several teammates may each hold one (v72); nothing here ranks them.
      */
     liveTelegramBindings(botId: string): TelegramBinding[];
     /** The live binding one Telegram user holds with a bot, if any. */
@@ -4868,130 +4843,41 @@ export declare class Store {
     /** Revoke every live binding one person holds with a bot, and everything
      * those chats could still do. Teammates' bindings are untouched. */
     unpairTelegram(botId: string, by: string, now: Date): boolean;
-    createTelegramAction(action: {
-        token: string;
-        binding: number;
-        decision: number;
-        optionId: string;
-        phase: "choose" | "confirm" | "cancel";
-        chatId: string;
-        messageId?: string;
-        ttlMs?: number;
-        /** Binds an irreversible confirmation to the EXACT note it showed. */
-        noteDigest?: string;
-    }, now: Date): void;
-    /** Which decision an outbound Telegram message carried. Recorded after the
-     * send returns its id; a send whose record was lost routes nothing. */
-    recordTelegramDecisionMessage(binding: number, chatId: string, messageId: string, decision: number, now: Date): void;
-    /** The decision behind an exact replied-to message, or nothing. Never "the latest". */
-    decisionForTelegramMessage(binding: number, chatId: string, messageId: string): number | null;
-    /** The one live, unexpired draft for a decision, if any. */
-    liveNoteDraft(binding: number, decision: number, now: Date): {
-        id: number;
-        note: string;
-        updateId: number;
-        state: string;
-    } | null;
-    /**
-     * Persist a validated note as the live draft. A newer update SUPERSEDES
-     * the old draft — drafts are immutable, and only a GREATER update_id may
-     * replace one, so out-of-order delivery cannot resurrect an older note
-     * (Codex free-text review, state machine). Returns false when an older
-     * or equal update tried.
-     */
-    saveNoteDraft(draft: {
-        binding: number;
-        decision: number;
-        updateId: number;
-        messageId: string;
-        replyTo: string;
-        note: string;
-    }, now: Date, ttlMs?: number): boolean;
-    /** Move a draft between states; the caller owns the transaction story. */
-    setNoteDraftState(id: number, state: "pending" | "armed" | "superseded" | "consumed" | "discarded"): void;
-    createTelegramFlowActions(at: {
-        binding: number;
-        chatId: string;
-        card: number;
-        entry: number;
-    }, actions: readonly {
-        token: string;
-        action: TelegramFlowAction["action"];
-    }[], now: Date, days?: number): void;
-    getTelegramFlowAction(token: string): TelegramFlowAction | null;
-    placeTelegramFlowActions(tokens: readonly string[], messageId: string): void;
-    /** Retire every button (and prompt) for one visit of a card: it was decided, or its draft replaced. */
-    retireTelegramFlowVisit(card: number, entry: number, now: Date): void;
-    recordTelegramFlowPrompt(prompt: TelegramFlowPrompt, now: Date, hours?: number): void;
-    /** The live prompt a message replies to, if any. */
-    telegramFlowPrompt(chatId: string, messageId: string, now: Date): TelegramFlowPrompt | null;
+    createTelegramAction(...args: Parameters<ChatMessages["createDecisionAction"]>): ReturnType<ChatMessages["createDecisionAction"]>;
+    recordTelegramDecisionMessage(...args: Parameters<ChatMessages["recordDecisionMessage"]>): ReturnType<ChatMessages["recordDecisionMessage"]>;
+    decisionForTelegramMessage(...args: Parameters<ChatMessages["decisionForMessage"]>): ReturnType<ChatMessages["decisionForMessage"]>;
+    liveNoteDraft(...args: Parameters<ChatMessages["liveNoteDraft"]>): ReturnType<ChatMessages["liveNoteDraft"]>;
+    saveNoteDraft(...args: Parameters<ChatMessages["saveNoteDraft"]>): ReturnType<ChatMessages["saveNoteDraft"]>;
+    setNoteDraftState(...args: Parameters<ChatMessages["setNoteDraftState"]>): ReturnType<ChatMessages["setNoteDraftState"]>;
+    createTelegramFlowActions(...args: Parameters<ChatMessages["createFlowActions"]>): ReturnType<ChatMessages["createFlowActions"]>;
+    getTelegramFlowAction(...args: Parameters<ChatMessages["flowAction"]>): ReturnType<ChatMessages["flowAction"]>;
+    placeTelegramFlowActions(...args: Parameters<ChatMessages["placeFlowActions"]>): ReturnType<ChatMessages["placeFlowActions"]>;
+    retireTelegramFlowVisit(...args: Parameters<ChatMessages["retireFlowVisit"]>): ReturnType<ChatMessages["retireFlowVisit"]>;
+    recordTelegramFlowPrompt(...args: Parameters<ChatMessages["recordFlowPrompt"]>): ReturnType<ChatMessages["recordFlowPrompt"]>;
+    telegramFlowPrompt(...args: Parameters<ChatMessages["flowPrompt"]>): ReturnType<ChatMessages["flowPrompt"]>;
     /** What one visit sent: recorded once, the first time (a later pass finds it kept). */
     recordFlowSend(row: Omit<FlowSendRow, "createdAt">, now: Date): boolean;
     flowSend(card: number, entry: number): FlowSendRow | null;
     /** Every visit's send for a card, newest first: what the card shows it sent. */
     flowSends(card: number): FlowSendRow[];
-    createTelegramFlowChoices(at: {
-        binding: number;
-        chatId: string;
-        card: number;
-        entry: number;
-    }, choices: readonly {
-        token: string;
-        choice: number;
-        label: string;
-    }[], now: Date, days?: number): void;
-    getTelegramFlowChoice(token: string): TelegramFlowChoice | null;
-    placeTelegramFlowChoices(tokens: readonly string[], messageId: string): void;
-    /** Retire every choice button for one visit of a card (and its reply prompt): it was chosen, or the card moved on. */
+    createTelegramFlowChoices(...args: Parameters<ChatMessages["createFlowChoices"]>): ReturnType<ChatMessages["createFlowChoices"]>;
+    getTelegramFlowChoice(...args: Parameters<ChatMessages["flowChoice"]>): ReturnType<ChatMessages["flowChoice"]>;
+    placeTelegramFlowChoices(...args: Parameters<ChatMessages["placeFlowChoices"]>): ReturnType<ChatMessages["placeFlowChoices"]>;
     /** A choice was made (or the card moved on): every option button, reply prompt and "Use this as your note?" for that
-     * visit is spent, in Telegram and in every other chat app, whichever place it was made in. */
+     * visit is spent, in every chat app, whichever place it was made in. */
     retireFlowChoices(card: number, entry: number, now: Date): void;
-    createTelegramQuestionActions(at: {
-        binding: number;
-        chatId: string;
-        question: number;
-    }, choices: readonly {
-        token: string;
-        choice: string | null;
-    }[], now: Date, days?: number): void;
-    getTelegramQuestionAction(token: string): {
-        token: string;
-        binding: number;
-        question: number;
-        choice: string | null;
-        chatId: string;
-        messageId: string | null;
-        expiresAt: string;
-        consumedAt: string | null;
-    } | null;
-    placeTelegramQuestionActions(tokens: readonly string[], messageId: string): void;
-    /** Retire every button and prompt for a question: it was answered (anywhere). */
-    retireTelegramQuestion(question: number, now: Date): void;
-    recordTelegramQuestionPrompt(prompt: {
-        chatId: string;
-        messageId: string;
-        binding: number;
-        question: number;
-    }, now: Date, hours?: number): void;
-    telegramQuestionPrompt(chatId: string, messageId: string, now: Date): {
-        chatId: string;
-        messageId: string;
-        binding: number;
-        question: number;
-    } | null;
-    getTelegramAction(token: string): TelegramAction | null;
-    /**
-     * Kill every live confirm/cancel challenge on a decision. Cancel means
-     * cancelled: a confirm that survived its own cancellation would be an
-     * irreversible choice still armed after the person said stop.
-     */
-    consumeTelegramChallenges(decision: number, now: Date): void;
-    /** Consume once. False means somebody already did, or it expired — either way, no. */
-    consumeTelegramAction(token: string, now: Date): boolean;
-    /** Stamp the message a choose-action's keyboard actually landed on. */
-    placeTelegramActions(tokens: readonly string[], messageId: string): void;
-    /**
-     * Take or renew the bridge's poll lease. One live poller per bot: cron
+    createTelegramQuestionActions(...args: Parameters<ChatMessages["createQuestionActions"]>): ReturnType<ChatMessages["createQuestionActions"]>;
+    getTelegramQuestionAction(...args: Parameters<ChatMessages["questionAction"]>): ReturnType<ChatMessages["questionAction"]>;
+    placeTelegramQuestionActions(...args: Parameters<ChatMessages["placeQuestionActions"]>): ReturnType<ChatMessages["placeQuestionActions"]>;
+    retireTelegramQuestion(...args: Parameters<ChatMessages["retireQuestion"]>): ReturnType<ChatMessages["retireQuestion"]>;
+    recordTelegramQuestionPrompt(...args: Parameters<ChatMessages["recordQuestionPrompt"]>): ReturnType<ChatMessages["recordQuestionPrompt"]>;
+    telegramQuestionPrompt(...args: Parameters<ChatMessages["questionPrompt"]>): ReturnType<ChatMessages["questionPrompt"]>;
+    getTelegramAction(...args: Parameters<ChatMessages["decisionAction"]>): ReturnType<ChatMessages["decisionAction"]>;
+    consumeTelegramChallenges(...args: Parameters<ChatMessages["consumeChallenges"]>): ReturnType<ChatMessages["consumeChallenges"]>;
+    consumeTelegramAction(...args: Parameters<ChatMessages["consumeDecisionAction"]>): ReturnType<ChatMessages["consumeDecisionAction"]>;
+    placeTelegramActions(...args: Parameters<ChatMessages["placeDecisionActions"]>): ReturnType<ChatMessages["placeDecisionActions"]>;
+    /**
+     * Take or renew the bridge's poll lease (ChatCore.acquire). One live poller per bot: cron
      * overlapping a follower gets `bridge-busy`, an expired holder is taken
      * over at the next generation, and the cursor rides the lease so a stale
      * generation can neither poll nor move it.
@@ -5731,10 +5617,7 @@ export declare class Store {
             reason: string;
         }[];
     } | null;
-    /** A Telegram message this bot sent that showed one task (v79): a reply to
-     * it is about that task (and that result, when it showed one). A message
-     * edited to show something else forgets it. */
-    recordTelegramTaskMessage(binding: TelegramBinding, messageId: string, taskId: string | null, run: number | null, now: Date): void;
+    recordTelegramTaskMessage(...args: Parameters<ChatMessages["recordTaskMessage"]>): ReturnType<ChatMessages["recordTaskMessage"]>;
     /** The approver's live personal threads that have messages, most recent
      * first — the chat list. Team conversations list themselves. */
     listMateThreads(approver: string, limit?: number): MateThreadSummary[];
@@ -6379,15 +6262,9 @@ export declare class Store {
     recordProjectConcurrency(by: string, repo: string, before: number, after: number, now: Date): void;
     /** Review 827: a project's demo URL changed (`off` when it has none). */
     recordProjectDemo(by: string, repo: string, before: string | null, after: string | null, now: Date): void;
-    /** Forward only, and only under the live generation. A stale poller moves nothing. */
-    /** v98: an update Telegram pushed, kept until the bridge applies it; false when it's already kept or applied. */
-    queueTelegramUpdate(botId: string, updateId: number, payload: string, now: Date): boolean;
-    /** v98: pushed updates waiting for the bridge, oldest first. */
-    telegramInbox(botId: string, limit: number): {
-        updateId: number;
-        payload: string;
-    }[];
-    dropTelegramInbox(updateId: number): void;
+    queueTelegramUpdate(...args: Parameters<ChatMessages["queueUpdate"]>): ReturnType<ChatMessages["queueUpdate"]>;
+    telegramInbox(...args: Parameters<ChatMessages["inbox"]>): ReturnType<ChatMessages["inbox"]>;
+    dropTelegramInbox(...args: Parameters<ChatMessages["dropInbox"]>): ReturnType<ChatMessages["dropInbox"]>;
     /** v98: where Telegram pushes this bot's updates (null: the bridge asks for them), and what's wrong, if anything. */
     setTelegramPush(botId: string, state: {
         url: string | null;
@@ -6398,164 +6275,43 @@ export declare class Store {
         problem: string | null;
         at: string | null;
     } | null;
+    /** Forward only, and only under the live generation. A stale poller moves nothing. */
     advanceBridgeCursor(botId: string, owner: string, generation: number, cursor: number, now: Date): boolean;
-    /** True if this update has not been applied before. The PRIMARY KEY is the idempotency. */
-    markTelegramUpdateApplied(updateId: number, result: string, now: Date): boolean;
-    /** Persist one ordinary message before its update is acknowledged. The caller's transaction also marks the update applied. */
-    enqueueTelegramConversation(row: {
-        binding: TelegramBinding;
-        updateId: number;
-        messageId: string;
-        replyTo: string | null;
-        request: string;
-        text: string;
-        context: string | null;
-        taskId: string | null;
-        sourceRun: number | null;
-    }, now: Date): number;
-    /** Whether a message from this chat is already waiting on, or being answered from, this bot message (a tapped question). */
-    telegramConversationWaitingOn(binding: number, messageId: string): boolean;
-    getTelegramConversation(id: number): TelegramConversation | null;
-    listTelegramConversations(botId: string): TelegramConversation[];
-    /**
-     * Claim the oldest message that still needs a turn: queued, or running
-     * under a claim that lapsed (a crash mid-turn), and not deferred past now.
-     * One at a time per bot — the mate runs one turn per approver anyway.
-     */
-    claimTelegramConversation(botId: string, owner: string, ttlMs: number, now: Date, only?: "turns" | "replies"): TelegramConversation | null;
-    /** Extend a held claim; false means it lapsed and somebody else may hold the row. */
-    renewTelegramConversation(id: number, owner: string, ttlMs: number, now: Date): boolean;
-    /**
-     * Bind the session a turn is about to be dispatched under, BEFORE the
-     * dispatch: the engine receipts the request inside that session, so a
-     * later attempt — after a crash, even after the session was ended and
-     * replaced from the console — reads the receipt where it was written
-     * instead of resolving today's session and finding nothing there.
-     */
-    bindTelegramConversationSession(id: number, owner: string, session: number): boolean;
-    /** Bind the admitted turn to its row as soon as the engine's receipt names it. */
-    bindTelegramConversationTurn(id: number, owner: string, session: number, turn: number): boolean;
-    /**
-     * Settle a claimed row: done or failed with its outcome word, or back to
-     * queued for a later attempt (a busy engine). Only the claim holder may;
-     * a lapsed claim settles nothing, so a reclaimer's outcome stands.
-     */
-    finishTelegramConversation(id: number, owner: string, result: {
-        state: "done" | "failed";
-        outcome: string;
-        replyMessageId?: string | null;
-    } | {
-        state: "queued";
-        outcome: string;
-        nextAttemptAt: string;
-    }, now: Date): boolean;
-    /**
-     * Replies the assistant wrote that still have not reached the person
-     * `since` ago or longer (status and the console show them with a Retry):
-     * the message's row, whose it is, when the oldest unsent part was
-     * written, and the last send error.
-     */
-    unsentTelegramReplies(botId: string | null, approver: string | null, since: Date): {
-        conversation: number;
-        approver: string;
-        since: string;
-        error: string | null;
-    }[];
-    /** Send unsent replies on the next bridge pass instead of waiting out their backoff; returns how many. */
-    retryTelegramReplies(approver: string | null, now: Date): number;
-    /**
-     * Persist the whole outbound half of a turn — every reply part and every
-     * card, with the cards' tokens already minted — in one transaction, BEFORE
-     * any send. Only the claim holder may, and only once: a row that already
-     * has parts keeps them (a retry resumes, never re-plans). The turn's
-     * identity rides the row too, so the parts answer to exactly that turn.
-     */
-    planTelegramConversationParts(id: number, owner: string, turn: {
-        session: number;
-        turn: number;
-    }, parts: readonly TelegramConversationPartPlan[], now: Date): boolean;
-    listTelegramConversationParts(conversation: number): TelegramConversationPart[];
-    /**
-     * Settle one send attempt under the row's claim. A confirmed message id
-     * is the only success: the part is sent, and a reply part's id becomes
-     * the row's reply id. Anything else leaves the part pending with its
-     * attempt counted, its error named, its next attempt scheduled, and —
-     * when the answer was lost rather than refused — its uncertainty counted.
-     * A lapsed claim settles nothing, so a reclaimer's outcome stands.
-     */
-    settleTelegramConversationPart(conversation: number, ordinal: number, owner: string, outcome: {
-        ok: true;
-        messageId: string;
-    } | {
-        ok: false;
-        error: string;
-        uncertain: boolean;
-        retryAt: string;
-    }, now: Date): boolean;
-    /** A card whose proposal no longer waits (confirmed or dismissed from another surface, or gone) is moot: dropped with the reason, never sent. */
-    dropTelegramConversationPart(conversation: number, ordinal: number, owner: string, reason: string, now: Date): boolean;
-    /** The exact task/run bindings of one outbound message this bot sent: a
-     * plain fact names one, a digest part may name several, (v64) a confirmed
-     * result image names its exact task and run, the lead's reply names the
-     * task its turn was about, a card names its task, and (v79) a status
-     * message names the task it showed. */
-    telegramMessageBindings(binding: TelegramBinding, messageId: string): {
-        taskId: string | null;
-        taskRef: number | null;
-        run: number | null;
-        project: string | null;
-    }[];
-    createTelegramProposalAction(action: {
-        token: string;
-        binding: number;
-        proposal: number;
-        phase: TelegramProposalAction["phase"];
-        chatId: string;
-        messageId?: string;
-        ttlMs?: number;
-    }, now: Date): void;
-    getTelegramProposalAction(token: string): TelegramProposalAction | null;
-    /** Consume once. False means somebody already did, or it expired. */
-    consumeTelegramProposalAction(token: string, now: Date): boolean;
-    /** Kill every live token on a proposal — after it resolves, or when a challenge is cancelled. */
-    consumeTelegramProposalActions(proposal: number, now: Date, phases?: readonly TelegramProposalAction["phase"][]): void;
-    /** Stamp the message a card's keyboard actually landed on. */
-    placeTelegramProposalActions(tokens: readonly string[], messageId: string): void;
-    telegramDestination(binding: TelegramBinding): string;
-    /** A progress card belongs to one builder result, including its root review.
-     * Do not combine planners, correction children, or separate build attempts. */
-    telegramProgressRun(row: Pick<Notification, "taskRef" | "run">): Run | null;
-    /** Reuse a confirmed message in this exact destination. A mixed digest,
-     * decision, image, or message naming another attempt is never editable. The
-     * outbound history survives a restart even if the final receipt was lost. */
-    telegramProgressMessage(binding: TelegramBinding, result: Run): string | null;
-    /** The existing outbox, with a separate receipt for this exact pairing. */
-    claimTelegramDeliveries(binding: TelegramBinding, owner: string, ttlMs: number, now: Date, only?: "all" | "urgent"): TelegramDelivery[];
+    markTelegramUpdateApplied(...args: Parameters<ChatMessages["markUpdateApplied"]>): ReturnType<ChatMessages["markUpdateApplied"]>;
+    enqueueTelegramConversation(...args: Parameters<ChatMessages["enqueueMessage"]>): ReturnType<ChatMessages["enqueueMessage"]>;
+    telegramConversationWaitingOn(...args: Parameters<ChatMessages["messageWaitingOn"]>): ReturnType<ChatMessages["messageWaitingOn"]>;
+    getTelegramConversation(...args: Parameters<ChatMessages["getMessage"]>): ReturnType<ChatMessages["getMessage"]>;
+    listTelegramConversations(...args: Parameters<ChatMessages["listMessages"]>): ReturnType<ChatMessages["listMessages"]>;
+    claimTelegramConversation(...args: Parameters<ChatMessages["claimMessage"]>): ReturnType<ChatMessages["claimMessage"]>;
+    renewTelegramConversation(...args: Parameters<ChatMessages["renewMessage"]>): ReturnType<ChatMessages["renewMessage"]>;
+    bindTelegramConversationSession(...args: Parameters<ChatMessages["bindMessageSession"]>): ReturnType<ChatMessages["bindMessageSession"]>;
+    bindTelegramConversationTurn(...args: Parameters<ChatMessages["bindMessageTurn"]>): ReturnType<ChatMessages["bindMessageTurn"]>;
+    finishTelegramConversation(...args: Parameters<ChatMessages["finishMessage"]>): ReturnType<ChatMessages["finishMessage"]>;
+    unsentTelegramReplies(...args: Parameters<ChatMessages["unsentReplies"]>): ReturnType<ChatMessages["unsentReplies"]>;
+    retryTelegramReplies(...args: Parameters<ChatMessages["retryReplies"]>): ReturnType<ChatMessages["retryReplies"]>;
+    planTelegramConversationParts(...args: Parameters<ChatMessages["planReplyParts"]>): ReturnType<ChatMessages["planReplyParts"]>;
+    listTelegramConversationParts(...args: Parameters<ChatMessages["replyParts"]>): ReturnType<ChatMessages["replyParts"]>;
+    settleTelegramConversationPart(...args: Parameters<ChatMessages["settleReplyPart"]>): ReturnType<ChatMessages["settleReplyPart"]>;
+    dropTelegramConversationPart(...args: Parameters<ChatMessages["dropReplyPart"]>): ReturnType<ChatMessages["dropReplyPart"]>;
+    telegramMessageBindings(...args: Parameters<ChatMessages["messageBindings"]>): ReturnType<ChatMessages["messageBindings"]>;
+    createTelegramProposalAction(...args: Parameters<ChatMessages["createProposalAction"]>): ReturnType<ChatMessages["createProposalAction"]>;
+    getTelegramProposalAction(...args: Parameters<ChatMessages["proposalAction"]>): ReturnType<ChatMessages["proposalAction"]>;
+    consumeTelegramProposalAction(...args: Parameters<ChatMessages["consumeProposalAction"]>): ReturnType<ChatMessages["consumeProposalAction"]>;
+    consumeTelegramProposalActions(...args: Parameters<ChatMessages["consumeProposalActions"]>): ReturnType<ChatMessages["consumeProposalActions"]>;
+    placeTelegramProposalActions(...args: Parameters<ChatMessages["placeProposalActions"]>): ReturnType<ChatMessages["placeProposalActions"]>;
+    telegramDestination(...args: Parameters<ChatMessages["destination"]>): ReturnType<ChatMessages["destination"]>;
+    telegramProgressRun(...args: Parameters<ChatMessages["progressRun"]>): ReturnType<ChatMessages["progressRun"]>;
+    telegramProgressMessage(...args: Parameters<ChatMessages["progressMessage"]>): ReturnType<ChatMessages["progressMessage"]>;
+    claimTelegramDeliveries(...args: Parameters<ChatMessages["claimDeliveries"]>): ReturnType<ChatMessages["claimDeliveries"]>;
     telegramRetryAt(botId: string): string;
     deferTelegram(botId: string, until: string): void;
-    /** Synchronous final fence, called AFTER each asynchronous enrollment read. */
-    telegramDeliveryProblem(row: TelegramDelivery, binding: TelegramBinding, owner: string, projects: readonly string[], now: Date, batch?: readonly number[]): string | null;
-    private telegramClaimHeld;
-    /** A confirmed network message remains history even if authority changed
-     * while it was in flight. It only binds the OLD destination, never new work. */
-    recordTelegramMessage(row: TelegramDelivery, binding: TelegramBinding, messageId: string, now: Date): void;
-    /** The newest confirmed message this notification became at one destination, if any. */
-    telegramMessageOf(notification: number, destination: string): string | null;
-    finalizeTelegramDelivery(row: TelegramDelivery, binding: TelegramBinding, owner: string, outcome: {
-        ok: true;
-        receipt: string | null;
-    } | {
-        ok: false;
-        error: string;
-        retryAt?: string;
-    }, now: Date): boolean;
-    /** The notifications this pairing holds, each with its delivery state there. */
-    telegramDeliveries(binding: TelegramBinding): NotificationReceipt[];
-    /** The digest cadence: null everyMs = off. */
-    telegramDigest(): TelegramDigest;
-    /** Set (or clear, with null) the cadence. Turning it on starts the
-     * window NOW — nothing held before the choice is dumped at once. */
-    setTelegramDigest(everyMs: number | null, by: string, now: Date): void;
+    telegramDeliveryProblem(...args: Parameters<ChatMessages["deliveryProblem"]>): ReturnType<ChatMessages["deliveryProblem"]>;
+    recordTelegramMessage(...args: Parameters<ChatMessages["recordMessage"]>): ReturnType<ChatMessages["recordMessage"]>;
+    telegramMessageOf(...args: Parameters<ChatMessages["messageOf"]>): ReturnType<ChatMessages["messageOf"]>;
+    finalizeTelegramDelivery(...args: Parameters<ChatMessages["finalizeDelivery"]>): ReturnType<ChatMessages["finalizeDelivery"]>;
+    telegramDeliveries(...args: Parameters<ChatMessages["deliveries"]>): ReturnType<ChatMessages["deliveries"]>;
+    telegramDigest(...args: Parameters<ChatMessages["digest"]>): ReturnType<ChatMessages["digest"]>;
+    setTelegramDigest(...args: Parameters<ChatMessages["setDigest"]>): ReturnType<ChatMessages["setDigest"]>;
     /** How chats reach this person: only when they are needed unless they chose every step. */
     notificationPreference(account: string): NotificationPreference;
     /** Change one person's choice; a digest time is a local HH:MM, or null for no evening digest. */
@@ -6672,7 +6428,7 @@ export declare class Store {
     chatBatchMessageFor(destination: string, taskRef: number, run: number): string | null;
     /** The message now showing this card, and what it shows. */
     setChatCardMessage(id: number, message: string, digest: string): void;
-    markTelegramDigestSent(now: Date): void;
+    markTelegramDigestSent(...args: Parameters<ChatMessages["markDigestSent"]>): ReturnType<ChatMessages["markDigestSent"]>;
     /** Routine rows waiting for the next digest: pending, and not urgent.
      * A row the live pairing delivered, or skipped as pre-pairing history,
      * is settled and not waiting. */
@@ -6797,33 +6553,10 @@ export declare class Store {
  * explicit skip, with no delivered timestamp and no attempt, so suppressed
  * history is never reported as a send that happened. */
 export declare const TELEGRAM_SKIPPED_RECEIPT = "skipped:before-pairing";
-/** v83: a notification for another person, settled for this destination without sending. */
-export declare const TELEGRAM_SKIPPED_ELSEWHERE = "skipped:for-another-person";
-/** A met promise the lead made on another chat: reported there, settled here without sending. */
-export declare const TELEGRAM_SKIPPED_OTHER_CHAT = "skipped:for-another-chat";
-/** A fact this person is not messaged about: the lead's work, their own act, or a project they muted. */
-export declare const TELEGRAM_SKIPPED_QUIET = "skipped:quiet";
-/**
- * Why the store itself holds a Telegram delivery back: authority,
- * provenance, ordering, a switched-off channel, or a wait it imposed. A
- * row held for one of these is waiting on policy, not failing on the wire.
- * Every other error recorded on a receipt came from an actual send, and
- * THAT is delivery trouble (`pendingForAttention`). One table, so the
- * fences and the tally can never disagree about the words.
- */
-export declare const TELEGRAM_HOLD_REASONS: Readonly<{
-    authority: "Telegram pairing or actor authorization changed";
-    destination: "Telegram destination changed";
-    claim: "Telegram delivery claim expired or changed";
-    rateLimit: "Telegram rate limit is still active";
-    resolved: "Notification no longer needs delivery";
-    provenance: "Notification has no trusted project provenance";
-    installation: "Installation notification requires instance access";
-    project: "Notification project is not currently authorized and enrolled";
-    task: "Notification task provenance changed";
-    order: "Earlier task notification is still undelivered";
-    disabled: "Telegram delivery is disabled";
-}>;
+export { TELEGRAM_HOLD_REASONS, TELEGRAM_SKIPPED_ELSEWHERE, TELEGRAM_SKIPPED_OTHER_CHAT, TELEGRAM_SKIPPED_QUIET };
+export { isLifecycleNotification, isTelegramProgressNotification, LIFECYCLE_KEY_PREFIX, LIFECYCLE_KINDS, proposalTaskOf, type LifecycleKind };
+/** A Telegram pairing, in the Telegram adapter's names: the bot is the installation, the user the member, the private chat the channel. */
+export declare function telegramBindingOf(binding: ChatBinding): TelegramBinding;
 export type WorktreeRow = {
     path: string;
     repo: string;