@llblab/pi-kit 0.37.0 → 0.37.1

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.37.1: Bundled Package Updates (2026-10-26)
+
+- `Exact pins`: `@llblab/pi-telegram` 0.58.1 → 0.58.3.
+- `Packaging`: Synchronizes the lockfile, bundle aliases and README inventory. Package membership and resource order remain unchanged; packed validation does not certify extension safety or installed-client behavior.
+
 ## 0.37.0: Bundled Package Updates (2026-10-25)
 
 - `Exact pins`: `@llblab/pi-telegram` 0.57.11 → 0.58.1.

package/README.md

@@ -18,7 +18,7 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.13.2` | OpenAI/legacy Codex subscription quota and Business credit status, with persistent priority Fast toggle mirrored in Telegram |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.9.0` | Visible continuation scheduling and bounded worker Skills through compiled, manifest-owned resources |
 | [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.26.5` | Scoped context/memory compiler with step-independent current memory, stable Passive/Active modes and visible blocked-state status |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.58.1` | Telegram companion with per-prompt Steer, queued controls, Reroute/Restore, recoverable connections, previews, follower Threads, files, and voice |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.58.3` | Telegram companion with per-prompt Steer, queued controls, Reroute/Restore, recoverable connections, previews, follower Threads, files, and voice |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.

package/node_modules/@llblab/pi-telegram/AGENTS.md

@@ -107,7 +107,7 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 - A model selection from an authorized Telegram target may stop and continue any interruptible active agent run in that same Pi session, including local/TUI work. Queue the synthetic control-lane continuation before aborting; when no Telegram prompt owns the run, bind continuation and reply ownership to the exact model-menu chat/Thread/message. Delay abort until every active tool execution settles, and clear both selection and fallback target on cancellation, agent start, settlement, or session replacement.
 - Telegram extension side effects must not hold Pi's core lifecycle hostage after semantic completion. Preserve ordering in extension-owned background work, record failures, and fence target/profile/transport/session authority.
 - In Threaded Mode, All is service/input-only. New output, previews, typing and routing UI require a concrete Thread; neither implicit fallback nor explicit aggregate delivery may write to All. Unavailable routing authority retains input without an All notice or silent settlement. Classic DM and explicit channel/business destinations remain separate; historical All output is not auto-cleaned.
-- Complete assistant/guest model answers use Telegram-native Rich Markdown. Harness-owned menus, status, diagnostics, thinking, and tool evidence remain explicit HTML/plain or their documented native surface. Before Telegram preview or final delivery, strip every assistant-authored HTML comment regardless of Markdown position while keeping action activation top-level-only; a comment-only result sends no text message. Preserve literal code outside comments and structurally safe chunking; never split invalid markup.
+- Complete assistant/guest model answers use Telegram-native Rich Markdown. Harness-owned menus, status, diagnostics, thinking, and tool evidence remain explicit HTML/plain or their documented native surface. Before Telegram preview or final delivery, strip every assistant-authored HTML comment regardless of Markdown position and recognize complete action comments by their delimiters and payload, independent of surrounding Markdown; a comment-only result sends no text message. Preserve literal code outside comments and structurally safe chunking; never split invalid markup.
 - `preview` owns streaming lifecycle only, not assistant rendering. Finalization waits for the captured generation's preceding preview work, never later drafts blocked by that publication, and must not issue pre/post-final draft-clear calls that create transient Telegram draft UI. Reset/invalidation detaches predecessor dependencies; late settlements cannot mutate replacement state. Turns that already answer as one atomic reply (voice replies, Guest Mode queries) never stream previews.
 - Native `sendChatAction(typing)` is the automatic activity signal for unsettled agent and compaction work while Telegram transport is authorized. Extension-owned blocking UI prompts pause it and completion resumes it while either work owner remains active. Compaction may stop only a typing loop it actually started; it must preserve a pre-existing agent-owned loop. Refresh only the assigned Thread on a conservative three-second cadence; do not mirror typing to aggregate `All` and multiply shared-chat flood pressure. One Thread's pending action must not suppress another Thread's activity. Typing is best-effort presence only, never a Thread-existence or message-delivery probe: a failed exact-target action remains a structured diagnostic and must not replace a healthy connected/leader/follower status with `error`. Do not invent extra in-chat work indicators or emit activity for startup/connect/reload/recovery alone.
 - Public activity handlers and connected companion delivery are asynchronous, target-bound, generation-fenced surfaces. Connected companion projection has no independent opt-out: disconnect or authority loss is its boundary. Token deltas, hidden reasoning, unknown sources, and stale authority never enter public projection.

package/node_modules/@llblab/pi-telegram/BACKLOG.md

@@ -2,21 +2,19 @@
 
 _This file owns unresolved project work only. Completed behavior belongs in `CHANGELOG.md`; durable contracts belong in `AGENTS.md` and `/docs`._
 
-## 0.58.1 publication checkpoint
-
-- [ ] Publish the independent Thread chat-action fix through the protected dev-to-main path, requiring fresh Ubuntu, Windows and both macOS shard checks at the exact candidate head and candidate/merged-tree equality. Keep the immutable Connect-only minor unchanged and verify its publication before issuing the hotfix tag.
-- [ ] Verify the hotfix GitHub Release and public npm latest, exact tag/gitHead identity, canonical notes, packed runtime/skills and provenance before closing this checkpoint. No live session reload or Telegram probes; controlled transport tests do not prove live client presence.
-
 ## Disposable Thread live acceptance
 
 - [ ] After separate operator authorization, use disposable Telegram tabs to check leader Settings review/Back, one confirmed cleanup of an inactive slotless binding, preservation of its replacement letter holder, and visible outcome/recovery copy. Native filesystem and injected-transport tests do not prove live Telegram/client or native Windows acceptance. Never use production history as the disposable fixture.
 - [ ] On separately authorized disposable routing tabs, verify pending-choice protection, Cancel after the view becomes unavailable, expiry notice in the owned leader Thread and no duplicate deletion after an unknown outcome. Local native journal/API-decoder fixtures are not live client acceptance.
 
-## Prompt-cache live confirmation
+## Typing authority during Telegram turns
+
+Live report on package 0.58.2 and Pi 1.4.0: every Telegram turn logged `sendChatAction: Telegram API call authority is unavailable` in a connected, long-lived session. The reporter's leader/follower role and refusal stage are not yet known. Prompt-cache acceptance is complete; this is a separate typing-indicator investigation.
 
-The prompt-cache report remains open for the reporter's offered live Anthropic capture after the published fix. Native request/transcript checks do not replace cache-hit or signed-thinking measurements.
+The native expired-loop diagnostic case is corrected: real typing loop/starter, direct API runtime and API client regressions cover mocked HTTP 200 after stop/same-target replacement, with unchanged session generation and transport epoch. A process-local ended-loop observation suppresses only the corresponding typed authority diagnostic; the request still rejects, active-owner refusals remain visible, and no callback crosses IPC. Real-client regressions retain the original HTTP/network failure when authority expires during error handling; a native follower caller rejects a delayed ACK after its local owner ends, without replay. Direct/follower and Classic/Threaded paths remain distinct from live acceptance. This does not establish the cause of the reporter's live failure or prove client typing.
 
-- [ ] Review the reporter's resume and mid-session tool-change results (versions, cache read/write counts and new thinking-drop events). Close the report if the live evidence confirms the fix, or narrow any residual failure into actionable follow-up. Do not reconstruct or claim recovery of previously lost thinking blocks.
+- [ ] Correlate the live report with the corrected native case using only redacted leader/follower role, timing around loop end/replacement and refusal-stage evidence if available. Do not infer transport loss or widen authority from the error string alone; isolate any distinct current-owner refusal before another runtime change.
+- [ ] After separately approved live validation, confirm client typing and absence of expired-loop API noise across Telegram turns and loop replacement. Preserve exact Thread targeting, independent Thread requests, best-effort presence and no unhealthy-status escalation; local native fixtures are not live acceptance.
 
 ## Stuck forwarded command after Thread re-creation
 
@@ -40,8 +38,8 @@ A target-scoped reply refusal cannot prove that a command made no prior effects.
 
 ## Passive-child cold-import follow-up
 
-The 0.57.8 tag validation failed `Child process sharing the agent dir does not poll while parent owns Telegram lock` even when that file ran alone: `Child process did not exit. stdout= stderr=` at its existing child deadline. The other seven process tests and the identical pre-merge tree passed. That historical failure has no child-stage trace, so cold import, startup and a retained runtime handle remain competing explanations. Bounded diagnostic sampling is exhausted; passing traces showed imports up to 4.37 seconds against the five-second non-Windows child budget and natural exit within 8–14 ms after the event-loop checkpoint. These traces do not identify the original cause. A later main-validation recurrence stopped after `eval` and `import-start`, with parent-clock `elapsedMs=5009` and no import-complete checkpoint. That trace locates this recurrence before import completion, not in natural exit or a retained post-checkpoint handle; the slow dependency/startup cause remains unknown. The independent tag-owned Release validation passed the same committed tree, which does not erase the failed main check. The initial hotfix candidate then showed the same pre-import-completion state on Ubuntu at `elapsedMs=5026`; the recurrence is not macOS-only. Slow dependency/startup cost remains unexplained, separate from the fixture's corrected startup/exit observation contract.
-- [ ] Validate the corrected phase-owned passive-child fixture in fresh complete platform CI before publication: bounded total startup, a strict post-readiness exit guard, unchanged no-poll/natural-exit assertions and no forced shutdown or retry. Controlled delayed-start/retained-work regressions and local native passes are not platform proof. For any genuine recurrence, preserve deadline and stage evidence before correcting runtime imports or budgets. Do not spend unchanged-head diagnostic samples or claim runner contention or the historical cause is proven.
+The 0.57.8 tag validation failed `Child process sharing the agent dir does not poll while parent owns Telegram lock` even when that file ran alone: `Child process did not exit. stdout= stderr=` at its existing child deadline. The other seven process tests and the identical pre-merge tree passed. That historical failure has no child-stage trace, so cold import, startup and a retained runtime handle remain competing explanations. Bounded diagnostic sampling is exhausted; passing traces showed imports up to 4.37 seconds against the five-second non-Windows child budget and natural exit within 8–14 ms after the event-loop checkpoint. These traces do not identify the original cause. A later main-validation recurrence stopped after `eval` and `import-start`, with parent-clock `elapsedMs=5009` and no import-complete checkpoint. That trace locates this recurrence before import completion, not in natural exit or a retained post-checkpoint handle; the slow dependency/startup cause remains unknown. The minor release's independent tag-owned validation passed the same committed tree, which does not erase that historical failed main check. The initial hotfix candidate then showed the same pre-import-completion state on Ubuntu at `elapsedMs=5026`; the recurrence is not macOS-only. Slow dependency/startup cost remains unexplained, separate from the fixture's corrected startup/exit observation contract.
+- [ ] On a genuinely failing cold-import trace under the phase-owned fixture, isolate dependency/startup cost using its actual overall/exit deadline and stage evidence before changing runtime imports or budgets. Preserve natural-exit/no-poll assertions and job budgets. Do not spend unchanged-head diagnostic samples or infer runner contention or the historical cause from passing runs.
 
 ## Windows Workspace-gate fixture timeout
 

package/node_modules/@llblab/pi-telegram/CHANGELOG.md

@@ -4,6 +4,16 @@
 
 ## Unreleased
 
+## 0.58.3: Typing Cancellation Diagnostics
+
+- `Typing diagnostics`: Ended typing loops no longer log cancellation-only authority refusals as API failures. Real HTTP/network failures retain their provenance and diagnostics even if authority expires before settlement. Requests remain rejected and single-attempt; callbacks stay local. Native late-success/failure and follower-ACK regressions cover this case, not the cause of the live report.
+- `Prompt-cache acceptance`: Reporter-provided live Anthropic captures and connected-session measurements confirm the released fix across tool changes, resume, local/Telegram switches and reconnect, with no new thinking drops in the tested runs. The remaining live-confirmation gate is closed; connected wire capture and broader model/cache-expiry coverage remain outside this evidence. Already-lost thinking is not reconstructed.
+
+## 0.58.2: Flexible Assistant Action Markup
+
+- `HTML actions`: Complete button/voice comments activate by their delimiters and accepted payload regardless of whitespace or surrounding Markdown, including code fences. Adjacent same-line comments are independent; unfinished comments do not activate. Escape the opening delimiter as `<!--` for literal examples.
+- `In-body buttons`: Fenced `telegram_button` blocks tolerate horizontal indentation, whitespace before the exact name, and three or more backticks or tildes. Closures require the same marker and at least the opening length on a separate line. Enclosing fenced examples remain literal; incomplete blocks, malformed JSON/CML and invalid rows still register no callbacks.
+
 ## 0.58.1: Independent Thread Typing
 
 - `Typing`: A pending activity request in one Thread no longer silently suppresses another Thread's typing. Exact chat/Thread/action calls still coalesce with their own minimum interval, while real Telegram 429 cooldowns remain shared across the chat, including late failures after a faster peer completes. Authority checks, one-attempt typing and bounded gate storage remain intact.

package/node_modules/@llblab/pi-telegram/dist/lib/outbound-buttons.js

@@ -4,7 +4,7 @@
  * Owns assistant-authored telegram_button extraction, button action storage, callback handling, and prompt-turn construction
  */
 import { randomUUID } from "node:crypto";
-import { getTelegramActionString as getTelegramButtonString, parseTelegramActionPayloadRows, parseTelegramButtonPayloadRows, replaceTelegramButtonFences, replaceTopLevelHtmlComments, } from "./outbound-markup.js";
+import { getTelegramActionString as getTelegramButtonString, parseTelegramActionPayloadRows, parseTelegramButtonPayloadRows, replaceTelegramButtonFences, replaceTelegramHtmlComments, } from "./outbound-markup.js";
 import { truncateTelegramQueueSummary, } from "./queue.js";
 const TELEGRAM_BUTTON_CALLBACK_PREFIX = "tgbtn";
 const TELEGRAM_BUTTON_ACTION_TTL_MS = 24 * 60 * 60 * 1000;
@@ -117,7 +117,23 @@ export function planTelegramButtonReply(markdown, deps) {
                 }),
             }));
     };
-    const withRichButtons = replaceTelegramButtonFences(markdown, (payload, closed) => {
+    const footerKeyboard = [];
+    const stripped = replaceTelegramHtmlComments(markdown, (comment) => {
+        const command = "telegram_button";
+        const normalizedContent = comment.content
+            .replace(/^\s+/, "")
+            .replace(/^!/, "");
+        if (!normalizedContent.startsWith(command))
+            return comment.raw;
+        const payloadRows = parseTelegramActionPayloadRows(comment, command);
+        if (!payloadRows)
+            return "";
+        const rows = buildRows(payloadRows, false);
+        if (rows)
+            footerKeyboard.push(...rows);
+        return "";
+    });
+    const withRichButtons = replaceTelegramButtonFences(stripped, (payload, closed) => {
         if (!closed)
             return "";
         const payloadRows = parseTelegramButtonPayloadRows(payload);
@@ -133,22 +149,8 @@ export function planTelegramButtonReply(markdown, deps) {
         }
         return `\n${rows.map(renderTelegramRichButtonRow).join("\n\n")}\n`;
     });
-    const stripped = replaceTopLevelHtmlComments(withRichButtons, (comment) => {
-        const command = "telegram_button";
-        const normalizedContent = comment.content
-            .replace(/^\s+/, "")
-            .replace(/^!/, "");
-        if (!normalizedContent.startsWith(command))
-            return comment.raw;
-        const payloadRows = parseTelegramActionPayloadRows(comment, command);
-        if (!payloadRows)
-            return "";
-        const rows = buildRows(payloadRows, false);
-        if (rows)
-            keyboard.push(...rows);
-        return "";
-    });
-    const visibleMarkdown = normalizeMarkdownAfterButtonExtraction(stripped);
+    keyboard.push(...footerKeyboard);
+    const visibleMarkdown = normalizeMarkdownAfterButtonExtraction(withRichButtons);
     return {
         markdown: keyboard.length > 0 && !visibleMarkdown
             ? DEFAULT_TELEGRAM_BUTTON_REPLY_MARKDOWN

package/node_modules/@llblab/pi-telegram/dist/lib/outbound-markup.d.ts

@@ -1,22 +1,22 @@
 /**
  * Telegram outbound markup parsing helpers
  * Zones: telegram outbound, assistant markup
- * Owns top-level assistant action comment extraction, attribute parsing, and markup stripping shared by voice and outbound delivery
+ * Owns delimiter-based assistant action comment extraction, attribute parsing, and markup stripping shared by voice and outbound delivery
  */
-export interface TelegramTopLevelHtmlComment {
+export interface TelegramHtmlComment {
     raw: string;
     content: string;
     start: number;
     end: number;
 }
-export declare function collectTopLevelHtmlComments(markdown: string): {
-    comments: TelegramTopLevelHtmlComment[];
+export declare function collectTelegramHtmlComments(markdown: string): {
+    comments: TelegramHtmlComment[];
     openCommentStart?: number;
 };
 export declare function replaceTelegramButtonFences(markdown: string, replace: (payload: string, closed: boolean) => string): string;
-export declare function replaceTopLevelHtmlComments(markdown: string, replacer: (comment: TelegramTopLevelHtmlComment) => string): string;
+export declare function replaceTelegramHtmlComments(markdown: string, replacer: (comment: TelegramHtmlComment) => string): string;
 export declare function parseTelegramButtonPayloadRows(source: string): Record<string, unknown>[][] | undefined;
-export declare function parseTelegramActionPayloadRows(comment: TelegramTopLevelHtmlComment, command: string): Record<string, unknown>[][] | undefined;
+export declare function parseTelegramActionPayloadRows(comment: TelegramHtmlComment, command: string): Record<string, unknown>[][] | undefined;
 export declare function stripTelegramCommentMarkupForPreview(markdown: string): string;
 export declare function stripTelegramCommentMarkupForDelivery(markdown: string): string;
 export interface TelegramVoiceReplyItem {

package/node_modules/@llblab/pi-telegram/dist/lib/outbound-markup.js

@@ -1,7 +1,7 @@
 /**
  * Telegram outbound markup parsing helpers
  * Zones: telegram outbound, assistant markup
- * Owns top-level assistant action comment extraction, attribute parsing, and markup stripping shared by voice and outbound delivery
+ * Owns delimiter-based assistant action comment extraction, attribute parsing, and markup stripping shared by voice and outbound delivery
  */
 import { isWireRecord as isTelegramActionPayload } from "./wire.js";
 function getMarkdownLineEnd(markdown, offset) {
@@ -12,7 +12,7 @@ function getMarkdownLineText(markdown, offset, end) {
     return markdown.slice(offset, end).replace(/\r?\n$/, "");
 }
 function getTopLevelOpeningFence(line) {
-    const match = line.match(/^(?: {0,3})(`{3,}|~{3,})/);
+    const match = line.match(/^[ \t]*(`{3,}|~{3,})/);
     const sequence = match?.[1];
     if (!sequence)
         return undefined;
@@ -22,43 +22,26 @@ function getTopLevelOpeningFence(line) {
     };
 }
 function isTopLevelClosingFence(line, fence) {
-    const match = line.match(/^(?: {0,3})(`{3,}|~{3,})([ \t]*)$/);
+    const match = line.match(/^[ \t]*(`{3,}|~{3,})[ \t]*$/);
     const sequence = match?.[1];
     return (!!sequence &&
         sequence[0] === fence.marker &&
         sequence.length >= fence.length);
 }
-export function collectTopLevelHtmlComments(markdown) {
+export function collectTelegramHtmlComments(markdown) {
     const comments = [];
     let offset = 0;
-    let fence;
     while (offset < markdown.length) {
-        const lineEnd = getMarkdownLineEnd(markdown, offset);
-        const line = getMarkdownLineText(markdown, offset, lineEnd);
-        if (fence) {
-            if (isTopLevelClosingFence(line, fence))
-                fence = undefined;
-            offset = lineEnd;
-            continue;
-        }
-        const nextFence = getTopLevelOpeningFence(line);
-        if (nextFence) {
-            fence = nextFence;
-            offset = lineEnd;
-            continue;
-        }
-        if (line.startsWith("<!--")) {
-            const closeIndex = markdown.indexOf("-->", offset + 4);
-            if (closeIndex === -1)
-                return { comments, openCommentStart: offset };
-            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;
-        }
-        offset = lineEnd;
+        const start = markdown.indexOf("<!--", offset);
+        if (start === -1)
+            break;
+        const closeIndex = markdown.indexOf("-->", start + 4);
+        if (closeIndex === -1)
+            return { comments, openCommentStart: start };
+        const end = closeIndex + 3;
+        const raw = markdown.slice(start, end);
+        comments.push({ raw, content: raw.slice(4, -3), start, end });
+        offset = end;
     }
     return { comments };
 }
@@ -92,7 +75,7 @@ export function replaceTelegramButtonFences(markdown, replace) {
         }
         else {
             fence = getTopLevelOpeningFence(line);
-            if (fence && /^```telegram_button[ \t]*$/.test(line)) {
+            if (fence && /^[ \t]*(?:`{3,}|~{3,})[ \t]*telegram_button[ \t]*$/.test(line)) {
                 actionStart = offset;
                 contentStart = end;
             }
@@ -105,8 +88,8 @@ export function replaceTelegramButtonFences(markdown, replace) {
     }
     return result + markdown.slice(copied);
 }
-export function replaceTopLevelHtmlComments(markdown, replacer) {
-    const { comments } = collectTopLevelHtmlComments(markdown);
+export function replaceTelegramHtmlComments(markdown, replacer) {
+    const { comments } = collectTelegramHtmlComments(markdown);
     if (comments.length === 0)
         return markdown;
     let result = "";
@@ -118,34 +101,9 @@ export function replaceTopLevelHtmlComments(markdown, replacer) {
     }
     return result + markdown.slice(offset);
 }
-function findTopLevelOpenOrPartialHtmlCommentIndex(markdown) {
-    const { openCommentStart } = collectTopLevelHtmlComments(markdown);
-    if (openCommentStart !== undefined)
-        return openCommentStart;
-    let offset = 0;
-    let fence;
-    while (offset < markdown.length) {
-        const lineEnd = getMarkdownLineEnd(markdown, offset);
-        const line = getMarkdownLineText(markdown, offset, lineEnd);
-        const isLastLine = lineEnd >= markdown.length;
-        if (fence) {
-            if (isTopLevelClosingFence(line, fence))
-                fence = undefined;
-            offset = lineEnd;
-            continue;
-        }
-        const nextFence = getTopLevelOpeningFence(line);
-        if (nextFence) {
-            fence = nextFence;
-            offset = lineEnd;
-            continue;
-        }
-        if (isLastLine && (line === "<" || line === "<!" || line === "<!-")) {
-            return offset;
-        }
-        offset = lineEnd;
-    }
-    return -1;
+function findOpenOrPartialHtmlCommentIndex(markdown) {
+    const start = markdown.indexOf("<!--");
+    return start >= 0 ? start : (markdown.match(/<(?:!-?)?$/u)?.index ?? -1);
 }
 function parseTolerantTelegramAttributes(source, names) {
     const attributes = {};
@@ -592,7 +550,7 @@ function stripTelegramHtmlCommentBlocks(markdown) {
 }
 export function stripTelegramCommentMarkupForPreview(markdown) {
     const withoutClosedBlocks = stripTelegramHtmlCommentBlocks(replaceTelegramButtonFences(markdown, () => ""));
-    const openBlockIndex = findTopLevelOpenOrPartialHtmlCommentIndex(withoutClosedBlocks);
+    const openBlockIndex = findOpenOrPartialHtmlCommentIndex(withoutClosedBlocks);
     const previewMarkdown = openBlockIndex >= 0
         ? withoutClosedBlocks.slice(0, openBlockIndex)
         : withoutClosedBlocks;
@@ -600,7 +558,7 @@ export function stripTelegramCommentMarkupForPreview(markdown) {
 }
 export function stripTelegramCommentMarkupForDelivery(markdown) {
     const withoutClosedBlocks = stripTelegramHtmlCommentBlocks(markdown);
-    const openBlockIndex = findTopLevelOpenOrPartialHtmlCommentIndex(withoutClosedBlocks);
+    const openBlockIndex = findOpenOrPartialHtmlCommentIndex(withoutClosedBlocks);
     const deliveryMarkdown = openBlockIndex >= 0
         ? withoutClosedBlocks.slice(0, openBlockIndex)
         : withoutClosedBlocks;
@@ -617,7 +575,7 @@ export function planTelegramVoiceReply(markdown) {
     const voiceReplies = [];
     let lang;
     let rate;
-    const stripped = replaceTopLevelHtmlComments(markdown, (comment) => {
+    const stripped = replaceTelegramHtmlComments(markdown, (comment) => {
         const command = "telegram_voice";
         const normalizedContent = comment.content
             .replace(/^\s+/, "")

package/node_modules/@llblab/pi-telegram/dist/lib/outbound.js

@@ -412,10 +412,10 @@ export function createTelegramOutboundReplyPlanner(store, getRenderingMode = ()
             rendering: getRenderingMode(),
             ...(options?.binding ? { binding: options.binding } : {}),
         });
-        // Button replies can also contain <!-- telegram_voice --> markup
-        const voiceReply = planTelegramVoiceReply(buttonReply.markdown);
+        // Extract voice from the original text before button-fence rendering consumes it.
+        const voiceReply = planTelegramVoiceReply(markdown);
         return {
-            markdown: voiceReply.markdown,
+            markdown: stripTelegramCommentMarkupForDelivery(buttonReply.markdown),
             ...(buttonReply.replyMarkup
                 ? { replyMarkup: buttonReply.replyMarkup }
                 : {}),

package/node_modules/@llblab/pi-telegram/dist/lib/prompts.d.ts

@@ -9,7 +9,7 @@ export declare const TELEGRAM_DISCONNECTED_CONTEXT_MESSAGE = "Telegram session d
 export declare const TELEGRAM_ATTACH_PROMPT_SNIPPET = "Queue files for the active Telegram reply; outside Telegram turns, send files directly to Telegram.";
 export declare const TELEGRAM_ATTACH_PROMPT_GUIDELINES: readonly ["When handling a [telegram] message and the user asked for a file or generated artifact, call telegram_attach with the local path instead of only mentioning the path in text.", "When a local/TUI user explicitly asks to send a generated file to Telegram, telegram_attach can deliver it to the paired/default Telegram chat even without an active Telegram turn.", "For an explicit thread target, provide chat_id plus thread_id; registered multi-instance followers default to their assigned thread target."];
 export declare const TELEGRAM_MESSAGE_PROMPT_SNIPPET = "Send direct Telegram Markdown text when the user explicitly asks for Telegram delivery to a concrete chat, channel, or live Pi Thread outside the normal reply flow.";
-export declare const TELEGRAM_MESSAGE_PROMPT_GUIDELINES: readonly ["Use telegram_message only when the user explicitly asks to send a message to Telegram from the local/TUI side, or names a concrete Telegram delivery target.", "For an explicitly requested channel post, pass its exact numeric id or public @username as chat_id; no local channel registry is required, and Telegram remains the authority on the bot's posting permission.", "For an explicitly requested channel media post, pass one local .jpg/.jpeg/.png/.webp photo or .mp4 video as media; the text becomes its caption (max 1024 characters), and albums or other media types are rejected.", "For a live Pi thread target, provide thread as its case-insensitive name or numeric id; the bridge sends visibly and admits one attributed turn to that live instance. Unknown, ambiguous, same, or offline targets fail before sending.", "Add buttons by embedding the same top-level telegram_button HTML comments used in normal Telegram replies; Telegram does not support standalone buttons.", "During an active Telegram turn, omit telegram_message for the current target and answer normally; use thread only when the user requests delivery to a different live Pi thread."];
+export declare const TELEGRAM_MESSAGE_PROMPT_GUIDELINES: readonly ["Use telegram_message only when the user explicitly asks to send a message to Telegram from the local/TUI side, or names a concrete Telegram delivery target.", "For an explicitly requested channel post, pass its exact numeric id or public @username as chat_id; no local channel registry is required, and Telegram remains the authority on the bot's posting permission.", "For an explicitly requested channel media post, pass one local .jpg/.jpeg/.png/.webp photo or .mp4 video as media; the text becomes its caption (max 1024 characters), and albums or other media types are rejected.", "For a live Pi thread target, provide thread as its case-insensitive name or numeric id; the bridge sends visibly and admits one attributed turn to that live instance. Unknown, ambiguous, same, or offline targets fail before sending.", "Add buttons by embedding the same telegram_button HTML comments used in normal Telegram replies; Telegram does not support standalone buttons.", "During an active Telegram turn, omit telegram_message for the current target and answer normally; use thread only when the user requests delivery to a different live Pi thread."];
 export interface TelegramModelContextAvailabilityMemory {
     suspended: boolean;
     toolNames: Set<string>;

package/node_modules/@llblab/pi-telegram/dist/lib/prompts.js

@@ -24,7 +24,7 @@ export const TELEGRAM_MESSAGE_PROMPT_GUIDELINES = [
     "For an explicitly requested channel post, pass its exact numeric id or public @username as chat_id; no local channel registry is required, and Telegram remains the authority on the bot's posting permission.",
     "For an explicitly requested channel media post, pass one local .jpg/.jpeg/.png/.webp photo or .mp4 video as media; the text becomes its caption (max 1024 characters), and albums or other media types are rejected.",
     "For a live Pi thread target, provide thread as its case-insensitive name or numeric id; the bridge sends visibly and admits one attributed turn to that live instance. Unknown, ambiguous, same, or offline targets fail before sending.",
-    "Add buttons by embedding the same top-level telegram_button HTML comments used in normal Telegram replies; Telegram does not support standalone buttons.",
+    "Add buttons by embedding the same telegram_button HTML comments used in normal Telegram replies; Telegram does not support standalone buttons.",
     "During an active Telegram turn, omit telegram_message for the current target and answer normally; use thread only when the user requests delivery to a different live Pi thread.",
 ];
 const TELEGRAM_TOOL_METADATA_LINES = Object.fromEntries([

package/node_modules/@llblab/pi-telegram/dist/lib/runtime.d.ts

@@ -119,6 +119,7 @@ export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntime
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
         assertAuthority?: () => void;
+        isCancelled?: () => boolean;
     }) => Promise<unknown>;
     updateStatus: (ctx: TContext, error?: string) => void;
     isContextActive?: (ctx: TContext) => boolean;

package/node_modules/@llblab/pi-telegram/dist/lib/runtime.js

@@ -236,6 +236,7 @@ export function createTelegramTypingLoopStarter(deps) {
                 try {
                     await deps.sendTypingAction(targetChatId, {
                         ...actionOptions,
+                        isCancelled: () => !active,
                         // This stays process-local; adapters recheck it before HTTP/IPC issuance, not just loop ticks.
                         assertAuthority() {
                             if (!active || !canContinue())

package/node_modules/@llblab/pi-telegram/dist/lib/telegram-api.d.ts

@@ -304,10 +304,10 @@ export interface TelegramApiCallOptions {
 }
 export declare class TelegramApiAuthorityError extends Error {
     readonly requestIssued: boolean;
-    constructor(requestIssued: boolean);
+    constructor(requestIssued: boolean, options?: ErrorOptions);
 }
 /** Recheck caller authority, classifying refusal by whether a Bot API request was already issued. */
-export declare function assertTelegramApiCallAuthority(assertAuthority: (() => void) | undefined, requestIssued: boolean): void;
+export declare function assertTelegramApiCallAuthority(assertAuthority: (() => void) | undefined, requestIssued: boolean, errorOptions?: ErrorOptions): void;
 export interface TelegramFileDownloadOptions {
     signal?: AbortSignal;
     maxFileSizeBytes?: number;
@@ -444,6 +444,8 @@ export interface TelegramBridgeApiRuntimeDeps {
 /** Typing issuance guard is local authority, never Bot API body or IPC data. */
 export interface TelegramTypingActionOptions extends Pick<TelegramApiCallOptions, "assertAuthority"> {
     message_thread_id?: number;
+    /** Diagnostic observation only: an ended loop does not grant issuance, success or retry. */
+    isCancelled?: () => boolean;
 }
 export interface TelegramBridgeApiRuntime extends Pick<TelegramApiClient, "call" | "callMultipart"> {
     downloadFile: (fileId: string, suggestedName: string, source?: TelegramAttachmentSource) => Promise<string>;

package/node_modules/@llblab/pi-telegram/dist/lib/telegram-api.js

@@ -43,19 +43,19 @@ const TELEGRAM_NETWORK_FAMILY_VALUES = new Set([
 ]);
 export class TelegramApiAuthorityError extends Error {
     requestIssued;
-    constructor(requestIssued) {
-        super("Telegram API call authority is unavailable.");
+    constructor(requestIssued, options) {
+        super("Telegram API call authority is unavailable.", options);
         this.name = "TelegramApiAuthorityError";
         this.requestIssued = requestIssued;
     }
 }
 /** Recheck caller authority, classifying refusal by whether a Bot API request was already issued. */
-export function assertTelegramApiCallAuthority(assertAuthority, requestIssued) {
+export function assertTelegramApiCallAuthority(assertAuthority, requestIssued, errorOptions) {
     try {
         assertAuthority?.();
     }
     catch {
-        throw new TelegramApiAuthorityError(requestIssued);
+        throw new TelegramApiAuthorityError(requestIssued, errorOptions);
     }
 }
 function parseTelegramApiTargetInteger(value) {
@@ -765,7 +765,7 @@ async function callTelegramWithRetry(method, request, options) {
             // Authority refusal is never a transport failure, retry grant or acknowledged success.
             if (error instanceof TelegramApiAuthorityError)
                 throw error;
-            assertTelegramApiCallAuthority(assertAuthority, requestIssued);
+            assertTelegramApiCallAuthority(assertAuthority, requestIssued, { cause: error });
             const retryable = isRetryableTelegramApiError(error) &&
                 !(options?.retryRateLimit === false &&
                     error instanceof TelegramApiHttpError &&
@@ -1120,7 +1120,10 @@ export function createTelegramBridgeApiRuntime(deps) {
                     }));
                     return true;
                 }
-                deps.recordRuntimeEvent("api", error, withTelegramTransportDiagnostics(error, { method }));
+                const diagnosticError = error instanceof TelegramApiAuthorityError && Object.hasOwn(error, "cause")
+                    ? error.cause : error;
+                if (!options?.isExpectedError?.(error))
+                    deps.recordRuntimeEvent("api", diagnosticError, withTelegramTransportDiagnostics(diagnosticError, { method }));
                 throw error;
             })
                 .finally(() => {
@@ -1194,13 +1197,21 @@ export function createTelegramBridgeApiRuntime(deps) {
                 ? { message_thread_id: options.message_thread_id }
                 : {}),
         }),
-        sendTypingAction: createTelegramChatActionSender((chatId, action, options) => callRecorded("sendChatAction", {
-            chat_id: chatId,
-            action,
-            ...(options?.message_thread_id !== undefined
-                ? { message_thread_id: options.message_thread_id }
-                : {}),
-        }, { assertAuthority: options?.assertAuthority }), "typing"),
+        sendTypingAction: createTelegramChatActionSender((chatId, action, options) => {
+            const isCancelled = options?.isCancelled;
+            return callRecorded("sendChatAction", {
+                chat_id: chatId,
+                action,
+                ...(options?.message_thread_id !== undefined
+                    ? { message_thread_id: options.message_thread_id }
+                    : {}),
+            }, {
+                assertAuthority: options?.assertAuthority,
+                ...(isCancelled ? {
+                    isExpectedError: (error) => error instanceof TelegramApiAuthorityError && !Object.hasOwn(error, "cause") && isCancelled() === true,
+                } : {}),
+            });
+        }, "typing"),
         sendRecordVoiceAction: createTelegramChatActionSender((chatId, action, options) => callRecorded("sendChatAction", {
             chat_id: chatId,
             action,

package/node_modules/@llblab/pi-telegram/dist/package.json

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

package/node_modules/@llblab/pi-telegram/dist/skills/telegram-bridge/SKILL.md

@@ -16,12 +16,12 @@ Use Telegram as a mobile companion to the current Pi session. Preserve the exact
 | Explicitly send from local/TUI to Telegram | `telegram_message` or `telegram_attach` |
 | Explicitly send to a different live Thread | `telegram_message(thread=...)` |
 | Add buttons | Hidden comment for footer; `telegram_button` fence for in-body rows |
-| Add explicit voice | Top-level hidden action comment |
+| Add explicit voice | Hidden action comment |
 | Build a repeated deterministic interaction | Follow `generative-apps` |
 
 A connected Telegram session proves capability, not user intent. Use Telegram features on Telegram-originated turns or explicit Telegram delivery requests only. Never call `telegram_message` for the current active target.
 
-For direct delivery, Thread routing, configuration, or diagnosis, read only the applicable reference listed under [Conditional References](#conditional-references).
+For delivery, Thread routing, configuration or diagnosis, read the applicable reference under [Conditional References](#conditional-references).
 
 ## Turn Context
 
@@ -40,7 +40,7 @@ Reply in concise, phone-width Telegram Rich Markdown. Use `$...$` and `$$...$$`
 
 ## Assistant Actions
 
-`telegram_button` and `telegram_voice` are markup, not tools. Emit action comments at column zero outside lists, quotes, code, and indentation. Comments create footer buttons or voice artifacts. For buttons between paragraphs, use a column-zero triple-backtick `telegram_button` block. Both button wrappers accept the same singleton JSON/CML cell or mixed matrix; the wrapper determines placement. Telegram removes every assistant-authored HTML comment from previews and final replies regardless of owner or Markdown position; only recognized top-level wrappers activate actions; comment-only output sends no text message.
+`telegram_button` and `telegram_voice` are markup, not tools. Complete comments activate regardless of surrounding Markdown. Escape `<!--` as `&lt;!--` for literal examples; backticks and backslashes do not disable actions. Comments create footer buttons or voice artifacts. In-body fences: ≥3 backticks/tildes, optional indentation/whitespace, exact `telegram_button`; separate same-marker closure, no shorter. Both wrappers accept a singleton JSON/CML cell or mixed matrix; the wrapper determines placement. Telegram removes every assistant-authored HTML comment from previews and final replies regardless of owner or Markdown position; only complete recognized comments or valid button fences activate actions; comment-only output sends no text message.
 
 ### Shared Encoding Rule
 
@@ -61,7 +61,7 @@ Every enabled button has a self-contained prompt and an optional selection style
 - `{label|prompt|selected_style}` and `{|prompt|selected_style}` accept `primary`, `success`, or `danger`.
 - Fourth-position `1`/`true` disables, `0`/`false` enables; omission means enabled. JSON uses boolean `disabled`. `{|Next||1}` omits label/style; `{Next|||1}` omits prompt/style; `{|||1}` is blank (Telegram receives a non-breaking space). Prefer meaningful labels and retain a useful enabled action. Enabled CML requires a prompt. Disabled controls stay visible but have no callback, queued prompt, or bound-method invocation.
 - Both wrappers concatenate rows from adjacent JSON/CML cells or matrices, with optional commas. Cells are vertical; horizontal peers require a nested row: `[[{A|a}{B|b}]]`.
-- Prefer one matrix per related group. Fenced blocks stay in place in Rich mode; HTML compatibility moves them to the footer. Native rows allow eight buttons. Malformed/oversized/unclosed blocks activate nothing; drafts hide them. Outer code fences and quoted/indented examples remain literal.
+- Prefer one matrix per related group. Fenced blocks stay in place in Rich mode; HTML compatibility moves them to the footer. Native rows allow eight buttons. Malformed/oversized/unclosed blocks activate nothing; drafts hide them. Enclosing code fences and quoted/list-prefixed button fences remain literal.
 - Both placements share prompt/app routing. In-body clicks acknowledge without recoloring; selected-style highlighting remains footer-only.
 
 A single in-body button (the four-backtick wrapper below makes this a literal example):
@@ -124,6 +124,6 @@ Before replying:
 
 - Use the ordinary path for the current target and direct tools only for explicit other delivery.
 - Attach requested files rather than only mentioning them.
-- Keep action comments and button fences top-level, complete, and canonical: CML first, JSON when necessary; either syntax may coexist within one matrix.
+- Keep comments complete and button fences top-level and canonical: CML first, JSON when necessary; either syntax may coexist within one matrix.
 - Give every enabled button a self-contained prompt; preserve confirmation for dangerous actions.
 - Expose no secret or hidden reasoning.