@llblab/pi-telegram 0.24.10 → 0.24.11

package/AGENTS.md

@@ -124,8 +124,9 @@ The core product loop is mobile continuation: start or supervise work in the ter
 - Agent activity status is native-only for the release path: Telegram uses `sendChatAction(typing)` and renders its native `…typing` indicator as the automatic work signal. When a connected instance starts any real agent run, send that indicator to the instance's own thread (and aggregate `All` surface), including Telegram turns, local/TUI prompts, and autonomous continuations such as Grow Loop; stop it at agent/session completion. Keep at most one chat action in flight per loop, coalesce identical leader-side actions across follower traffic, and treat Telegram 429 `retry_after` as a shared suppression window rather than a delayed retry or persistent terminal error. This signal is independent from terminal `Active`, which remains scoped to Telegram-owned turns. Confirmed manual `/compact` and automatic compaction tied to an active Telegram turn also use native activity. Do not send activity merely for startup/connect/reload/recovery or add extra in-chat work surfaces without a new explicit design decision.
 - Voice reply mode Settings UI standard: the top-level Settings row is `👄 Voice reply: hidden|mirror|always`; `hidden` is the true default, persists no `voice.replyMode`, adds no voice context, and still allows explicit agent-authored `telegram_voice`; `mirror` activates automatic voice context only for voice/audio input, and `always` activates it for every Telegram turn. The submenu title is `👄 Voice reply mode:`; choice buttons use lowercase labels with a model-style active dot (`🟢 hidden`, `🟢 mirror`) rather than per-mode emoji; the explanatory submenu body uses compact HTML-code bullets such as `<code>-</code> <code>hidden</code> (default): ...`. Preserve this wording/icons unless the operator explicitly asks to redesign it
 - Outbound voice delivery is one fallback pipeline: configured `outboundHandlers` with `type: "voice"` run first in `telegram.json` order, then programmatic voice handlers, then registered voice synthesis providers as zero-config progressive fallbacks; provider extensions must not override operator-configured handlers
-- `telegram_voice` text is arbitrary TTS-target text and the prompt should show only forms that include text to speak: `<!-- telegram_voice text="Short summary" -->` or `<!-- telegram_voice: Short summary -->`. Avoid raw Markdown/code/tables in voice text.
-- `telegram_button` has three canonical forms: `<!-- telegram_button: OK -->` for label-only buttons, `<!-- telegram_button label=Continue prompt="Continue with the current plan." -->` for one-line prompts, or `<!-- telegram_button label="Show risks"\nList the main risks first.\n-->` for multiline prompts. The bridge preserves agent-authored label text and emoji, and owns post-selection state without changing that label: optional `selected_style="primary|success|danger"` selects blue, green, or red after queue admission, with `primary` as the default, and color never suppresses the prompt. Do not author JSON button specs, inline-after-text comments, standalone button tools, or comments inside code/quotes/lists/indented examples; write normal Markdown plus top-level hidden comments, and let the bridge supply the standard `☑️ **Choose an option:**` Rich Markdown heading when buttons are the only output
+- `telegram_voice` and `telegram_button` action comments have exactly two payload forms: a JSON object or double-quoted HTML-like attributes. An optional colon after the action name never selects or changes the payload format; the parser removes it before detecting `{...}` JSON or attributes. JSON is the universal form for long or escaped content, while attributes are the compact form. Keep each complete action in one top-level comment and encode JSON line breaks as `\n`; shorthand, body, paired-comment, unquoted-attribute, and single-quoted-attribute forms are invalid.
+- `telegram_voice` accepts equivalent `text` or `value` keys, with explicit `text` taking precedence when both appear; optional `lang` and `rate` use the same payload object or attributes. Voice text is arbitrary TTS-target text; avoid raw Markdown, code, and tables.
+- `telegram_button` accepts `label` plus `prompt`, or the compact `value` key when both strings are identical; explicitly supplied `label` or `prompt` takes precedence over the corresponding `value` fallback. Optional `selected_style="primary|success|danger"` selects blue, green, or red after queue admission, with `primary` as the default. The bridge preserves agent-authored label text and emoji, and color never suppresses the prompt. Keep comments out of code, quotes, lists, and indented examples; write normal Markdown plus top-level hidden comments, and let the bridge supply the standard `☑️ **Choose an option:**` Rich Markdown heading when buttons are the only output
 
 ## 6. Engineering Conventions
 

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+## 0.24.11: Assistant Action Markup Hotfix
+
+- `Assistant Action Markup`: Standardized `telegram_button` and `telegram_voice` on two model-facing payload forms: JSON objects and compact double-quoted attributes. The separator colon after either action name is optional and format-neutral, so mixed model output such as colon-prefixed attributes or colonless JSON parses identically. Buttons may use compact `value` when `label` and `prompt` are identical, while voice treats `text` and `value` as equivalent payload keys; explicit fields take precedence. Removed shorthand, body, paired-comment, unquoted-attribute, and single-quoted-attribute parsing so one complete comment owns each action. Impact: models use one shared action grammar without duplicating equal button text or navigating hidden legacy variants.
+- `Composition Root Cooling`: Moved current-process bus identity defaults into `bus`, moved generated-button reply-markup edits into the direct/bus-aware Telegram API runtimes, and removed the always-true bus-configuration callback from Threaded Mode orchestration. Impact: `index.ts` loses low-level process/time/API payload work and dormant policy branching while retaining visible high-level port wiring.
+
 ## 0.24.10: Compact Thread Role Hotfix
 
 - `Status`: Threaded Mode status again appends only `@leader` or `@follower` to the execution status instead of repeating the visible Telegram tab name on a separate `Thread` row. Impact: compact `/status` output avoids redundant thread identity while retaining the transport role.

package/README.md

@@ -179,11 +179,11 @@ Inbound files land under `<agent-dir>/tmp/telegram` and default to a 50 MiB limi
 
 ### Voice And Media
 
-Voice notes, audio, images, PDFs, and other media can pass through configured inbound handlers, programmatic handlers, or registered STT providers. Outbound voice can use configured `outboundHandlers` or registered TTS providers; `pi-telegram` owns reply policy and Telegram transport, while providers own synthesis.
+Voice notes, audio, images, PDFs, and other media can pass through configured inbound handlers, programmatic handlers, or registered STT providers. Outbound voice can use configured `outboundHandlers` or registered TTS providers; `pi-telegram` owns reply policy and Telegram transport, while providers own synthesis. Explicit `telegram_voice` actions accept either a JSON object or compact double-quoted attributes, with equivalent `text` and `value` payload keys and an optional format-neutral colon after the action name.
 
 ### Buttons And Callbacks
 
-Assistant replies can include top-level hidden `telegram_button` comments. The bridge strips the comments from visible text, renders inline buttons, and routes callbacks back into Pi as queued prompts or extension-owned callback actions. Button-only replies receive the standard `☑️ **Choose an option:**` heading as automatic visible fallback text. Once a generated prompt button is accepted, only that exact button switches to its optional `selected_style` (`primary` blue by default, `success` green, or `danger` red) without altering its agent-authored label or emoji; every style still queues the selected prompt.
+Assistant replies can include top-level hidden `telegram_button` comments using either a JSON object or compact double-quoted attributes. Buttons use `label` plus `prompt`, or the compact `value` key when both are identical. The optional colon after the action name never changes format detection. The bridge strips the comments from visible text, renders inline buttons, and routes callbacks back into Pi as queued prompts or extension-owned callback actions. Button-only replies receive the standard `☑️ **Choose an option:**` heading as automatic visible fallback text. Once a generated prompt button is accepted, only that exact button switches to its optional `selected_style` (`primary` blue by default, `success` green, or `danger` red) without altering its agent-authored label or emoji; every style still queues the selected prompt.
 
 ### Threaded Mode And Multi-Instance Bus
 

package/docs/architecture.md

@@ -279,7 +279,7 @@ Final delivery attaches reply metadata only where requested. Reply parameters ap
 
 Outbound files staged during an active Telegram turn are delivered after that turn completes. They use `telegram_attach`, are checked atomically per tool call, and use configurable size limits before photo/document upload. When no Telegram turn is active, `telegram_attach` sends files immediately to the paired/default chat, an assigned follower thread, or an explicit `chat_id` plus optional `thread_id`; `telegram_message` provides direct local/TUI Markdown text delivery for explicit user requests and runs the same `telegram_button` markup planner so buttons attach to that text message. Direct local/TUI delivery is singleton-controlled: classic mode requires this Pi instance to own `/telegram-connect`, while Threaded Mode followers must be registered and route through the leader-owned transport. Already accepted active-turn reply/attachment delivery remains session-local.
 
-Assistant-authored final-message actions use hidden top-level comments:
+Assistant-authored final-message actions use hidden top-level comments. Both actions accept a JSON object or double-quoted HTML-like attributes; an optional colon after the action name is format-neutral and stripped before payload detection:
 
 - `telegram_voice` creates voice reply artifacts through configured outbound handlers, programmatic voice handlers, or registered synthesis providers.
 - `telegram_button` creates inline buttons whose callbacks enqueue the configured prompt text as a normal Telegram prompt turn.

package/docs/outbound.md

@@ -106,51 +106,44 @@ Synthesis providers receive the extracted `telegram_voice` text plus optional `l
 
 ## Voice Markup
 
-Assistant replies can include a hidden voice block:
+Assistant replies can include hidden voice actions in either supported payload form:
 
 ```md
 Full text answer stays here.
 
-<!-- telegram_voice lang=ru rate=+30%
-Text to synthesize as a Telegram voice message.
--->
+<!-- telegram_voice: {"value":"Short spoken companion summary.","lang":"ru","rate":"+30%"} -->
 
-<!-- telegram_voice lang=ru rate=+30% text="Short spoken companion summary." -->
-
-<!-- telegram_voice: Short spoken companion summary. -->
+<!-- telegram_voice text="Short spoken companion summary." lang="ru" rate="+30%" -->
 ```
 
-The bridge strips the comment from Telegram text. On `agent_end`, it maps each `telegram_voice` block to a provider call, generates one file per block, and sends each file as an independent Telegram-native voice message. The opening `<!-- telegram_voice` marker must start at column zero on a top-level line outside fenced code, quotes, and lists; otherwise it is rendered as literal Markdown. Body-form comments leave the opening line unclosed until the body-ending `-->`; closed heads can use `text="..."` for explicit one-line spoken text.
+The bridge strips the comment from Telegram text. On `agent_end`, it maps each `telegram_voice` action to a provider call, generates one file per action, and sends each file as an independent Telegram-native voice message. Equivalent `text` or `value` supplies the spoken payload, with explicit `text` taking precedence when both appear; `lang` and `rate` are optional. The colon after `telegram_voice` is optional for both JSON and attributes and never changes format detection. Use JSON for long or escaped text and encode line breaks inside JSON strings as `\n`. The opening marker must start at column zero on a top-level line outside fenced code, quotes, lists, and indented examples; otherwise it remains literal Markdown.
 
 ## Buttons Markup
 
-Assistant replies can include independent button blocks. The prompt is sent back to Pi when the user taps the button; use the colon shorthand when the prompt should equal the label, `prompt="..."` for one-line prompts, or the body form for multiline prompts:
+Assistant replies can include independent button actions in the same two payload forms:
 
 ```md
 I can continue.
 
-<!-- telegram_button label=Continue prompt="Continue with the current plan." -->
+<!-- telegram_button: {"label":"Continue","prompt":"Continue with the current plan.","selected_style":"primary"} -->
 
-<!-- telegram_button label="Show risks"
-List the main risks first.
--->
+<!-- telegram_button label="Show risks" prompt="List the main risks first." selected_style="danger" -->
 
-<!-- telegram_button: Done -->
+<!-- telegram_button: {"value":"Done"} -->
 ```
 
 Rules:
 
-- `telegram_button: Label` creates one independent label-only button row whose prompt equals the label.
-- `telegram_button label="Label" prompt="Prompt"` creates one independent button row whose prompt is the `prompt` attribute.
-- `telegram_button label="Label"` with a body creates one independent button row whose prompt is the block body.
-- The opening `<!-- telegram_button` marker must start at column zero on a top-level line outside fenced code, quotes, lists, and indented examples; otherwise it is literal Markdown.
-- Keep the canonical body form as `<!-- telegram_button label="Label"` + body + `-->`; closed heads must use `prompt="..."` or the colon shorthand to create a button.
-- Use one block per button; this mirrors HTML's singular element model and avoids a nested button DSL inside comments.
+- JSON objects and double-quoted HTML-like attributes are the only accepted payload forms; shorthand, body, paired-comment, unquoted-attribute, and single-quoted-attribute forms are rejected.
+- The colon after `telegram_button` is optional for both forms and never changes format detection.
+- Use `label` plus `prompt`, or the compact `value` key when both strings are identical. Explicit `label` or `prompt` takes precedence over its `value` fallback. Use JSON with `\n` escapes for multiline prompts.
+- The opening marker must start at column zero on a top-level line outside fenced code, quotes, lists, and indented examples; otherwise it remains literal Markdown.
+- Use one comment per button; this mirrors HTML's singular element model and avoids a nested button DSL.
 - Button actions are stored in memory with short `callback_data`; Telegram never sees the full prompt in the button payload.
-- After Telegram accepts a generated button callback as a queued prompt, the bridge changes that exact button to its configured selection style without changing agent-authored text or emoji. Set `selected_style="primary"` (blue), `selected_style="success"` (green), or `selected_style="danger"` (red); omitted or invalid values fall back to `primary`. The style never suppresses queue admission. Other choices stay visually unchanged and remain available; the callback acknowledgement remains the fallback on clients that do not render button styles.
+- After Telegram accepts a generated button callback as a queued prompt, the bridge changes that exact button to its configured selection style without changing agent-authored text or emoji. Set `selected_style` to `primary` (blue), `success` (green), or `danger` (red); omitted or invalid values fall back to `primary`. The style never suppresses queue admission. Other choices stay visually unchanged and remain available; the callback acknowledgement remains the fallback on clients that do not render button styles.
 - When generated button markup is the entire assistant reply, the bridge supplies the standard `☑️ **Choose an option:**` heading as visible message text so Telegram has a message to which it can attach the inline keyboard.
 
-Do not emit JSON button specs, inline comments after visible text, standalone button actions, or tool calls for ordinary Telegram-turn buttons. The agent writes Markdown plus hidden comments; the bridge strips comments and attaches Telegram `reply_markup` after `agent_end`. For local/TUI-originated direct sends, put the same Markdown and `telegram_button` comments in `telegram_message(text)`.
+Do not emit inline comments after visible text, standalone button actions, or tool calls for ordinary Telegram-turn buttons. The agent writes Markdown plus hidden comments; the bridge strips comments and attaches Telegram `reply_markup` after `agent_end`. For local/TUI-originated direct sends, put the same Markdown and `telegram_button` comments in `telegram_message(text)`.
 
 Buttons are built in and do not need a command template because they are pure Telegram reply markup plus callback routing.
 
@@ -162,8 +155,8 @@ The extension injects prompt guidance by context:
 - For ordinary local/TUI prompts, the agent only sees compact direct-delivery guidance: use `telegram_attach` or `telegram_message` when the user asks to send something to Telegram, and otherwise answer locally as normal.
 - For Telegram-originated turns, the prompt carries only minimal mobile/reply/file guidance; agents can call `telegram_help()` for full voice/button/direct-delivery/Threaded Mode/formatting/debug details.
 - For Telegram-originated turns, write the full technical answer as normal Markdown.
-- Add `telegram_voice` when a Telegram-native voice message is useful; use body text, `text="..."`, or colon shorthand for the text to synthesize. A companion summary is optional, no specific summary format is required.
-- Add `telegram_button: ...` when label equals prompt, `telegram_button label="..." prompt="..."` for one-line prompts, or `telegram_button label="..."` with a body for multiline prompts. Use optional `selected_style="success|danger|primary"` for post-admission color. A button-only reply may omit parent text because the bridge supplies `☑️ **Choose an option:**` automatically.
+- Add `telegram_voice` with either a JSON object or double-quoted attributes when a Telegram-native voice message is useful. A companion summary is optional, no specific summary format is required.
+- Add `telegram_button` with either a JSON object or double-quoted attributes. Use `label` plus `prompt`, or `value` when they are identical; `selected_style` is optional. A button-only reply may omit parent text because the bridge supplies `☑️ **Choose an option:**` automatically.
 - For ordinary Telegram-turn replies, do not call transport tools for voice or buttons; the bridge owns delivery, while registered voice synthesis providers own TTS and OGG/Opus conversion. For explicit local/TUI direct sends, `telegram_message` may include top-level `telegram_button` comments in its Markdown text because those buttons are attached to that text message.
 - Prefer meaningful visible parent text when it adds context; for a button-only answer, rely on the bridge's automatic `☑️ **Choose an option:**` fallback rather than manufacturing duplicate text.
 

package/docs/public-api.md

@@ -64,8 +64,8 @@ This command surface is a mobile companion subset, not a raw terminal-command br
 - `telegram_attach(paths, chat_id?, thread_id?, caption?)` is the stable artifact delivery tool for generated files. During Telegram turns it queues files for the active reply; with `assistant.rendering: "rich"`, exactly one PNG/JPEG, MP4, or MP3 artifact plus non-empty final Markdown can become one reply-anchored Rich Message. HTML mode, multiple/unsupported files, Guest Mode, and voice outputs retain their established paths. Outside Telegram turns the tool sends files directly to the paired/default chat, the registered follower's assigned thread, or an explicit `chat_id` plus optional `thread_id` when this Pi instance owns `/telegram-connect` or is registered with the multi-instance bus.
 - `telegram_message(text, chat_id?, thread_id?)` sends a direct Telegram Markdown message from local/TUI-initiated work when this Pi instance owns `/telegram-connect` or is registered with the multi-instance bus. Top-level `telegram_button` comments inside `text` are parsed with the same planner used for normal replies and attached to that message; buttons are never standalone Telegram messages.
 - `telegram_help()` returns detailed agent-facing guidance for pi-telegram delivery actions, Threaded Mode, formatting, and debugging. The regular prompt only points agents at this tool instead of repeating the full guidance on every turn. `telegram_attach`, `telegram_message`, and `telegram_help` remain registered but are model-active only while this instance owns direct transport or holds a live follower registration; disconnect/loss suppresses their schemas and prompt metadata, and recovery restores only the operator's previously active pi-telegram subset.
-- `telegram_voice` hidden comments request Telegram-native voice delivery.
-- `telegram_button` hidden comments create inline buttons whose taps enqueue prompts. Use top-level column-zero comments outside code, quotes, lists, and indented examples; do not emit JSON button specs or standalone button actions.
+- `telegram_voice` hidden comments request Telegram-native voice delivery through either a JSON object or double-quoted attributes. Equivalent `text` or `value` supplies the spoken payload; explicit `text` takes precedence.
+- `telegram_button` hidden comments create inline buttons whose taps enqueue prompts through the same two payload forms. Use `label` plus `prompt`, or `value` when both strings are identical. The colon after either action name is optional and does not select the format. Use top-level column-zero comments outside code, quotes, lists, and indented examples; do not emit standalone button actions.
 
 Prompt guidance is context-aware: local/TUI prompts see only explicit direct-delivery guidance, while Telegram-originated turns receive the full action-comment syntax and phone-width output contract.
 

package/index.ts

@@ -67,11 +67,8 @@ export default function (pi: Pi.ExtensionAPI) {
   const getActiveTelegramThreadProfile = function (): string | undefined {
     return configStore.getActiveProfileName();
   };
-  const busProcessRuntime = Bus.createTelegramBusProcessRuntime({
+  const busProcessRuntime = Bus.createCurrentTelegramBusProcessRuntime({
     getActiveProfileName: getActiveTelegramThreadProfile,
-    pid: process.pid,
-    parentPid: process.ppid,
-    createdAtMs: Date.now(),
   });
   const {
     instanceId: telegramInstanceId,
@@ -119,14 +116,8 @@ export default function (pi: Pi.ExtensionAPI) {
   const runtimeEvents = runtimeDiagnostics.events;
   const recordRuntimeEvent = runtimeDiagnostics.recordRuntimeEvent;
   const configStore = Config.createTelegramConfigStore({ recordRuntimeEvent });
-  const isTelegramBusConfigured = function (): boolean {
-    return true;
-  };
   const isTelegramBusRuntimeEnabled = function (): boolean {
-    return (
-      isTelegramBusConfigured() &&
-      !telegramThreadCapabilityState.isTopicModeUnavailable()
-    );
+    return !telegramThreadCapabilityState.isTopicModeUnavailable();
   };
   Config.bindGlobalTelegramConfigRuntime(configStore);
   const configControls = Config.createTelegramConfigControls(configStore);
@@ -397,6 +388,7 @@ export default function (pi: Pi.ExtensionAPI) {
     sendRichMessageDraft,
     downloadFile: downloadTelegramBridgeFile,
     editMessageText: editTelegramMessageText,
+    editMessageReplyMarkup: editTelegramMessageReplyMarkup,
     answerCallbackQuery,
     answerGuestQuery,
     deleteMessage: deleteTelegramMessage,
@@ -741,13 +733,7 @@ export default function (pi: Pi.ExtensionAPI) {
     stopTypingLoop: typing.stop,
     answerCallbackQuery,
     editInteractiveMessage,
-    async editMessageReplyMarkup(chatId, messageId, replyMarkup) {
-      await callTelegramApi("editMessageReplyMarkup", {
-        chat_id: chatId,
-        message_id: messageId,
-        reply_markup: replyMarkup,
-      });
-    },
+    editMessageReplyMarkup: editTelegramMessageReplyMarkup,
     sendInteractiveMessage,
     deleteMessage: deleteTelegramMessage,
     answerGuestQuery,
@@ -932,7 +918,6 @@ export default function (pi: Pi.ExtensionAPI) {
       getAllowedUserId: configStore.getAllowedUserId,
       callApi: callTelegramApi,
       topicTargetStore: threadStore,
-      isBusConfigured: isTelegramBusConfigured,
       isBusRuntimeEnabled: isTelegramBusRuntimeEnabled,
       ownsLock: lockRuntime.owns,
       startClassicPolling: pollingRuntime.start,

package/lib/bus-api.ts

@@ -265,6 +265,24 @@ export function createTelegramBusAwareApiRuntime(
       await deps.callFollowerApi("call", ["editMessageText", body]);
       return "edited";
     },
+    async editMessageReplyMarkup(
+      chatId: number,
+      messageId: number,
+      replyMarkup: unknown,
+    ): Promise<void> {
+      if (deps.ownsDirect()) {
+        await deps.directRuntime.editMessageReplyMarkup(
+          chatId,
+          messageId,
+          replyMarkup,
+        );
+        return;
+      }
+      await deps.callFollowerApi("call", [
+        "editMessageReplyMarkup",
+        { chat_id: chatId, message_id: messageId, reply_markup: replyMarkup },
+      ]);
+    },
     async answerCallbackQuery(
       callbackQueryId: string,
       text?: string,

package/lib/bus.ts

@@ -72,6 +72,20 @@ export function getTelegramProcessBirthIdentity(
   return `${pid}:generation:${fallbackGeneration}`;
 }
 
+export function createCurrentTelegramBusProcessRuntime(input: {
+  getActiveProfileName: () => string | undefined;
+  pid?: number;
+  parentPid?: number;
+  createdAtMs?: number;
+}): TelegramBusProcessRuntime {
+  return createTelegramBusProcessRuntime({
+    getActiveProfileName: input.getActiveProfileName,
+    pid: input.pid ?? process.pid,
+    parentPid: input.parentPid ?? process.ppid,
+    createdAtMs: input.createdAtMs ?? Date.now(),
+  });
+}
+
 export function createTelegramBusProcessRuntime(input: {
   getActiveProfileName: () => string | undefined;
   pid: number;

package/lib/outbound-buttons.ts

@@ -11,7 +11,7 @@ import type {
   TelegramInlineKeyboardMarkup,
 } from "./keyboard.ts";
 import {
-  parseTelegramCommentAttributes,
+  parseTelegramActionPayload,
   parseTopLevelTelegramComment,
   replaceTopLevelHtmlComments,
 } from "./outbound-markup.ts";
@@ -87,16 +87,27 @@ function normalizeMarkdownAfterButtonExtraction(markdown: string): string {
   return markdown.replace(/\n{3,}/g, "\n\n").trim();
 }
 
-function parseButtonsCommentAttributes(input: string): {
-  label?: string;
-  prompt?: string;
-  selectedStyle?: TelegramInlineKeyboardButtonStyle;
-} {
-  const attributes = parseTelegramCommentAttributes(input);
-  const selectedStyle = attributes.selected_style;
+function getTelegramButtonString(
+  payload: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = payload[key];
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+function parseTelegramButtonAction(
+  payload: Record<string, unknown>,
+): TelegramOutboundButtonAction | undefined {
+  const value = getTelegramButtonString(payload, "value");
+  const label = getTelegramButtonString(payload, "label") ?? value;
+  const prompt = getTelegramButtonString(payload, "prompt") ?? value;
+  if (!label || !prompt) return undefined;
+  const selectedStyle = payload.selected_style;
   return {
-    ...(attributes.label ? { label: attributes.label } : {}),
-    ...(attributes.prompt ? { prompt: attributes.prompt } : {}),
+    text: label,
+    prompt,
     ...(selectedStyle === "success" ||
     selectedStyle === "danger" ||
     selectedStyle === "primary"
@@ -105,49 +116,6 @@ function parseButtonsCommentAttributes(input: string): {
   };
 }
 
-function parseButtonsCommentRows(
-  head: string,
-  body: string | undefined,
-): TelegramOutboundButtonAction[][] {
-  const trimmedHead = head.trim();
-
-  if (body === undefined) {
-    if (trimmedHead.startsWith(":")) {
-      const label = trimmedHead.slice(1).trim();
-      return label ? [[{ text: label, prompt: label }]] : [];
-    }
-    const attributes = parseButtonsCommentAttributes(head);
-    return attributes.label && attributes.prompt
-      ? [
-          [
-            {
-              text: attributes.label,
-              prompt: attributes.prompt,
-              ...(attributes.selectedStyle
-                ? { selectedStyle: attributes.selectedStyle }
-                : {}),
-            },
-          ],
-        ]
-      : [];
-  }
-
-  const attributes = parseButtonsCommentAttributes(head);
-  const prompt = body.trim();
-  if (!attributes.label || !prompt) return [];
-  return [
-    [
-      {
-        text: attributes.label,
-        prompt,
-        ...(attributes.selectedStyle
-          ? { selectedStyle: attributes.selectedStyle }
-          : {}),
-      },
-    ],
-  ];
-}
-
 export function createTelegramButtonActionStore(
   options: { ttlMs?: number } = {},
 ): TelegramButtonActionStore {
@@ -197,14 +165,15 @@ export function planTelegramButtonReply(
   const stripped = replaceTopLevelHtmlComments(markdown, (comment) => {
     const command = parseTopLevelTelegramComment(comment, "telegram_button");
     if (!command) return comment.raw;
-    const rows = parseButtonsCommentRows(command.head, command.body);
-    for (const row of rows) {
-      keyboard.push(
-        row.map((button) => ({
-          text: button.text,
-          callback_data: deps.registerAction(button),
-        })),
-      );
+    const payload = parseTelegramActionPayload(comment, "telegram_button");
+    const action = payload ? parseTelegramButtonAction(payload) : undefined;
+    if (action) {
+      keyboard.push([
+        {
+          text: action.text,
+          callback_data: deps.registerAction(action),
+        },
+      ]);
     }
     return "";
   });

package/lib/outbound-markup.ts

@@ -16,16 +16,6 @@ interface TelegramTopLevelFenceState {
   length: number;
 }
 
-function isTelegramActionCommentContent(content: string): boolean {
-  const normalizedContent = content.replace(/^\s+/, "");
-  const [head = ""] = normalizedContent.split(/\r?\n/, 1);
-  return ["telegram_voice", "telegram_button"].some((command) => {
-    if (!head.startsWith(command)) return false;
-    const nextChar = head[command.length];
-    return nextChar === undefined || /\s|:/.test(nextChar);
-  });
-}
-
 function getMarkdownLineEnd(markdown: string, offset: number): number {
   const newlineIndex = markdown.indexOf("\n", offset);
   return newlineIndex === -1 ? markdown.length : newlineIndex + 1;
@@ -64,58 +54,6 @@ function isTopLevelClosingFence(
   );
 }
 
-function collectPairedTelegramVoiceActionBody(
-  markdown: string,
-  bodyStart: number,
-  commentContent: string,
-): { content: string; end: number } | undefined {
-  const normalizedContent = commentContent.trim();
-  if (
-    !normalizedContent.startsWith("telegram_voice") ||
-    !isTelegramActionCommentContent(commentContent)
-  ) {
-    return undefined;
-  }
-  let offset = bodyStart;
-  while (offset < markdown.length) {
-    const lineEnd = getMarkdownLineEnd(markdown, offset);
-    const line = getMarkdownLineText(markdown, offset, lineEnd);
-    if (line === "<!-- /telegram_voice -->") {
-      const body = markdown.slice(bodyStart, offset).trim();
-      if (!body) return undefined;
-      return {
-        content: `${commentContent.trimEnd()}\n${body}`,
-        end: lineEnd,
-      };
-    }
-    if (line.startsWith("<!--")) return undefined;
-    offset = lineEnd;
-  }
-  return undefined;
-}
-
-function collectInlineClosedTelegramActionBody(
-  markdown: string,
-  bodyStart: number,
-  commentContent: string,
-): { content: string; end: number } | undefined {
-  const bodyLineEnd = getMarkdownLineEnd(markdown, bodyStart);
-  const bodyLine = getMarkdownLineText(markdown, bodyStart, bodyLineEnd);
-  const closeLineEnd = getMarkdownLineEnd(markdown, bodyLineEnd);
-  const closeLine = getMarkdownLineText(markdown, bodyLineEnd, closeLineEnd);
-  const hasRecoverableBody =
-    isTelegramActionCommentContent(commentContent) &&
-    bodyLine.trim() !== "" &&
-    !bodyLine.startsWith("<!--") &&
-    !bodyLine.startsWith("-->") &&
-    closeLine === "-->";
-  if (!hasRecoverableBody) return undefined;
-  return {
-    content: `${commentContent.trimEnd()}\n${bodyLine}`,
-    end: bodyLineEnd + 3,
-  };
-}
-
 export function collectTopLevelHtmlComments(markdown: string): {
   comments: TelegramTopLevelHtmlComment[];
   openCommentStart?: number;
@@ -140,27 +78,9 @@ export function collectTopLevelHtmlComments(markdown: string): {
     if (line.startsWith("<!--")) {
       const closeIndex = markdown.indexOf("-->", offset + 4);
       if (closeIndex === -1) return { comments, openCommentStart: offset };
-      let end = closeIndex + 3;
-      let raw = markdown.slice(offset, end);
-      let content = raw.slice(4, -3);
-      const closeColumn = closeIndex - offset;
-      const closesOnOpeningLine = closeIndex < lineEnd;
-      const hasOnlyWhitespaceAfterClose =
-        line.slice(closeColumn + 3).trim() === "";
-      const pairedVoiceBody =
-        closesOnOpeningLine && hasOnlyWhitespaceAfterClose
-          ? collectPairedTelegramVoiceActionBody(markdown, lineEnd, content)
-          : undefined;
-      const inlineBody =
-        !pairedVoiceBody && closesOnOpeningLine && hasOnlyWhitespaceAfterClose
-          ? collectInlineClosedTelegramActionBody(markdown, lineEnd, content)
-          : undefined;
-      const recoveredBody = pairedVoiceBody ?? inlineBody;
-      if (recoveredBody) {
-        end = recoveredBody.end;
-        raw = markdown.slice(offset, end);
-        content = recoveredBody.content;
-      }
+      const end = closeIndex + 3;
+      const raw = markdown.slice(offset, end);
+      const content = raw.slice(4, -3);
       comments.push({ raw, content, start: offset, end });
       offset = getMarkdownLineEnd(markdown, end);
       continue;
@@ -233,18 +153,47 @@ export function parseTopLevelTelegramComment(
   };
 }
 
-export function parseTelegramCommentAttributes(
-  input: string,
-): Record<string, string> {
+function parseCanonicalTelegramActionAttributes(
+  source: string,
+): Record<string, string> | undefined {
   const attributes: Record<string, string> = {};
-  for (const match of input.matchAll(
-    /([A-Za-z_][A-Za-z0-9_-]*)=(?:"([^"]*)"|'([^']*)'|(\S+))/g,
-  )) {
-    const key = match[1];
-    const value = (match[2] ?? match[3] ?? match[4] ?? "").trim();
-    if (value) attributes[key] = value;
+  const pattern = /\s*([A-Za-z_][A-Za-z0-9_-]*)="([^"]*)"/y;
+  let offset = 0;
+  while (offset < source.length) {
+    pattern.lastIndex = offset;
+    const match = pattern.exec(source);
+    if (!match) return undefined;
+    const value = match[2].trim();
+    if (value) attributes[match[1]] = value;
+    offset = pattern.lastIndex;
+  }
+  return Object.keys(attributes).length > 0 ? attributes : undefined;
+}
+
+export function parseTelegramActionPayload(
+  comment: TelegramTopLevelHtmlComment,
+  command: string,
+): Record<string, unknown> | undefined {
+  const parsed = parseTopLevelTelegramComment(comment, command);
+  if (!parsed) return undefined;
+  const source = [parsed.head, parsed.body]
+    .filter((part): part is string => part !== undefined)
+    .join("\n")
+    .trim()
+    .replace(/^:\s*/, "");
+  if (!source) return undefined;
+  if (source.startsWith("{")) {
+    try {
+      const value: unknown = JSON.parse(source);
+      return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? (value as Record<string, unknown>)
+        : undefined;
+    } catch {
+      return undefined;
+    }
   }
-  return attributes;
+  if (parsed.body !== undefined) return undefined;
+  return parseCanonicalTelegramActionAttributes(source);
 }
 
 export function normalizeMarkdownAfterVoiceExtraction(
@@ -295,58 +244,14 @@ export interface TelegramVoiceReplyPlan {
   rate?: string;
 }
 
-function parseVoiceReplyAttributes(input: string): {
-  lang?: string;
-  rate?: string;
-  text?: string;
-} {
-  const attributes = parseTelegramCommentAttributes(input);
-  return {
-    ...(attributes.lang ? { lang: attributes.lang } : {}),
-    ...(attributes.rate ? { rate: attributes.rate } : {}),
-    ...(attributes.text ? { text: attributes.text } : {}),
-  };
-}
-
-function parseVoiceCommentBody(
-  head: string,
-  body: string | undefined,
-): {
-  attrs: string;
-  text: string;
-} {
-  const trimmedHead = head.trim();
-  if (body !== undefined) {
-    return { attrs: trimmedHead.replace(/^:/, "").trim(), text: body.trim() };
-  }
-  let colonIndex = -1;
-  let inQuote = false;
-  let quoteChar = "";
-  for (let i = 0; i < trimmedHead.length; i++) {
-    const char = trimmedHead[i];
-    if (inQuote) {
-      if (char === quoteChar) inQuote = false;
-    } else {
-      if (char === '"' || char === "'") {
-        inQuote = true;
-        quoteChar = char;
-      } else if (char === ":") {
-        colonIndex = i;
-        break;
-      }
-    }
-  }
-  if (colonIndex > 0) {
-    const attrsPart = trimmedHead.slice(0, colonIndex).trim();
-    const textPart = trimmedHead.slice(colonIndex + 1).trim();
-    const attrs = parseVoiceReplyAttributes(attrsPart);
-    return { attrs: attrsPart, text: textPart || attrs.text || "", ...attrs };
-  }
-  if (trimmedHead.startsWith(":")) {
-    return { attrs: "", text: trimmedHead.slice(1).trim() };
-  }
-  const attrs = parseVoiceReplyAttributes(trimmedHead);
-  return { attrs: trimmedHead, text: attrs.text ?? "" };
+function getTelegramActionString(
+  payload: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = payload[key];
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
 }
 
 export function planTelegramVoiceReply(
@@ -356,26 +261,24 @@ export function planTelegramVoiceReply(
   let lang: string | undefined;
   let rate: string | undefined;
   const stripped = replaceTopLevelHtmlComments(markdown, (comment) => {
-    let command = parseTopLevelTelegramComment(comment, "telegram_voice");
-    if (!command) {
-      let content = comment.content.replace(/^\s+/, "").replace(/^!/, "");
-      if (content.startsWith("telegram_voice")) {
-        const headPart = content.slice("telegram_voice".length).trim();
-        command = { head: headPart, body: undefined };
-      }
-    }
-    if (!command) return "";
-    const parsed = parseVoiceCommentBody(command.head, command.body);
-    const attrs = parseVoiceReplyAttributes(parsed.attrs);
-    if (parsed.text) {
+    const command = parseTopLevelTelegramComment(comment, "telegram_voice");
+    if (!command) return comment.raw;
+    const payload = parseTelegramActionPayload(comment, "telegram_voice");
+    if (!payload) return "";
+    const text =
+      getTelegramActionString(payload, "text") ??
+      getTelegramActionString(payload, "value");
+    const itemLang = getTelegramActionString(payload, "lang");
+    const itemRate = getTelegramActionString(payload, "rate");
+    if (text) {
       voiceReplies.push({
-        text: parsed.text,
-        ...(attrs.lang ? { lang: attrs.lang } : {}),
-        ...(attrs.rate ? { rate: attrs.rate } : {}),
+        text,
+        ...(itemLang ? { lang: itemLang } : {}),
+        ...(itemRate ? { rate: itemRate } : {}),
       });
     }
-    if (attrs.lang) lang = attrs.lang;
-    if (attrs.rate) rate = attrs.rate;
+    if (itemLang) lang = itemLang;
+    if (itemRate) rate = itemRate;
     return "";
   });
   const voiceText = voiceReplies

package/lib/polling.ts

@@ -319,7 +319,6 @@ export interface TelegramThreadCapabilityRuntimeDeps<
   TContext,
 > extends TelegramThreadCapabilityReaderDeps {
   topicTargetStore: TelegramThreadCapabilityStore;
-  isBusConfigured: () => boolean;
   ownsLock: (ctx: TContext) => boolean;
   getPollingStartedWithTelegramBus: () => boolean;
   setPollingStartedWithTelegramBus: (started: boolean) => void;
@@ -394,7 +393,6 @@ export interface TelegramThreadAwarePollingDeps<
   TContext,
   TOwner,
 > extends TelegramStartupThreadCapabilityProbeDeps {
-  isBusConfigured: () => boolean;
   isBusRuntimeEnabled: () => boolean;
   isTopicModeUnavailableError: (error: unknown) => boolean;
   getPollingStartedWithTelegramBus: () => boolean;
@@ -419,7 +417,6 @@ export interface TelegramThreadCapabilityOrchestrationDeps<
 > extends TelegramThreadCapabilityReaderDeps {
   state: TelegramThreadCapabilityStateRuntime;
   topicTargetStore: TelegramThreadCapabilityStore;
-  isBusConfigured: () => boolean;
   isBusRuntimeEnabled: () => boolean;
   ownsLock: (ctx: TContext) => boolean;
   startClassicPolling: (ctx: TContext) => MaybePromise<void>;
@@ -475,7 +472,6 @@ export function createTelegramThreadCapabilityOrchestration<TContext, TOwner>(
     getAllowedUserId: deps.getAllowedUserId,
     callApi: deps.callApi,
     topicTargetStore: deps.topicTargetStore,
-    isBusConfigured: deps.isBusConfigured,
     ownsLock: deps.ownsLock,
     getPollingStartedWithTelegramBus: deps.state.isBusPollingStarted,
     setPollingStartedWithTelegramBus: deps.state.setBusPollingStarted,
@@ -498,7 +494,6 @@ export function createTelegramThreadCapabilityOrchestration<TContext, TOwner>(
       getAllowedUserId: deps.getAllowedUserId,
       callApi: deps.callApi,
       topicTargetStore: deps.topicTargetStore,
-      isBusConfigured: deps.isBusConfigured,
       isBusRuntimeEnabled: deps.isBusRuntimeEnabled,
       isTopicModeUnavailableError: deps.isTopicModeUnavailableError,
       getPollingStartedWithTelegramBus: deps.state.isBusPollingStarted,
@@ -590,7 +585,6 @@ export async function applyTelegramThreadCapability<TContext>(
   deps: TelegramThreadCapabilityRuntimeDeps<TContext>,
 ): Promise<void> {
   await deps.topicTargetStore.load();
-  if (!deps.isBusConfigured()) return;
   const nowMs = (deps.getNowMs ?? Date.now)();
   const previousBotState = deps.topicTargetStore.getBotState();
   if (!threadModeEnabled) {
@@ -691,17 +685,14 @@ export function createTelegramThreadAwarePollingPorts<TContext, TOwner>(
     ctx: TContext,
     options?: { forceFreshLeaderThread?: boolean },
   ): Promise<void> => {
-    if (deps.isBusConfigured()) {
-      await deps.topicTargetStore.load();
-      let startupThreadCapability: boolean | undefined;
-      try {
-        startupThreadCapability =
-          await probeTelegramStartupThreadCapability(deps);
-      } catch (error) {
-        deps.recordEvent("bus", error, { phase: "startup-thread-mode-probe" });
-      }
-      deps.setTopicModeUnavailable(startupThreadCapability !== true);
+    await deps.topicTargetStore.load();
+    let startupThreadCapability: boolean | undefined;
+    try {
+      startupThreadCapability = await probeTelegramStartupThreadCapability(deps);
+    } catch (error) {
+      deps.recordEvent("bus", error, { phase: "startup-thread-mode-probe" });
     }
+    deps.setTopicModeUnavailable(startupThreadCapability !== true);
     if (deps.isBusRuntimeEnabled()) {
       deps.setTopicModeUnavailable(false);
       try {
@@ -886,7 +877,6 @@ export function createTelegramThreadCapabilityMonitor<TContext>(
   return {
     start(ctx) {
       stop();
-      if (!deps.isBusConfigured()) return;
       interval = setInterval(() => {
         check(ctx);
       }, intervalMs);

package/lib/prompts.ts

@@ -138,13 +138,13 @@ How to answer Telegram turns:
 Assistant-authored Telegram actions:
 - \`telegram_voice\` and \`telegram_button\` are hidden top-level HTML comments, not Pi tools.
 - Put action comments at column zero, outside code, quotes, lists, and indented examples.
-- Voice forms: \`<!-- telegram_voice text="Short summary" -->\`, \`<!-- telegram_voice: Short summary -->\`, multiline \`<!-- telegram_voice lang=ru\nShort summary.\n-->\`, or paired \`<!-- telegram_voice lang=ru -->\nShort summary.\n<!-- /telegram_voice -->\`.
-- Keep the complete action at top level and include a non-empty voice payload.
+- Action payloads use either JSON or double-quoted attributes; the colon after the action name is optional and does not affect parsing. Voice accepts equivalent \`text\` or \`value\`: \`<!-- telegram_voice: {"value":"Short summary","lang":"en"} -->\` or \`<!-- telegram_voice text="Short summary" lang="en" -->\`.
+- Keep the complete action in one top-level comment and include non-empty \`text\` or \`value\`; encode line breaks inside JSON strings as \`\\n\`.
 - Keep voice text TTS-friendly; avoid raw Markdown, code, and tables in voice text.
 - Voice delivery generates and attaches OGG automatically; do not also call \`telegram_attach\` for the same audio.
 - Voice reply modes are compact: \`hidden\` emits no automatic context, \`mirror\` emits it for voice/audio input, and \`always\` emits it for every Telegram turn. Explicit \`telegram_voice\` remains available for an intentionally distinct spoken payload.
-- Button forms: \`<!-- telegram_button: OK -->\`, \`<!-- telegram_button label=Continue prompt="Continue with the current plan." -->\`, or multiline \`<!-- telegram_button label="Show risks" selected_style="danger"\nList the main risks first.\n-->\`.
-- Optional \`selected_style\` controls the button after queue admission: \`primary\` (default, blue), \`success\` (green), or \`danger\` (red). It never suppresses the prompt.
+- Button payloads use \`label\` plus \`prompt\`, or compact \`value\` when both are identical: \`<!-- telegram_button: {"label":"Continue","prompt":"Continue with the current plan."} -->\` or \`<!-- telegram_button value="Continue" -->\`.
+- Optional \`selected_style\` in either payload form controls the button after queue admission: \`primary\` (default, blue), \`success\` (green), or \`danger\` (red). It never suppresses the prompt.
 - If hidden button comments form the whole reply, the bridge supplies the standard \`☑️ **Choose an option:**\` heading automatically.
 
 Local/TUI direct delivery:

package/lib/telegram-api.ts

@@ -497,6 +497,11 @@ export interface TelegramBridgeApiRuntime {
   editMessageText: (
     body: TelegramEditMessageTextBody,
   ) => Promise<"edited" | "unchanged">;
+  editMessageReplyMarkup: (
+    chatId: number,
+    messageId: number,
+    replyMarkup: unknown,
+  ) => Promise<void>;
   answerCallbackQuery: (
     callbackQueryId: string,
     text?: string,
@@ -1569,6 +1574,13 @@ export function createTelegramBridgeApiRuntime(
         throw error;
       }
     },
+    editMessageReplyMarkup: async (chatId, messageId, replyMarkup) => {
+      await callRecorded("editMessageReplyMarkup", {
+        chat_id: chatId,
+        message_id: messageId,
+        reply_markup: replyMarkup,
+      });
+    },
     answerCallbackQuery: async (callbackQueryId, text) => {
       try {
         await deps.client.answerCallbackQuery(callbackQueryId, text);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.24.10",
+  "version": "0.24.11",
   "private": false,
   "publishConfig": {
     "access": "public"