@llblab/pi-telegram 0.6.3 → 0.7.1

package/lib/queue.ts

@@ -1,6 +1,7 @@
 /**
- * Telegram queue and queue-runtime domain helpers
- * Owns queue items, queue mutations, dispatch and lifecycle planning, session resets, and queue-adjacent runtime helpers
+ * Telegram queue core contracts and pure planning helpers
+ * Zones: telegram queue, pi agent lifecycle, scheduling
+ * Owns queue item contracts, lane admission, pure queue mutations, and dispatch planning
  */
 
 // --- Queue Items ---
@@ -178,6 +179,14 @@ export function createTelegramQueueStore<TContext = unknown>(
   };
 }
 
+export function createTelegramQueueItemCountGetter<TContext = unknown>(
+  store: Pick<TelegramQueueStore<TContext>, "getQueuedItems">,
+): () => number {
+  return function getTelegramQueueItemCount() {
+    return store.getQueuedItems().length;
+  };
+}
+
 export function createTelegramActiveTurnStore<
   TTurn extends PendingTelegramTurn = PendingTelegramTurn,
 >(): TelegramActiveTurnStore<TTurn> {
@@ -344,7 +353,7 @@ function formatTelegramQueueItemStatusSummary<TContext = unknown>(
   item: TelegramQueueItem<TContext>,
 ): string {
   if (item.queueLane === "priority") {
-    return `⬆ ${item.statusSummary}`;
+    return `⚡ ${item.statusSummary}`;
   }
   return item.statusSummary;
 }
@@ -665,18 +674,32 @@ export type TelegramAgentLifecycleHooksRuntimeDeps<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
+  TReplyMarkup = unknown,
 > = TelegramAgentStartHookRuntimeDeps<TTurn, TContext> &
-  TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage> &
+  TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage, TReplyMarkup> &
   TelegramToolExecutionHookRuntimeDeps<TContext>;
 
 export function createTelegramAgentLifecycleHooks<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
->(deps: TelegramAgentLifecycleHooksRuntimeDeps<TTurn, TContext, TMessage>) {
+  TReplyMarkup = unknown,
+>(
+  deps: TelegramAgentLifecycleHooksRuntimeDeps<
+    TTurn,
+    TContext,
+    TMessage,
+    TReplyMarkup
+  >,
+) {
   return {
     onAgentStart: createTelegramAgentStartHook<TTurn, TContext>(deps),
-    onAgentEnd: createTelegramAgentEndHook<TTurn, TContext, TMessage>(deps),
+    onAgentEnd: createTelegramAgentEndHook<
+      TTurn,
+      TContext,
+      TMessage,
+      TReplyMarkup
+    >(deps),
     ...createTelegramToolExecutionHooks<TContext>(deps),
   };
 }
@@ -737,6 +760,7 @@ export interface TelegramAgentEndOutboundReplyPlan<TReplyMarkup = unknown> {
 
 export interface TelegramAgentEndRuntimeDeps<
   TTurn extends PendingTelegramTurn,
+  TReplyMarkup = unknown,
 > {
   turn: TTurn | undefined;
   assistant: TelegramAgentEndAssistantResult;
@@ -750,13 +774,13 @@ export interface TelegramAgentEndRuntimeDeps<
     chatId: number,
     markdown: string,
     replyToMessageId: number,
-    options?: { replyMarkup?: unknown },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<boolean>;
   sendMarkdownReply: (
     chatId: number,
     replyToMessageId: number,
     markdown: string,
-    options?: { replyMarkup?: unknown },
+    options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<unknown>;
   sendTextReply: (
     chatId: number,
@@ -764,7 +788,9 @@ export interface TelegramAgentEndRuntimeDeps<
     text: string,
   ) => Promise<unknown>;
   sendQueuedAttachments: (turn: TTurn) => Promise<void>;
-  planOutboundReply?: (markdown: string) => TelegramAgentEndOutboundReplyPlan;
+  planOutboundReply?: (
+    markdown: string,
+  ) => TelegramAgentEndOutboundReplyPlan<TReplyMarkup>;
   sendOutboundReplyArtifacts?: (
     turn: TTurn,
     plan: TelegramAgentEndOutboundReplyPlan,
@@ -776,6 +802,7 @@ export interface TelegramAgentEndHookRuntimeDeps<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
+  TReplyMarkup = unknown,
 > {
   getActiveTurn: () => TTurn | undefined;
   extractAssistant: (
@@ -790,11 +817,20 @@ export interface TelegramAgentEndHookRuntimeDeps<
   ) => void;
   clearPreview: (chatId: number) => Promise<void>;
   setPreviewPendingText: (text: string) => void;
-  finalizeMarkdownPreview: TelegramAgentEndRuntimeDeps<TTurn>["finalizeMarkdownPreview"];
-  sendMarkdownReply: TelegramAgentEndRuntimeDeps<TTurn>["sendMarkdownReply"];
+  finalizeMarkdownPreview: TelegramAgentEndRuntimeDeps<
+    TTurn,
+    TReplyMarkup
+  >["finalizeMarkdownPreview"];
+  sendMarkdownReply: TelegramAgentEndRuntimeDeps<
+    TTurn,
+    TReplyMarkup
+  >["sendMarkdownReply"];
   sendTextReply: TelegramAgentEndRuntimeDeps<TTurn>["sendTextReply"];
   sendQueuedAttachments: (turn: TTurn) => Promise<void>;
-  planOutboundReply?: TelegramAgentEndRuntimeDeps<TTurn>["planOutboundReply"];
+  planOutboundReply?: TelegramAgentEndRuntimeDeps<
+    TTurn,
+    TReplyMarkup
+  >["planOutboundReply"];
   sendOutboundReplyArtifacts?: TelegramAgentEndRuntimeDeps<TTurn>["sendOutboundReplyArtifacts"];
 }
 
@@ -872,7 +908,15 @@ export function createTelegramAgentEndHook<
   TTurn extends PendingTelegramTurn,
   TContext,
   TMessage,
->(deps: TelegramAgentEndHookRuntimeDeps<TTurn, TContext, TMessage>) {
+  TReplyMarkup = unknown,
+>(
+  deps: TelegramAgentEndHookRuntimeDeps<
+    TTurn,
+    TContext,
+    TMessage,
+    TReplyMarkup
+  >,
+) {
   return async function onAgentEnd(
     event: TelegramAgentEndHookEvent<TMessage>,
     ctx: TContext,
@@ -903,7 +947,8 @@ export function createTelegramAgentEndHook<
 
 export async function handleTelegramAgentEndRuntime<
   TTurn extends PendingTelegramTurn,
->(deps: TelegramAgentEndRuntimeDeps<TTurn>): Promise<void> {
+  TReplyMarkup = unknown,
+>(deps: TelegramAgentEndRuntimeDeps<TTurn, TReplyMarkup>): Promise<void> {
   const { turn, assistant } = deps;
   const rawFinalText = assistant.text;
   const outboundReply = rawFinalText
@@ -934,7 +979,7 @@ export async function handleTelegramAgentEndRuntime<
       turn.chatId,
       turn.replyToMessageId,
       assistant.errorMessage ||
-        "Telegram bridge: pi failed while processing the request.",
+        "Telegram bridge: π failed while processing the request.",
     );
     if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
     return;

package/lib/rendering.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram preview and markdown rendering helpers
+ * Zones: telegram rendering, shared text utils
  * Converts assistant output into Telegram-safe plain text and HTML chunks with chunk-boundary handling
  */
 

package/lib/replies.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram reply delivery helpers
+ * Zones: telegram outbound, rendering transport
  * Owns rendered-message delivery, reply transport wiring, and plain or markdown final replies
  */
 
@@ -10,10 +11,48 @@ import {
   type TelegramRenderMode,
 } from "./rendering.ts";
 
+// --- Reply Dedup ---
+
+/** Non-persistent reply deduplication for a single agent turn.
+ *  First reply to a prompt gets `reply_parameters.reply_to_message_id`;
+ *  subsequent replies in the same turn skip it to avoid stacking
+ *  duplicate reply headers in the chat viewport. */
+export interface ReplyDedupRuntime {
+  /** Returns true if this is the first reply for the given prompt
+   *  message id in the current turn. Side-effect: marks it replied. */
+  shouldReply(promptMessageId: number): boolean;
+  /** Reset the tracker when a new prompt enters the queue. */
+  reset(): void;
+}
+
+export function createReplyDedupRuntime(): ReplyDedupRuntime {
+  const replied = new Map<number, boolean>();
+  return {
+    shouldReply(promptMessageId: number): boolean {
+      if (replied.has(promptMessageId)) return false;
+      replied.set(promptMessageId, true);
+      return true;
+    },
+    reset(): void {
+      replied.clear();
+    },
+  };
+}
+
+// --- Transport-level dedup ---
+
+let lastRepliedToMessageId: number | undefined;
+
+export function resetTransportReplyDedup(): void {
+  lastRepliedToMessageId = undefined;
+}
+
 export function buildTelegramReplyParameters(
   messageId: number | undefined,
 ): TelegramReplyParameters | undefined {
   if (messageId === undefined) return undefined;
+  if (messageId === lastRepliedToMessageId) return undefined;
+  lastRepliedToMessageId = messageId;
   return { message_id: messageId, allow_sending_without_reply: true };
 }
 
@@ -219,13 +258,13 @@ export interface TelegramRenderedMessageRuntimeDeps<TReplyMarkup> {
 export interface TelegramRenderedMessageRuntime<TReplyMarkup> {
   sendTextReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     text: string,
     options?: { parseMode?: "HTML" },
   ) => Promise<number | undefined>;
   sendMarkdownReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     markdown: string,
     options?: { replyMarkup?: unknown },
   ) => Promise<number | undefined>;
@@ -332,3 +371,52 @@ export function createTelegramRenderedMessageRuntime<TReplyMarkup>(
     },
   };
 }
+
+// --- Dedup-wrapped Reply Wrappers ---
+
+/** Wrap a sendTextReply with reply dedup so only the first message
+ *  in a turn carries `reply_to_message_id`. */
+export function dedupSendTextReply(
+  dedup: ReplyDedupRuntime,
+  inner: (
+    chatId: number,
+    replyToMessageId: number | undefined,
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<number | undefined>,
+): (
+  chatId: number,
+  replyToMessageId: number,
+  text: string,
+  options?: { parseMode?: "HTML" },
+) => Promise<number | undefined> {
+  return async (chatId, replyToMessageId, text, options) => {
+    const effectiveReplyTo = dedup.shouldReply(replyToMessageId)
+      ? replyToMessageId
+      : undefined;
+    return inner(chatId, effectiveReplyTo, text, options);
+  };
+}
+
+/** Wrap a sendMarkdownReply with reply dedup. */
+export function dedupSendMarkdownReply<TReplyMarkup = unknown>(
+  dedup: ReplyDedupRuntime,
+  inner: (
+    chatId: number,
+    replyToMessageId: number | undefined,
+    markdown: string,
+    options?: { replyMarkup?: TReplyMarkup },
+  ) => Promise<number | undefined>,
+): (
+  chatId: number,
+  replyToMessageId: number,
+  markdown: string,
+  options?: { replyMarkup?: TReplyMarkup },
+) => Promise<number | undefined> {
+  return async (chatId, replyToMessageId, markdown, options) => {
+    const effectiveReplyTo = dedup.shouldReply(replyToMessageId)
+      ? replyToMessageId
+      : undefined;
+    return inner(chatId, effectiveReplyTo, markdown, options);
+  };
+}

package/lib/routing.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram inbound routing composition
+ * Zones: telegram inbound, orchestration, queue/menu/command composition
  * Wires authorized updates into menus, commands, media grouping, and prompt queueing
  */
 
@@ -11,6 +12,7 @@ import * as Media from "./media.ts";
 import * as Menu from "./menu.ts";
 import * as Model from "./model.ts";
 import * as Queue from "./queue.ts";
+import * as PromptTemplates from "./prompt-templates.ts";
 import type { TelegramBridgeRuntime } from "./runtime.ts";
 import * as Turns from "./turns.ts";
 import * as Updates from "./updates.ts";
@@ -25,11 +27,6 @@ export type TelegramRoutedCallbackQuery = Updates.TelegramCallbackQuery &
   Menu.MenuCallbackQuery;
 
 export interface TelegramInboundRouteRuntimeDeps<
-  TUpdate extends Updates.TelegramUpdateFlow & {
-    message?: TMessage;
-    edited_message?: TMessage;
-    callback_query?: TCallbackQuery;
-  },
   TMessage extends TelegramRoutedMessage,
   TCallbackQuery extends TelegramRoutedCallbackQuery,
   TContext,
@@ -51,6 +48,15 @@ export interface TelegramInboundRouteRuntimeDeps<
     Model.ScopedTelegramModel<TModel>
   >;
   menuActions: Menu.TelegramMenuActionRuntime<TContext, TModel>;
+  openQueueMenu: (
+    chatId: number,
+    replyToMessageId: number,
+    ctx: TContext,
+  ) => Promise<void>;
+  queueMenuCallbackHandler: (
+    query: TCallbackQuery,
+    ctx: TContext,
+  ) => Promise<boolean>;
   buttonActionStore?: OutboundHandlers.TelegramButtonActionStore;
   attachmentHandlerRuntime: TelegramAttachmentHandlerRuntime<TContext>;
   updateStatus: (ctx: TContext, error?: string) => void;
@@ -65,10 +71,14 @@ export interface TelegramInboundRouteRuntimeDeps<
     text: string,
   ) => Promise<number | undefined>;
   setMyCommands: Commands.TelegramBotCommandRegistrationDeps["setMyCommands"];
+  getCommands: () => Parameters<
+    typeof PromptTemplates.getTelegramPromptTemplateCommands
+  >[0];
   downloadFile: Media.DownloadTelegramMessageFilesDeps["downloadFile"];
   getThinkingLevel: () => Model.ThinkingLevel;
   setThinkingLevel: (level: Model.ThinkingLevel) => void;
   setModel: (model: TModel) => Promise<boolean>;
+  sendUserMessage?: (message: string) => void;
   isIdle: (ctx: TContext) => boolean;
   hasPendingMessages: (ctx: TContext) => boolean;
   compact: (
@@ -82,6 +92,21 @@ export interface TelegramInboundRouteRuntimeDeps<
   ) => void;
 }
 
+const TELEGRAM_OWNED_CALLBACK_PREFIXES = [
+  "menu:",
+  "model:",
+  "queue:",
+  "status:",
+  "tgbtn:",
+  "thinking:",
+] as const;
+
+function isTelegramOwnedCallbackData(data: string): boolean {
+  return TELEGRAM_OWNED_CALLBACK_PREFIXES.some((prefix) =>
+    data.startsWith(prefix),
+  );
+}
+
 export function createTelegramInboundRouteRuntime<
   TUpdate extends Updates.TelegramUpdateFlow & {
     message?: TMessage;
@@ -94,7 +119,6 @@ export function createTelegramInboundRouteRuntime<
   TModel extends Model.MenuModel,
 >(
   deps: TelegramInboundRouteRuntimeDeps<
-    TUpdate,
     TMessage,
     TCallbackQuery,
     TContext,
@@ -159,8 +183,65 @@ export function createTelegramInboundRouteRuntime<
       );
       if (handled) return;
     }
+    const handledByQueue = await deps.queueMenuCallbackHandler(query, ctx);
+    if (handledByQueue) return;
+    const callbackData = query.data;
+    if (
+      deps.sendUserMessage &&
+      callbackData &&
+      !isTelegramOwnedCallbackData(callbackData)
+    ) {
+      deps.sendUserMessage(`[callback] ${callbackData}`);
+      await deps.answerCallbackQuery(query.id);
+      return;
+    }
     await menuCallbackHandler(query, ctx);
   };
+  const promptTurnBuilder = Turns.createTelegramPromptTurnRuntimeBuilder<
+    TMessage,
+    TContext
+  >({
+    allocateQueueOrder: deps.bridgeRuntime.queue.allocateItemOrder,
+    downloadFile: deps.downloadFile,
+    processAttachments: deps.attachmentHandlerRuntime.process,
+  });
+  const enqueueContinueTurn = async (
+    message: TMessage,
+    ctx: TContext,
+  ): Promise<void> => {
+    const enqueuePlan = Queue.planTelegramPromptEnqueue(
+      deps.telegramQueueStore.getQueuedItems(),
+      deps.bridgeRuntime.lifecycle.shouldPreserveQueuedTurnsAsHistory(),
+    );
+    deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory(false);
+    const continueMessage = {
+      ...message,
+      text: "continue",
+      caption: undefined,
+    } as TMessage;
+    const turn = await promptTurnBuilder(
+      [continueMessage],
+      enqueuePlan.historyTurns,
+      ctx,
+    );
+    const continueTurn = {
+      ...turn,
+      queueLane: "priority" as const,
+      laneOrder: Number.MIN_SAFE_INTEGER + turn.queueOrder,
+      statusSummary: "continue",
+    };
+    deps.telegramQueueStore.setQueuedItems(enqueuePlan.remainingItems);
+    deps.queueMutationRuntime.append(continueTurn, ctx);
+    deps.dispatchNextQueuedTelegramTurn(ctx);
+  };
+  const reservedCommandNames = new Set(
+    Commands.TELEGRAM_RESERVED_COMMAND_NAMES,
+  );
+  const getPromptTemplateCommands = () =>
+    PromptTemplates.getTelegramPromptTemplateCommands(
+      deps.getCommands(),
+      reservedCommandNames,
+    );
   const commandHandler = Commands.createTelegramCommandHandlerTargetRuntime<
     TMessage,
     TContext
@@ -181,15 +262,25 @@ export function createTelegramInboundRouteRuntime<
       deps.bridgeRuntime.lifecycle.setCompactionInProgress,
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    enqueueContinueTurn,
     compact: deps.compact,
     allocateItemOrder: deps.bridgeRuntime.queue.allocateItemOrder,
     allocateControlOrder: deps.bridgeRuntime.queue.allocateControlOrder,
     appendControlItem: deps.queueMutationRuntime.append,
     showStatus: deps.menuActions.sendStatusMessage,
     openModelMenu: deps.menuActions.openModelMenu,
+    openThinkingMenu: (message, ctx) => {
+      const chatId = (message as { chat: { id: number } }).chat.id;
+      return deps.menuActions.openThinkingMenu(chatId, message.message_id, ctx);
+    },
+    openQueueMenu: (message, ctx) => {
+      const chatId = (message as { chat: { id: number } }).chat.id;
+      return deps.openQueueMenu(chatId, message.message_id, ctx);
+    },
     getAllowedUserId: deps.configStore.getAllowedUserId,
     setAllowedUserId: deps.configStore.setAllowedUserId,
     setMyCommands: deps.setMyCommands,
+    getPromptTemplateCommands,
     persistConfig: deps.configStore.persist,
     sendTextReply: deps.sendTextReply,
     recordRuntimeEvent: deps.recordRuntimeEvent,
@@ -203,14 +294,7 @@ export function createTelegramInboundRouteRuntime<
       deps.bridgeRuntime.lifecycle.shouldPreserveQueuedTurnsAsHistory,
     setPreserveQueuedTurnsAsHistory:
       deps.bridgeRuntime.lifecycle.setPreserveQueuedTurnsAsHistory,
-    createTurn: Turns.createTelegramPromptTurnRuntimeBuilder<
-      TMessage,
-      TContext
-    >({
-      allocateQueueOrder: deps.bridgeRuntime.queue.allocateItemOrder,
-      downloadFile: deps.downloadFile,
-      processAttachments: deps.attachmentHandlerRuntime.process,
-    }),
+    createTurn: promptTurnBuilder,
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
   }).enqueue;
@@ -220,6 +304,14 @@ export function createTelegramInboundRouteRuntime<
   >({
     extractRawText: Media.extractFirstTelegramMessageText,
     handleCommand: commandHandler,
+    expandPromptTemplateCommand: (commandName, args) =>
+      PromptTemplates.expandTelegramPromptTemplateCommand(
+        commandName,
+        args,
+        getPromptTemplateCommands(),
+      ),
+    replaceMessageText: (message, text) =>
+      ({ ...message, text, caption: undefined }) as TMessage,
     enqueueTurn: promptEnqueue,
   });
   const mediaDispatch = Media.createTelegramMediaGroupDispatchRuntime<

package/lib/runtime.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram bridge runtime-state helpers
+ * Zones: pi agent runtime state, telegram session, shared coordination
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
 
@@ -350,6 +351,7 @@ export function createTelegramTypingLoopStarter<TContext>(
         } catch (error) {
           const message =
             error instanceof Error ? error.message : String(error);
+          deps.updateStatus(ctx, message);
           deps.recordRuntimeEvent?.("typing", error, {
             chatId: targetChatId,
           });

package/lib/setup.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram setup prompt helpers
+ * Zones: pi agent command ui, telegram config
  * Computes token-prefill defaults and prompt mode selection for /telegram-setup
  */
 

package/lib/status.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram status rendering helpers
+ * Zones: telegram ui, pi agent diagnostics, tui
  * Builds usage, cost, and context summaries for the interactive Telegram status view
  */
 
@@ -41,6 +42,8 @@ export interface TelegramStatusActiveModel {
 export interface TelegramStatusContext {
   sessionManager: { getEntries(): TelegramStatusSessionEntry[] };
   getContextUsage(): TelegramContextUsage | undefined;
+  isIdle?: () => boolean;
+  hasPendingMessages?: () => boolean;
   modelRegistry: {
     isUsingOAuth(model: TelegramStatusActiveModel): boolean;
   };
@@ -406,12 +409,17 @@ export function buildTelegramStatusBarText(
     return `${label} ${theme.fg("muted", "disconnected")}`;
   if (!state.paired)
     return `${label} ${theme.fg("warning", "awaiting pairing")}`;
-  const queued = theme.fg("muted", state.queuedStatus);
+  const queued = state.queuedStatus
+    ? theme.fg("muted", state.queuedStatus)
+    : "";
   if (state.compactionInProgress) {
     return `${label} ${theme.fg("accent", "compacting")}${queued}`;
   }
   if (state.processing) {
-    return `${label} ${theme.fg("accent", state.processingStatus ?? "processing")}${queued}`;
+    const processingStatus = state.processingStatus ?? "processing";
+    const processingToken =
+      processingStatus === "active" ? "warning" : "accent";
+    return `${label} ${theme.fg(processingToken, processingStatus)}${queued}`;
   }
   return `${label} ${theme.fg("success", "connected")}`;
 }
@@ -528,6 +536,13 @@ function buildContextSummary(
   return `${percent}/${formatTokens(contextWindow)}`;
 }
 
+function buildStatusSummary(ctx: TelegramStatusContext): string {
+  if (ctx.hasPendingMessages?.()) return "pending";
+  if (ctx.isIdle?.() === false) return "active";
+  if (ctx.isIdle?.() === true) return "idle";
+  return "unknown";
+}
+
 export function buildStatusHtml(
   ctx: TelegramStatusContext,
   activeModel: TelegramStatusActiveModel | undefined,
@@ -536,7 +551,7 @@ export function buildStatusHtml(
   const usesSubscription = activeModel
     ? ctx.modelRegistry.isUsingOAuth(activeModel)
     : false;
-  const lines: string[] = [];
+  const lines: string[] = [buildStatusRow("Status", buildStatusSummary(ctx))];
   const usageSummary = buildUsageSummary(stats);
   const costSummary = buildCostSummary(stats, usesSubscription);
   if (usageSummary) {
@@ -546,8 +561,5 @@ export function buildStatusHtml(
     lines.push(buildStatusRow("Cost", costSummary));
   }
   lines.push(buildStatusRow("Context", buildContextSummary(ctx, activeModel)));
-  if (lines.length === 0) {
-    lines.push(buildStatusRow("Status", "No usage data yet."));
-  }
   return lines.join("\n");
 }

package/lib/turns.ts

@@ -1,5 +1,6 @@
 /**
  * Telegram turn-building helpers
+ * Zones: telegram inbound, pi agent prompt content, queue
  * Owns prompt-turn summary and content construction so queued Telegram turns are assembled consistently
  */