@llblab/pi-telegram 0.2.6 → 0.2.8

package/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Current
 
+- `[Rendering]` Preserved leading indentation on the first Markdown line, kept numeric markers for ordered task lists in both preview and final Telegram rendering, and stopped reinterpreting standalone `[x]` or `[ ]` prose as inline checkboxes. Impact: nested content no longer flattens when a message starts with indentation, numbered checklists keep their ordered semantics, and literal checklist-like prose stays literal.
+- `[Queue UI]` Marked liked high-priority queued Telegram turns with `⬆` in the pi status-bar queue preview. Impact: operators can now distinguish reaction-promoted turns from normal queued prompts at a glance.
 - `[Docs]` Added short responsibility header comments to every project `.ts` file. Impact: file boundaries are easier to understand while navigating the growing `/lib` split.
 - `[Naming]` Renamed extracted domain modules and mirrored regression suites to use repo-scoped bare domain filenames such as `api.ts`, `queue.ts`, and `queue.test.ts` instead of repeating `telegram-*` in every path. Impact: the internal topology is easier to scan and stays aligned with the repository-level Telegram scope.
 - `[Controls]` Expanded Telegram session controls with a richer `/status` view, inline model selection, and thinking-level controls, and fixed the callback-selection path so idle model and thinking picks apply immediately instead of only becoming visible after a later Telegram interaction. Impact: more bridge configuration can be managed directly from Telegram with more predictable immediate feedback.

package/README.md

@@ -4,8 +4,7 @@
 
 Telegram DM bridge for pi.
 
-This repository is a fork of the original [`badlogic/pi-telegram`](https://github.com/badlogic/pi-telegram).
-It started from upstream commit [`cb34008460b6c1ca036d92322f69d87f626be0fc`](https://github.com/badlogic/pi-telegram/commit/cb34008460b6c1ca036d92322f69d87f626be0fc) and has since diverged substantially.
+This repository is an actively maintained fork of [`badlogic/pi-telegram`](https://github.com/badlogic/pi-telegram). It started from upstream commit [`cb34008460b6c1ca036d92322f69d87f626be0fc`](https://github.com/badlogic/pi-telegram/commit/cb34008460b6c1ca036d92322f69d87f626be0fc) and has since diverged substantially.
 
 ## Start Here
 
@@ -14,19 +13,15 @@ It started from upstream commit [`cb34008460b6c1ca036d92322f69d87f626be0fc`](htt
 - [Changelog](./CHANGELOG.md)
 - [Documentation](./docs/README.md)
 
-## What Changed In This Fork
+## Key Features
 
-Compared to upstream commit `cb34008`, this fork significantly extends and hardens the extension.
-
-- Better Telegram control UI, including an improved `/status` view with inline buttons for model and thinking selection
-- Interactive model selection improvements, including scoped model lists, thinking-level control for reasoning-capable models, and in-flight restart on a newly selected model for active Telegram-owned runs
-- Queueing and interaction upgrades, including queue previews, reaction-based prioritization/removal, media-group handling, high-priority control actions, and safer dispatch behavior
-- Markdown and reply rendering improvements, with richer formatting support, narrow-client-friendly table/list rendering, quote compatibility fixes, and multiple fixes for incorrect Telegram rendering and chunking edge cases
-- Streaming, attachment, and delivery workflow hardening, including more robust preview updates and file handling
-- General runtime polish, bug fixes, and refactors across pairing, command handling, and Telegram session behavior
-- Cleaner internal domain layout, with flat `/lib/*.ts` modules and mirrored `/tests/*.test.ts` suites that use repo-scoped domain names instead of redundant `telegram-*` filename prefixes
-
-In short: this fork is no longer just a repackaged copy of upstream; it is a feature-expanded and bug-fixed Telegram frontend for pi.
+- **Priority Command Queue**: Control commands such as `/status` and `/model` use a high-priority control queue, so they do not get stuck behind normal queued prompts when pi is busy.
+- **Interactive UI**: Manage your session directly from Telegram. Inline buttons allow you to switch models and adjust reasoning (thinking) levels on the fly.
+- **In-flight Model Switching**: Change the active model mid-generation. The agent gracefully pauses, applies the new model, and restarts its response without losing context.
+- **Smart Message Queue**: Messages sent while the agent is busy are queued and previewed in the pi status bar, and queued turns can be reprioritized or removed with Telegram reactions.
+- **Mobile-Optimized Rendering**: Tables and lists are formatted for narrow screens. Markdown is correctly parsed and split to fit Telegram's limits without breaking HTML structures or code blocks.
+- **File Handling & Attachments**: Send images and files to the agent, or ask it to generate and return artifacts. Outbound files are delivered automatically via the `telegram_attach` tool.
+- **Streaming Responses**: Smooth, real-time typing effect using Telegram Drafts (or message edits as a fallback).
 
 ## Install
 
@@ -42,22 +37,16 @@ From git:
 pi install git:github.com/llblab/pi-telegram
 ```
 
-Or for a single run:
-
-```bash
-pi -e @llblab/pi-telegram
-```
-
 ## Configure
 
-### Telegram
+### 1. Telegram Bot
 
 1. Open [@BotFather](https://t.me/BotFather)
 2. Run `/newbot`
 3. Pick a name and username
 4. Copy the bot token
 
-### pi
+### 2. Connect to pi
 
 Start pi, then run:
 
@@ -65,125 +54,54 @@ Start pi, then run:
 /telegram-setup
 ```
 
-Paste the bot token when prompted.
-If a bot token is already saved in `~/.pi/agent/telegram.json`, `/telegram-setup` shows that stored value by default. Otherwise it pre-fills from the first configured environment variable in `TELEGRAM_BOT_TOKEN`, `TELEGRAM_BOT_KEY`, `TELEGRAM_TOKEN`, or `TELEGRAM_KEY`.
+Paste your bot token when prompted. If a bot token is already saved in `~/.pi/agent/telegram.json`, `/telegram-setup` shows that stored value by default. Otherwise it prefills from the first configured environment variable in `TELEGRAM_BOT_TOKEN`, `TELEGRAM_BOT_KEY`, `TELEGRAM_TOKEN`, or `TELEGRAM_KEY`.
 
-The extension stores config in:
-
-```text
-~/.pi/agent/telegram.json
-```
-
-## Connect a pi session
-
-The Telegram bridge is session-local. Connect it only in the pi session that should own the bot:
+Link the bridge to your current pi session:
 
 ```bash
 /telegram-connect
 ```
 
-To stop polling in the current session:
-
-```bash
-/telegram-disconnect
-```
-
-Check status:
-
-```bash
-/telegram-status
-```
+_(Note: The bridge is session-local. Only one pi session can be connected to the bot at a time.)_
 
-## Pair your Telegram account
-
-After token setup and `/telegram-connect`:
+### 3. Pair your account
 
 1. Open the DM with your bot in Telegram
 2. Send `/start`
 
-The first DM user becomes the allowed Telegram user for the bridge. The extension only accepts messages from that user.
+The first user to message the bot becomes the exclusive owner of the bridge. The extension will only accept messages from this user.
 
 ## Usage
 
-Chat with your bot in Telegram DMs.
-
-Additional fork-specific controls:
-
-- `/status` now has a richer view with inline buttons for model and thinking controls, and joins the high-priority control queue when pi is busy
-- `/model` opens the interactive model selector, applies idle selections immediately, joins the high-priority control queue when pi is busy, and can restart the active Telegram-owned run on the newly selected model, waiting for the current tool call to finish when needed
-- `/compact` starts session compaction when pi and the Telegram queue are idle
-- Queue reactions: `👍` prioritizes a waiting turn, `👎` removes it
-
-### Send text
-
-Send any message in the bot DM. It is forwarded into pi with a `[telegram]` prefix.
+Once paired, simply chat with your bot in Telegram. All text, images, and files are forwarded to pi.
 
-### Send images and files
+### Commands & Controls
 
-Send images, albums, or files in the DM.
+- **`/status`**: View session stats, cost, and use inline buttons to change models.
+- **`/model`**: Open the interactive model selector.
+- **`/compact`**: Start session compaction (only works when the session is idle).
+- **`/stop`** (or just **`stop`**): Abort the active run.
+- **`/telegram-disconnect`** (in pi): Stop polling in the current session.
+- **`/telegram-status`** (in pi): Check bridge status.
 
-The extension:
+### Queue, Reactions, and Media
 
-- downloads them to `~/.pi/agent/tmp/telegram`
-- includes local file paths in the prompt
-- forwards inbound images as image inputs to pi
+- If you send more Telegram messages while pi is busy, they are queued and processed in order.
+- `👍` moves a waiting turn into the priority block. Removing `👍` sends it back to its normal queue position, and adding `👍` again gives it a fresh priority position.
+- `👎` removes a waiting turn from the queue. Telegram Bot API does not expose ordinary DM message-deletion events through the polling path used here, so queue removal is bound to the dislike reaction.
+- For media groups, a reaction on any message in the group applies to the whole queued turn.
+- Inbound images, albums, and files are downloaded to `~/.pi/agent/tmp/telegram`, local file paths are included in the prompt, and inbound images are forwarded to pi as image inputs.
+- Queue reactions depend on Telegram delivering `message_reaction` updates for your bot and chat type.
 
-### Ask for files back
+### Requesting Files
 
-If you ask pi for a file or generated artifact, pi should call the `telegram_attach` tool. The extension then sends those files with the next Telegram reply.
+If you ask pi for a file or generated artifact (e.g., _"generate a shell script and attach it"_), pi will call the `telegram_attach` tool, and the extension will send the file alongside its next Telegram reply.
 
 Examples:
 
 - `summarize this image`
-- `read this README and summarize it`
-- `write me a markdown file with the plan and send it back`
 - `generate a shell script and attach it`
 
-### Stop a run
-
-In Telegram, send:
-
-```text
-stop
-```
-
-or:
-
-```text
-/stop
-```
-
-That aborts the active pi turn.
-
-### Queue follow-ups
-
-If you send more Telegram messages while pi is busy, they are queued and processed in order.
-
-The pi status bar shows queued Telegram turns as compact previews, for example:
-
-```text
-+3: [summarize this image…, write a shell script…, 📎 2 attachments]
-```
-
-Each preview is limited to at most 4 words or 32 characters.
-
-### Reprioritize or discard queued messages
-
-While a message is still waiting in the queue:
-
-- React with 👍 to move it into the priority block
-- React with 👎 to remove it from the queue
-
-Priority is stable:
-
-- The first liked queued message stays ahead of later liked messages
-- Removing 👍 sends the message back to its normal queue position
-- Adding 👍 again gives it a fresh priority position
-
-For media groups, a reaction on any message in the group applies to the whole queued turn.
-
-Message reactions depend on Telegram delivering `message_reaction` updates for your bot and chat type.
-
 ## Streaming
 
 The extension streams assistant text previews back to Telegram while pi is generating.

package/docs/architecture.md

@@ -68,7 +68,7 @@ Queued items now use two explicit dimensions:
 - `kind`: prompt vs control
 - `queueLane`: control vs priority vs default
 
-This lets synthetic control actions and Telegram prompts share one stable ordering model while still rendering distinctly in status output.
+This lets synthetic control actions and Telegram prompts share one stable ordering model while still rendering distinctly in status output. In the pi status bar queue preview, priority prompts are marked with `⬆` while control items keep their own control-specific summary markers such as `⚡`.
 
 A dispatched prompt remains in the queue until `agent_start` consumes it. That keeps the active Telegram turn bound correctly for previews, attachments, abort handling, and final reply delivery.
 
@@ -96,6 +96,7 @@ Key rules:
 - Real code blocks must remain literal and escaped
 - Markdown tables should keep their internal separators but drop the outer left and right borders when rendered as monospace blocks so narrow Telegram clients keep more usable width
 - Unordered Markdown lists should render with a monospace `-` marker and ordered Markdown lists should render with monospace numeric markers so list indentation stays more predictable on narrow Telegram clients
+- Real Markdown task-list items should render with checkbox markers, while standalone `[x]` and `[ ]` prose should stay literal instead of being reinterpreted as checklists
 - Nested Markdown quotes should flatten into one Telegram blockquote with added non-breaking-space indentation because Telegram does not render nested blockquotes reliably
 - Long replies must be split below Telegram's 4096-character limit
 - Chunking should avoid breaking HTML structure where possible
@@ -125,7 +126,7 @@ Current operator controls include:
 - Inline status buttons for model and thinking adjustments, applying idle selections immediately while still respecting busy-run restart rules
 - `/model` for interactive model selection, queued as a high-priority control item when needed and supporting in-flight restart of the active Telegram-owned run on a newly selected model
 - `/compact` for Telegram-triggered pi session compaction when the bridge is idle
-- Queue reactions using `👍` and `👎`
+- Queue reactions using `👍` and `👎`, with `👎` acting as the canonical queue-removal path because ordinary Telegram DM message deletions are not exposed through the Bot API polling path this bridge uses
 
 ## In-Flight Model Switching
 

package/index.ts

@@ -235,14 +235,12 @@ interface TelegramMessageReactionUpdated {
 }
 
 interface TelegramUpdate {
-  _: string;
   update_id: number;
   message?: TelegramMessage;
   edited_message?: TelegramMessage;
   callback_query?: TelegramCallbackQuery;
   message_reaction?: TelegramMessageReactionUpdated;
   deleted_business_messages?: { message_ids?: unknown };
-  messages?: unknown;
 }
 
 interface TelegramGetFileResult {

package/lib/polling.ts

@@ -11,6 +11,8 @@ export interface TelegramUpdateLike {
   update_id: number;
 }
 
+// Standard Telegram DM polling does not expose ordinary message-deletion events,
+// so queue removal stays reaction-driven while delete-like business updates remain defensive-only.
 export const TELEGRAM_ALLOWED_UPDATES = [
   "message",
   "edited_message",

package/lib/queue.ts

@@ -189,6 +189,13 @@ export function consumeDispatchedTelegramPrompt(
   return { activeTurn: nextItem, remainingItems: items.slice(1) };
 }
 
+function formatTelegramQueueItemStatusSummary(item: TelegramQueueItem): string {
+  if (item.queueLane === "priority") {
+    return `⬆ ${item.statusSummary}`;
+  }
+  return item.statusSummary;
+}
+
 export function formatQueuedTelegramItemsStatus(
   items: TelegramQueueItem[],
 ): string {
@@ -196,7 +203,7 @@ export function formatQueuedTelegramItemsStatus(
   const previewCount = 4;
   const summaries = items
     .slice(0, previewCount)
-    .map((item) => item.statusSummary)
+    .map(formatTelegramQueueItemStatusSummary)
     .filter(Boolean);
   if (summaries.length === 0) return ` +${items.length}`;
   const suffix = items.length > summaries.length ? ", …" : "";

package/lib/rendering.ts

@@ -129,8 +129,25 @@ function stripIndentedCodePrefix(line: string): string {
   return line;
 }
 
+function normalizeMarkdownDocument(markdown: string): string {
+  const lines = markdown.replace(/\r\n/g, "\n").split("\n");
+  let start = 0;
+  while (start < lines.length && (lines[start] ?? "").trim().length === 0) {
+    start += 1;
+  }
+  let end = lines.length;
+  while (end > start && (lines[end - 1] ?? "").trim().length === 0) {
+    end -= 1;
+  }
+  return lines.slice(start, end).join("\n");
+}
+
+function isMarkdownNumberedListMarker(marker: string): boolean {
+  return /^\d+\.$/.test(marker);
+}
+
 export function renderMarkdownPreviewText(markdown: string): string {
-  const normalized = markdown.replace(/\r\n/g, "\n").trim();
+  const normalized = normalizeMarkdownDocument(markdown);
   if (normalized.length === 0) return "";
   const output: string[] = [];
   const lines = normalized.split("\n");
@@ -169,9 +186,14 @@ export function renderMarkdownPreviewText(markdown: string): string {
     const task = line.match(/^(\s*)([-*+]|\d+\.)\s+\[([ xX])\]\s+(.+)$/);
     if (task) {
       const indent = " ".repeat((task[1] ?? "").length);
-      const marker = (task[3] ?? " ").toLowerCase() === "x" ? "[x]" : "[ ]";
+      const listMarker = task[2] ?? "-";
+      const checkboxMarker =
+        (task[3] ?? " ").toLowerCase() === "x" ? "[x]" : "[ ]";
+      const taskPrefix = isMarkdownNumberedListMarker(listMarker)
+        ? `${listMarker} ${checkboxMarker}`
+        : checkboxMarker;
       output.push(
-        `${indent}${marker} ${stripInlineMarkdownToPlainText(task[4] ?? "")}`,
+        `${indent}${taskPrefix} ${stripInlineMarkdownToPlainText(task[4] ?? "")}`,
       );
       continue;
     }
@@ -275,13 +297,6 @@ function renderInlineMarkdown(text: string): string {
   result = renderDelimitedInlineStyle(result, "_", (content) => {
     return `<i>${content}</i>`;
   });
-  result = result.replace(
-    /(^|[\s>(])(\[(?: |x|X)\])(?=($|[\s<).,:;!?]))/g,
-    (_match, prefix: string, checkbox: string) => {
-      const normalized = checkbox.toLowerCase() === "[x]" ? "[x]" : "[ ]";
-      return `${prefix}<code>${normalized}</code>`;
-    },
-  );
   result = result.replace(/\\([\\`*_{}\[\]()#+\-.!>~|])/g, "$1");
   return result.replace(
     /\uE000(\d+)\uE001/g,
@@ -330,9 +345,14 @@ function renderMarkdownTextLines(block: string): string[] {
       const task = piece.match(/^(\s*)([-*+]|\d+\.)\s+\[([ xX])\]\s+(.+)$/);
       if (task) {
         const indent = buildListIndent(Math.floor((task[1] ?? "").length / 2));
-        const marker = (task[3] ?? " ").toLowerCase() === "x" ? "[x]" : "[ ]";
+        const listMarker = task[2] ?? "-";
+        const checkboxMarker =
+          (task[3] ?? " ").toLowerCase() === "x" ? "[x]" : "[ ]";
+        const taskPrefix = isMarkdownNumberedListMarker(listMarker)
+          ? `<code>${listMarker}</code> <code>${checkboxMarker}</code>`
+          : `<code>${checkboxMarker}</code>`;
         rendered.push(
-          `${indent}<code>${marker}</code> ${renderInlineMarkdown(task[4] ?? "")}`,
+          `${indent}${taskPrefix} ${renderInlineMarkdown(task[4] ?? "")}`,
         );
         continue;
       }
@@ -498,7 +518,7 @@ function renderMarkdownQuoteBlock(lines: string[]): string[] {
 }
 
 function renderMarkdownToTelegramHtmlChunks(markdown: string): string[] {
-  const normalized = markdown.replace(/\r\n/g, "\n").trim();
+  const normalized = normalizeMarkdownDocument(markdown);
   if (normalized.length === 0) return [];
   const renderedBlocks: string[] = [];
   const lines = normalized.split("\n");

package/lib/updates.ts

@@ -22,8 +22,6 @@ export type TelegramReactionTypeLike =
 
 export interface TelegramUpdateLike {
   deleted_business_messages?: { message_ids?: unknown };
-  _: string;
-  messages?: unknown;
 }
 
 function isTelegramMessageIdList(value: unknown): value is number[] {
@@ -55,12 +53,6 @@ export function extractDeletedTelegramMessageIds(
   if (isTelegramMessageIdList(deletedBusinessMessageIds)) {
     return deletedBusinessMessageIds;
   }
-  if (
-    update._ === "updateDeleteMessages" &&
-    isTelegramMessageIdList(update.messages)
-  ) {
-    return update.messages;
-  }
   return [];
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "private": false,
   "description": "Better Telegram DM bridge extension for pi",
   "type": "module",
@@ -29,7 +29,8 @@
   "pi": {
     "extensions": [
       "./index.ts"
-    ]
+    ],
+    "image": "https://github.com/llblab/pi-telegram/raw/main/screenshot.png"
   },
   "peerDependencies": {
     "@mariozechner/pi-ai": "*",

package/tests/queue.test.ts

@@ -16,6 +16,7 @@ import {
   buildTelegramSessionStartState,
   executeTelegramControlItemRuntime,
   executeTelegramQueueDispatchPlan,
+  formatQueuedTelegramItemsStatus,
   getNextTelegramToolExecutionCount,
   shouldStartTelegramPolling,
 } from "../lib/queue.ts";
@@ -169,6 +170,57 @@ test("Queue mutation helpers apply and clear prompt priority without touching co
   assert.equal(cleared.items[1]?.queueLane, "control");
 });
 
+test("Queued status formatting marks priority prompts in the pi status bar", () => {
+  const queueItemType = undefined as
+    | Parameters<typeof formatQueuedTelegramItemsStatus>[0][number]
+    | undefined;
+  const priorityPrompt: typeof queueItemType = {
+    kind: "prompt",
+    chatId: 1,
+    replyToMessageId: 1,
+    sourceMessageIds: [11],
+    queueOrder: 4,
+    queueLane: "priority",
+    laneOrder: 0,
+    queuedAttachments: [],
+    content: [{ type: "text", text: "prompt" }],
+    historyText: "prompt history",
+    statusSummary: "prompt",
+  };
+  const defaultPrompt: typeof queueItemType = {
+    kind: "prompt",
+    chatId: 1,
+    replyToMessageId: 2,
+    sourceMessageIds: [12],
+    queueOrder: 5,
+    queueLane: "default",
+    laneOrder: 5,
+    queuedAttachments: [],
+    content: [{ type: "text", text: "default" }],
+    historyText: "default history",
+    statusSummary: "default",
+  };
+  const controlItem: typeof queueItemType = {
+    kind: "control",
+    controlType: "status",
+    chatId: 1,
+    replyToMessageId: 3,
+    queueOrder: 6,
+    queueLane: "control",
+    laneOrder: 0,
+    statusSummary: "⚡ status",
+    execute: async () => {},
+  };
+  assert.equal(
+    formatQueuedTelegramItemsStatus([
+      controlItem,
+      priorityPrompt,
+      defaultPrompt,
+    ]),
+    " +3: [⚡ status, ⬆ prompt, default]",
+  );
+});
+
 test("History partition keeps control items queued and extracts prompt items", () => {
   const queueItemType = undefined as
     | Parameters<

package/tests/rendering.test.ts

@@ -7,6 +7,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import { __telegramTestUtils } from "../index.ts";
+import { renderMarkdownPreviewText } from "../lib/rendering.ts";
 
 test("Nested lists stay out of code blocks", () => {
   const chunks = __telegramTestUtils.renderTelegramMessage(
@@ -68,6 +69,50 @@ test("Numbered lists use monospace numeric markers", () => {
   assert.match(chunks[0]?.text ?? "", /<code>2\.<\/code> second/);
 });
 
+test("Ordered task lists preserve numeric markers in previews and final rendering", () => {
+  const markdown = "1. [x] first\n2. [ ] second";
+  assert.equal(renderMarkdownPreviewText(markdown), markdown);
+  const chunks = __telegramTestUtils.renderTelegramMessage(markdown, {
+    mode: "markdown",
+  });
+  assert.equal(chunks.length, 1);
+  assert.match(
+    chunks[0]?.text ?? "",
+    /<code>1\.<\/code> <code>\[x\]<\/code> first/,
+  );
+  assert.match(
+    chunks[0]?.text ?? "",
+    /<code>2\.<\/code> <code>\[ \]<\/code> second/,
+  );
+});
+
+test("Leading indentation on the first markdown line stays intact", () => {
+  const markdown = "  - nested bullet\n    - nested child";
+  assert.equal(renderMarkdownPreviewText(markdown), markdown);
+  const chunks = __telegramTestUtils.renderTelegramMessage(markdown, {
+    mode: "markdown",
+  });
+  assert.equal(chunks.length, 1);
+  assert.match(chunks[0]?.text ?? "", /^\u00A0\u00A0<code>-<\/code> nested bullet/m);
+  assert.match(
+    chunks[0]?.text ?? "",
+    /^\u00A0\u00A0\u00A0\u00A0<code>-<\/code> nested child/m,
+  );
+});
+
+test("Standalone checkbox-looking prose stays literal outside task lists", () => {
+  const markdown = "Use [ ] as a placeholder and keep [x] literal";
+  assert.equal(renderMarkdownPreviewText(markdown), markdown);
+  const chunks = __telegramTestUtils.renderTelegramMessage(markdown, {
+    mode: "markdown",
+  });
+  assert.equal(chunks.length, 1);
+  assert.equal((chunks[0]?.text ?? "").includes("<code>[ ]</code>"), false);
+  assert.equal((chunks[0]?.text ?? "").includes("<code>[x]</code>"), false);
+  assert.match(chunks[0]?.text ?? "", /Use \[ \] as a placeholder/);
+  assert.match(chunks[0]?.text ?? "", /keep \[x\] literal/);
+});
+
 test("Nested blockquotes flatten into one Telegram blockquote with indentation", () => {
   const chunks = __telegramTestUtils.renderTelegramMessage(
     "> outer\n>> inner\n>>> deepest",

package/tests/updates.test.ts

@@ -30,28 +30,20 @@ test("Update helpers normalize emoji reactions and collect emoji-only entries",
   assert.deepEqual([...emojis], ["👍", "👎"]);
 });
 
-test("Update helpers extract deleted message ids from Telegram update variants", () => {
+test("Update helpers extract deleted business-message ids only from Bot API shapes", () => {
   assert.deepEqual(
     extractDeletedTelegramMessageIds({
-      _: "other",
       deleted_business_messages: { message_ids: [1, 2] },
     }),
     [1, 2],
   );
   assert.deepEqual(
     extractDeletedTelegramMessageIds({
-      _: "updateDeleteMessages",
-      messages: [3, 4],
-    }),
-    [3, 4],
-  );
-  assert.deepEqual(
-    extractDeletedTelegramMessageIds({
-      _: "updateDeleteMessages",
-      messages: [3, "bad"],
+      deleted_business_messages: { message_ids: [3, "bad"] },
     }),
     [],
   );
+  assert.deepEqual(extractDeletedTelegramMessageIds({}), []);
 });
 
 test("Update routing classifies authorization state for pair, allow, and deny", () => {
@@ -101,11 +93,10 @@ test("Update routing extracts private human messages from message or edited_mess
   assert.ok(directMessage);
 });
 
-test("Update flow prioritizes deleted-message handling over other update kinds", () => {
+test("Update flow prioritizes deleted business-message handling over other update kinds", () => {
   const action = buildTelegramUpdateFlowAction(
     {
-      _: "updateDeleteMessages",
-      messages: [1, 2],
+      deleted_business_messages: { message_ids: [1, 2] },
       message_reaction: {
         chat: { type: "private" },
         user: { id: 1, is_bot: false },
@@ -119,7 +110,6 @@ test("Update flow prioritizes deleted-message handling over other update kinds",
 test("Update flow returns authorized callback and message actions", () => {
   const callbackAction = buildTelegramUpdateFlowAction(
     {
-      _: "other",
       callback_query: {
         from: { id: 7, is_bot: false },
         message: { chat: { type: "private" } },
@@ -133,7 +123,6 @@ test("Update flow returns authorized callback and message actions", () => {
     { kind: "allow" },
   );
   const messageAction = buildTelegramUpdateFlowAction({
-    _: "other",
     message: {
       chat: { type: "private" },
       from: { id: 9, is_bot: false },
@@ -148,7 +137,6 @@ test("Update flow returns authorized callback and message actions", () => {
 
 test("Update flow ignores unauthorized transport shapes and preserves reaction events", () => {
   const reactionAction = buildTelegramUpdateFlowAction({
-    _: "other",
     message_reaction: {
       chat: { type: "private" },
       user: { id: 1, is_bot: false },
@@ -156,7 +144,6 @@ test("Update flow ignores unauthorized transport shapes and preserves reaction e
   });
   assert.equal(reactionAction.kind, "reaction");
   const ignored = buildTelegramUpdateFlowAction({
-    _: "other",
     callback_query: {
       from: { id: 1, is_bot: true },
       message: { chat: { type: "private" } },
@@ -218,7 +205,6 @@ test("Update execution plan preserves deleted and reaction actions", () => {
 test("Update execution plan can be built directly from updates", () => {
   const plan = buildTelegramUpdateExecutionPlanFromUpdate(
     {
-      _: "other",
       callback_query: {
         from: { id: 4, is_bot: false },
         message: { chat: { type: "private" } },
@@ -260,7 +246,6 @@ test("Update runtime can execute directly from raw updates", async () => {
   const events: string[] = [];
   await executeTelegramUpdate(
     {
-      _: "other",
       message: {
         chat: { id: 10, type: "private" },
         message_id: 20,