@llblab/pi-telegram 0.41.0 → 0.41.1

package/CHANGELOG.md

@@ -2,6 +2,13 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.41.1: Focused Operator Status Hotfix
+
+- `Next Turn Feedback`: Replies one Pi-aligned fully bold abort notice to the aborted Telegram turn, falls back to the `/next` command for local work, preserves completed intermediate output, and suppresses pending aborted assistant text so one forced transition no longer produces a contradictory second reply.
+- `Status Telemetry`: Keeps the Tokens row compact with input/output totals and moves cache read/write plus the latest cache-hit rate into a dedicated Cache row.
+- `Reply Transcription`: Runs replied voice and other media through the inbound handler/provider pipeline and appends provenance-scoped outputs inside the reply context, including Guest Mode, instead of leaving quoted audio as an untranscribed attachment.
+- `Information Hierarchy`: Brings access-denial and Threaded Mode chooser headings back under the common fully bold emoji-led sentence/colon contract.
+
 ## 0.41.0: Connected Companion Presence
 
 - `Always-On Projection`: Treats authorized Telegram connection as the public-output boundary for local, autonomous, and unclassified Pi work, always delivering completed visible blocks in order instead of exposing an independent proactive-push opt-out.

package/docs/architecture.md

@@ -301,7 +301,7 @@ Immediate controls:
 - `/start` opens the main inline application menu.
 - `/model`, `/thinking`, `/queue`, and `/settings` are hidden shortcuts to menu sections.
 - `/compact` opens an inline confirmation dialog and then runs compaction when the bridge is idle.
-- `/next` dispatches the next queued turn, aborting Pi first when needed.
+- `/next` dispatches the next queued turn, aborting Pi first when needed. When an active Telegram turn is aborted, its single Pi-aligned informational notice replies to a pre-abort snapshot of that turn; otherwise the command message is the fallback target. Aborted pending assistant text is not projected as a second reply, while already completed intermediate output remains visible.
 - `/abort` aborts active work while preserving queued items. Abort-history preservation is enabled only for Telegram-owned active turns; later local/non-Telegram agent starts clear stale abort-history mode so the next Telegram prompt appends instead of absorbing old queued turns as history.
 - `/stop` aborts and clears waiting Telegram queue items.
 
@@ -336,7 +336,7 @@ Assistant delivery guarantees:
 - Model-authored Markdown is the source of truth; the bridge does not pre-render assistant Markdown to HTML unless the operator selects `assistant.rendering: "html"` for compatibility.
 - Before native Rich Markdown delivery, the bridge normalizes known Bot-API-fragile source forms without changing visible meaning, including space-after-marker blockquotes and dollar-prefixed ticker atoms that Telegram may otherwise treat as unterminated math.
 - Prompt context blocks use compact metadata (`[tag|key:value]`) as the stable inbound contract. `[telegram...]` names the current surface only: owner/current turns use `[telegram]` or `[telegram|thread:<name>]`; guest-mode turns use `[telegram|guest:<group-title-or-peer-username-or-id>]`. In a private Guest Mode turn the paired owner's `from` identity is never the guest: the remote private-chat identity wins, then non-owner caller metadata, with a non-bot replied peer available only as a final identity fallback when stronger conversation evidence is absent; username falls back to the remote display name and numeric id. Reply attribution still belongs independently in `[reply|from:...]`, and a replied bot can never define or replace the current `[telegram|guest:...]` location identity. Source authors for quoted/forwarded material and their files are carried by `[reply|from:<username-or-id>]`, `[forward|from:<username-or-id>]`, and `[attachments|from:<username-or-id>]`, while plain `[attachments]` remains current-turn attachments and is ordered before reply/forward/source context. Media embedded in inbound Telegram `rich_message` blocks is downloaded like ordinary message media and stays attached to its forward-source block instead of being mislabeled as current-user material.
-- Quoted rich replies use Telegram `rich_message` blocks as the prompt-context source when available, so `[reply]` context receives rendered plain text instead of raw `InputRichMessage.markdown` fallback text.
+- Quoted rich replies use Telegram `rich_message` blocks as the prompt-context source when available, so `[reply]` context receives rendered plain text instead of raw `InputRichMessage.markdown` fallback text. Replied media runs through the same inbound handlers and voice transcription providers as current-message media, with provenance-scoped `[outputs|from:…]` appended inside the reply block.
 - Long native Markdown replies are split only at Telegram Rich Message transport limits; oversized fenced code, display-math, and fully wrapped inline-formatting blocks are rewrapped per chunk so persisted Rich Markdown chunks remain structurally valid.
 - When Draft previews are enabled, streaming previews pass structurally closed assistant Markdown prefixes through to `sendRichMessageDraft` with ownership checks, voice suppression, and serialized flushes. Unclosed inline spans, links, fenced code, comments, and display-math blocks are held back until a safe boundary exists. Draft failures are recorded and the failing frame is skipped instead of degrading to raw plain-message previews, because partial Markdown can be invalid while the final message remains valid.
 - Preview flushes are serialized so older edits cannot race newer drafts; final delivery waits for active draft flushes and does not perform a post-final draft-clear call.
@@ -390,7 +390,7 @@ The bridge does not mirror arbitrary `ctx.ui.confirm/input/select/custom` prompt
 
 ## Diagnostics And Operational Behavior
 
-Status rendering distinguishes connected, active, dispatching, queued, tool-running, model-switching, and compacting states; the Telegram status menu gives compaction precedence over generic active or pending work. Its Tokens row mirrors Pi's terminal footer, including inline `R` cache-read tokens, `W` cache-write tokens, and `CH` for the latest assistant request's cache-read share of prompt tokens rather than a misleading cumulative-session ratio; the label remains distinct from companion-provided usage limits. Observed automatic compaction sends the same start and completion notices as the manual command without duplicating notices for command-owned compaction. If a queue mutation removes the last waiting item while Telegram-owned work still has running tools, status remains active instead of degrading to connected.
+Status rendering distinguishes connected, active, dispatching, queued, tool-running, model-switching, and compacting states; the Telegram status menu gives compaction precedence over generic active or pending work. Its compact Tokens row shows only input and output totals, while the adjacent Cache row groups `R` cache-read tokens, `W` cache-write tokens, and `CH` for the latest assistant request's cache-read share of prompt tokens rather than a misleading cumulative-session ratio; the labels remain distinct from companion-provided usage limits. Observed automatic compaction sends the same start and completion notices as the manual command without duplicating notices for command-owned compaction. If a queue mutation removes the last waiting item while Telegram-owned work still has running tools, status remains active instead of degrading to connected.
 
 Queue reaction behavior, lane-tail transitions, Keep/Skip independence, multi-reaction precedence, and the Bot API reaction-removal limitation are defined in [Priority, Reactions, Keep, and Skip](#priority-reactions-keep-and-skip). Reaction changes first flush a matching delayed text or media group so the governed turn exists before mutation, and dropping marked heads cannot leave status permanently queued.
 

package/docs/inbound.md

@@ -67,7 +67,7 @@ Built-in placeholders for text handlers:
 
 ## Media/File Handlers
 
-Media/file handlers keep the legacy attachment-handler behavior: downloaded files are matched by `mime`, `type`, or `match`, then each file runs the first successful matching handler. Downloaded files with `mime: "text/plain"` or any `text/*` MIME type have a built-in fail-open handler that reads UTF-8 content into `[outputs]` when no configured handler produced output. Composition is useful for pipelines such as voice transcription followed by machine translation, so the agent receives translated `[outputs]` instead of the raw STT language.
+Media/file handlers keep the legacy attachment-handler behavior: downloaded files are matched by `mime`, `type`, or `match`, then each file runs the first successful matching handler. Attachments from a replied-to message use the same handler/provider pipeline independently; their `[outputs|from:…]` section remains inside that `[reply]` context after its attachment list instead of being attributed to the current message. Downloaded files with `mime: "text/plain"` or any `text/*` MIME type have a built-in fail-open handler that reads UTF-8 content into `[outputs]` when no configured handler produced output. Composition is useful for pipelines such as voice transcription followed by machine translation, so the agent receives translated `[outputs]` instead of the raw STT language.
 
 Built-in placeholders for media/file handlers:
 

package/docs/public-api.md

@@ -50,7 +50,7 @@ Stable commands inside the paired Telegram DM:
 
 - `/start` — pair when needed and open the main application menu.
 - `/compact` — open confirmation and compact when idle.
-- `/next` — dispatch the next queued turn, aborting active work first when needed.
+- `/next` — dispatch the next queued turn, aborting active work first when needed; one Pi-aligned informational reply anchors to a pre-abort snapshot of the Telegram turn or falls back to the command, and aborted pending assistant text is suppressed.
 - `/continue` — enqueue a priority `continue` prompt.
 - `/abort` — abort active work and keep the queue; abort-history is scoped to Telegram-owned active turns.
 - `/stop` — abort active Telegram-owned work and clear waiting Telegram queue items.
@@ -336,7 +336,7 @@ Contract:
 - Providers are synchronous because `/start` status text is rendered inline with the menu.
 - Return `undefined` when the line is not relevant for the active model.
 - Provider failures are isolated and skipped so optional companion status cannot break the core Telegram menu.
-- The bridge renders rows as `<Label>: <value>` in the same HTML status block as Status, Tokens, Cost, and Context, capitalizing the first label character for Telegram UI consistency. Tokens mirrors Pi's footer telemetry: `↑` input, `↓` output, `R` cache-read tokens, `W` cache-write tokens, and `CH` for the latest assistant request's `cacheRead / (input + cacheRead + cacheWrite)`, shown to one decimal place only after the session reports cache activity. The precise Tokens label avoids conflating token telemetry with companion-provided usage-limit rows.
+- The bridge renders rows as `<Label>: <value>` in the same HTML status block as Status, Tokens, Cache, Cost, and Context, capitalizing the first label character for Telegram UI consistency. Tokens contains only `↑` input and `↓` output totals. Cache groups `R` cache-read tokens, `W` cache-write tokens, and `CH` for the latest assistant request's `cacheRead / (input + cacheRead + cacheWrite)`, shown to one decimal place only after the session reports cache activity. These precise labels avoid conflating token telemetry with companion-provided usage-limit rows.
 
 ## Updates
 

package/lib/activity.ts

@@ -428,6 +428,9 @@ export function createTelegramActivityBridgeRuntime(deps: {
     onAssistantEvent(event) {
       getRuntime()?.onAssistantEvent(event);
     },
+    onAssistantMessageEnd(stopReason) {
+      getRuntime()?.onAssistantMessageEnd(stopReason);
+    },
     onToolStart(event) {
       getRuntime()?.onToolStart(event);
     },
@@ -491,6 +494,7 @@ export interface TelegramActivityRuntime {
   recordInputSource: (source: TelegramActivityInputSource) => void;
   onAgentStart: (activeTelegramTarget?: TelegramActivityTarget) => void;
   onAssistantEvent: (event: TelegramAssistantStreamEvent) => void;
+  onAssistantMessageEnd: (stopReason?: string) => void;
   onToolStart: (event: {
     toolCallId: string;
     toolName: string;
@@ -677,6 +681,9 @@ export function createTelegramActivityRuntime(deps: {
       }
       if (event.type === "error") flushPendingSegment("terminal-partial");
     },
+    onAssistantMessageEnd(stopReason) {
+      if (stopReason === "aborted") pendingAssistantSegment = undefined;
+    },
     onToolStart(event) {
       emit({ type: "tool-start", ...event });
     },

package/lib/bindings.ts

@@ -1218,6 +1218,9 @@ export function registerTelegramLifecycleRuntimeHooks({
     },
     onMessageEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
+      if (event.message.role === "assistant") {
+        activityRuntime.onAssistantMessageEnd(event.message.stopReason);
+      }
       terminalAssistantMessagePendingDelivery =
         event.message.role === "assistant" &&
         event.message.stopReason !== "toolUse" &&

package/lib/commands.ts

@@ -1049,6 +1049,9 @@ export interface TelegramCommandRuntimeDeps<
     text: string,
     options?: { parseMode?: "HTML" },
   ) => Promise<void>;
+  getActiveTurnReply?: () =>
+    | ((text: string, options?: { parseMode?: "HTML" }) => Promise<void>)
+    | undefined;
   sendInteractiveMessage?: TelegramCompactConfirmationDeps["sendInteractiveMessage"];
   assertExecutionCurrent?: (message: TMessage) => void;
 }
@@ -1272,6 +1275,9 @@ export async function handleTelegramNextCommand(deps: {
     text: string,
     options?: { parseMode?: "HTML" },
   ) => Promise<void>;
+  getActiveTurnReply?: () =>
+    | ((text: string, options?: { parseMode?: "HTML" }) => Promise<void>)
+    | undefined;
 }): Promise<void> {
   deps.clearPendingModelSwitch();
   if (!deps.hasQueuedItems()) {
@@ -1282,16 +1288,19 @@ export async function handleTelegramNextCommand(deps: {
     return;
   }
   if (!deps.isIdle() && deps.hasAbortHandler()) {
+    const activeTurnReply = deps.getActiveTurnReply?.();
     deps.clearFoldForDispatch();
     deps.abortCurrentTurn();
     deps.updateStatus();
-    await deps.sendTextReply(
-      formatTelegramInformationHeading(
-        "⏩",
-        "Aborted! Dispatching next queued turn.",
-      ),
-      { parseMode: "HTML" },
+    const notice = formatTelegramInformationHeading(
+      "⏩",
+      "Operation aborted. Dispatching next queued turn.",
     );
+    if (activeTurnReply) {
+      await activeTurnReply(notice, { parseMode: "HTML" });
+    } else {
+      await deps.sendTextReply(notice, { parseMode: "HTML" });
+    }
     return;
   }
   if (!deps.isIdle()) {
@@ -1799,6 +1808,7 @@ async function handleTelegramCommandRuntime<
             deps.setFoldQueuedPromptsIntoHistory(false),
           updateStatus: updateStatusFor(commandCtx),
           sendTextReply: sendReplyFor(nextMessage),
+          getActiveTurnReply: deps.getActiveTurnReply,
         });
       },
       handleContinue: async (nextMessage, commandCtx) => {

package/lib/media.ts

@@ -366,6 +366,7 @@ export function extractTelegramReplyContextText(
 export function buildTelegramReplyContextBlock(
   message: TelegramMediaMessage,
   replyFiles: Pick<DownloadedTelegramFile, "path">[] = [],
+  replyOutputs: readonly string[] = [],
 ): string {
   const from = formatTelegramUser(message.reply_to_message?.from);
   const header = from ? `[reply|from:${from}]` : "[reply]";
@@ -379,10 +380,19 @@ export function buildTelegramReplyContextBlock(
     ? replyFiles.map((file) => `- /${basename(file.path)}`)
     : replyFiles.map((file) => `- ${file.path}`);
   const replyBlock = text ? `${header} ${text}` : header;
+  const sections = [replyBlock];
   if (fileLines.length > 0) {
-    return `${replyBlock}\n\n${attachmentHeader}\n${fileLines.join("\n")}`;
+    sections.push(`${attachmentHeader}\n${fileLines.join("\n")}`);
+  }
+  if (replyOutputs.length > 0) {
+    const outputHeader = `[outputs${from ? `|from:${from}` : ""}]`;
+    sections.push(
+      `${outputHeader}\n${replyOutputs.map((output) => `- ${output}`).join("\n")}`,
+    );
+  }
+  if (text || fileLines.length > 0 || replyOutputs.length > 0) {
+    return sections.join("\n\n");
   }
-  if (text) return replyBlock;
   return "";
 }
 

package/lib/routing.ts

@@ -107,8 +107,9 @@ function appendTelegramSourceAttachmentSection(
   text: string,
   from: string | undefined,
   files: Pick<Media.DownloadedTelegramFile, "path">[],
+  outputs: readonly string[] = [],
 ): string {
-  if (files.length === 0) return text;
+  if (files.length === 0 && outputs.length === 0) return text;
   const dirs = [...new Set(files.map((file) => dirname(file.path)))];
   const sameDir = dirs.length === 1;
   const source = from ? `|from:${from}` : "";
@@ -118,8 +119,15 @@ function appendTelegramSourceAttachmentSection(
   const items = sameDir
     ? files.map((file) => `/${basename(file.path)}`)
     : files.map((file) => file.path);
-  const prefix = text.length > 0 ? `${text}\n\n` : "";
-  return `${prefix}${header}\n${items.map((item) => `- ${item}`).join("\n")}`;
+  const sections = text ? [text] : [];
+  if (items.length > 0) {
+    sections.push(`${header}\n${items.map((item) => `- ${item}`).join("\n")}`);
+  }
+  if (outputs.length > 0) {
+    const outputHeader = `[outputs${source}]`;
+    sections.push(`${outputHeader}\n${outputs.map((output) => `- ${output}`).join("\n")}`);
+  }
+  return sections.join("\n\n");
 }
 
 function getContextCwd(ctx: unknown): string | undefined {
@@ -269,7 +277,7 @@ function getTelegramRoutableThreadRecords(
 
 function formatTelegramAllTabMenuChooserText(command: string): string {
   return [
-    "<b>🧵 Choose target thread</b>",
+    "<b>🧵 Choose target thread:</b>",
     "",
     `You used <code>/${escapeHtml(command)}</code> from the <b>All</b> tab.`,
     "Select the Pi thread that should handle it:",
@@ -332,7 +340,7 @@ function buildTelegramUnboundRerouteRestoreChooserMarkup(
 
 function formatTelegramUnboundRerouteRestoreChooserText(): string {
   return [
-    "<b>🧵 Replace/restore Telegram thread</b>",
+    "<b>🧵 Replace/restore Telegram thread:</b>",
     "",
     "Choose the Pi instance to move to this new Telegram thread:",
   ].join("\n");
@@ -340,7 +348,7 @@ function formatTelegramUnboundRerouteRestoreChooserText(): string {
 
 function formatTelegramUnboundTopicGuidance(): string {
   return [
-    "⚠️ <b>New thread is not a Pi instance</b>",
+    "<b>⚠️ New thread is not a Pi instance.</b>",
     "",
     "To create a bound Telegram tab:",
     "<code>1.</code> Start another Pi instance in your terminal.",
@@ -358,7 +366,7 @@ function formatTelegramUnboundRerouteChooserText(
   options: { includeGuidance?: boolean } = {},
 ): string {
   const rerouteText = [
-    "🧵 <b>Choose target thread</b>",
+    "<b>🧵 Choose target thread:</b>",
     "",
     "Your message is still in this Telegram thread.",
     "Select the Pi thread that should handle it:",
@@ -1877,6 +1885,18 @@ export function createTelegramInboundRouteRuntime<
     getPromptTemplateCommands,
     persistConfig: deps.configStore.persist,
     sendTextReply: deps.sendTextReply,
+    getActiveTurnReply: () => {
+      const activeTurn = deps.activeTurnRuntime.get();
+      if (!activeTurn) return undefined;
+      return async (text, options) => {
+        await deps.sendTextReply(
+          activeTurn.chatId,
+          activeTurn.replyToMessageId,
+          text,
+          { target: activeTurn.target, parseMode: options?.parseMode },
+        );
+      };
+    },
     sendInteractiveMessage: deps.sendInteractiveMessage,
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
@@ -2265,6 +2285,11 @@ export function createTelegramInboundRouteRuntime<
         )
       : [];
     assertExecutionCurrent();
+    const processedReply =
+      replyFiles.length > 0
+        ? await deps.inboundHandlerRuntime.process(replyFiles, "", ctx)
+        : undefined;
+    assertExecutionCurrent();
     const files = await Media.downloadTelegramMessageFiles([guestMsg], {
       downloadFile: deps.downloadFile,
     });
@@ -2285,7 +2310,8 @@ export function createTelegramInboundRouteRuntime<
       sourceContext = appendTelegramSourceAttachmentSection(
         replyBlock,
         replyPeer,
-        replyFiles,
+        processedReply?.promptFiles ?? replyFiles,
+        processedReply?.handlerOutputs,
       );
     }
     const promptText = Turns.buildTelegramTurnPrompt({

package/lib/status.ts

@@ -1494,17 +1494,22 @@ function buildUsageSummary(stats: TelegramUsageStats): string | undefined {
   const tokenParts: string[] = [];
   if (stats.totalInput) tokenParts.push(`↑${formatTokens(stats.totalInput)}`);
   if (stats.totalOutput) tokenParts.push(`↓${formatTokens(stats.totalOutput)}`);
+  return tokenParts.length > 0 ? tokenParts.join(" ") : undefined;
+}
+
+function buildCacheSummary(stats: TelegramUsageStats): string | undefined {
+  const cacheParts: string[] = [];
   if (stats.totalCacheRead)
-    tokenParts.push(`R${formatTokens(stats.totalCacheRead)}`);
+    cacheParts.push(`R${formatTokens(stats.totalCacheRead)}`);
   if (stats.totalCacheWrite)
-    tokenParts.push(`W${formatTokens(stats.totalCacheWrite)}`);
+    cacheParts.push(`W${formatTokens(stats.totalCacheWrite)}`);
   if (
     (stats.totalCacheRead > 0 || stats.totalCacheWrite > 0) &&
     stats.latestCacheHitRate !== undefined
   ) {
-    tokenParts.push(`CH${stats.latestCacheHitRate.toFixed(1)}%`);
+    cacheParts.push(`CH${stats.latestCacheHitRate.toFixed(1)}%`);
   }
-  return tokenParts.length > 0 ? tokenParts.join(" ") : undefined;
+  return cacheParts.length > 0 ? cacheParts.join(" ") : undefined;
 }
 
 function buildCostSummary(
@@ -1557,10 +1562,14 @@ export function buildStatusHtml(
     ),
   ];
   const usageSummary = buildUsageSummary(stats);
+  const cacheSummary = buildCacheSummary(stats);
   const costSummary = buildCostSummary(stats, usesSubscription);
   if (usageSummary) {
     lines.push(buildStatusRow("Tokens", usageSummary));
   }
+  if (cacheSummary) {
+    lines.push(buildStatusRow("Cache", cacheSummary));
+  }
   if (costSummary) {
     lines.push(buildStatusRow("Cost", costSummary));
   }

package/lib/turns.ts

@@ -468,8 +468,17 @@ export function createTelegramPromptTurnRuntimeBuilder<
         )
       : [];
     if (firstMessage) deps.assertExecutionCurrent?.(firstMessage);
+    const processedReply =
+      deps.processAttachments && replyFiles.length > 0
+        ? await deps.processAttachments(replyFiles, "", ctx as TContext)
+        : undefined;
+    if (firstMessage) deps.assertExecutionCurrent?.(firstMessage);
     const replyContext = firstMessage
-      ? buildTelegramReplyContextBlock(firstMessage, replyFiles)
+      ? buildTelegramReplyContextBlock(
+          firstMessage,
+          processedReply?.promptFiles ?? replyFiles,
+          processedReply?.handlerOutputs,
+        )
       : "";
     const forwardEntries = messages.flatMap((message) => {
       const context = extractTelegramForwardContextText(

package/lib/updates.ts

@@ -895,7 +895,7 @@ const TELEGRAM_UNAUTHORIZED_DENIAL_COPY = "Access denied.";
 
 function formatTelegramUnauthorizedDenial(format: "plain" | "html"): string {
   return format === "html"
-    ? `🚫 <b>${TELEGRAM_UNAUTHORIZED_DENIAL_COPY}</b>`
+    ? `<b>🚫 ${TELEGRAM_UNAUTHORIZED_DENIAL_COPY}</b>`
     : `🚫 ${TELEGRAM_UNAUTHORIZED_DENIAL_COPY}`;
 }
 

package/package.json

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