@llblab/pi-telegram 0.8.1 → 0.9.0

package/lib/menu.ts

@@ -118,6 +118,7 @@ export interface TelegramMenuEffectPort<TModel extends MenuModel = MenuModel> {
   updateModelMenuMessage: () => Promise<void>;
   updateThinkingMenuMessage: () => Promise<void>;
   updateStatusMessage: () => Promise<void>;
+  persistScopedModelPatterns?: (patterns: string[]) => Promise<void>;
   setModel: (model: TModel) => Promise<boolean>;
   setCurrentModel: (model: TModel) => void;
   setThinkingLevel: (level: ThinkingLevel) => void;
@@ -188,6 +189,10 @@ export interface TelegramMenuCallbackRuntimeDeps<
     state: TelegramModelMenuState<TModel>,
     ctx: TContext,
   ) => Promise<void>;
+  updateSettingsMenuMessage?: (
+    state: TelegramModelMenuState<TModel>,
+    ctx: TContext,
+  ) => Promise<void>;
   answerCallbackQuery: (
     callbackQueryId: string,
     text?: string,
@@ -196,6 +201,10 @@ export interface TelegramMenuCallbackRuntimeDeps<
   hasActiveTelegramTurn: () => boolean;
   hasAbortHandler: () => boolean;
   hasActiveToolExecutions: () => boolean;
+  persistScopedModelPatterns?: (
+    patterns: string[],
+    ctx: TContext,
+  ) => Promise<void>;
   setModel: (model: TModel) => Promise<boolean>;
   setCurrentModel: (model: TModel, ctx: TContext) => void;
   stagePendingModelSwitch: (
@@ -265,11 +274,21 @@ export interface TelegramMenuActionRuntime<
 
 export type TelegramMenuCallbackAction =
   | { kind: "ignore" }
-  | { kind: "status"; action: "model" | "thinking" | "queue" }
+  | { kind: "status"; action: "model" | "thinking" | "queue" | "settings" }
   | { kind: "thinking:set"; level: string }
   | {
       kind: "model";
-      action: "noop" | "scope" | "page" | "pages" | "pick";
+      action:
+        | "noop"
+        | "scope"
+        | "page"
+        | "pages"
+        | "open"
+        | "pick"
+        | "pick-selected"
+        | "scope-enable"
+        | "scope-disable"
+        | "scope-toggle";
       value?: string;
     };
 
@@ -285,6 +304,9 @@ export function parseTelegramMenuCallbackAction(
   if (data === "menu:queue" || data === "status:queue") {
     return { kind: "status", action: "queue" };
   }
+  if (data === "menu:settings" || data === "status:settings") {
+    return { kind: "status", action: "settings" };
+  }
   if (data?.startsWith("thinking:set:")) {
     return {
       kind: "thinking:set",
@@ -298,7 +320,12 @@ export function parseTelegramMenuCallbackAction(
       action === "scope" ||
       action === "page" ||
       action === "pages" ||
-      action === "pick"
+      action === "open" ||
+      action === "pick" ||
+      action === "pick-selected" ||
+      action === "scope-enable" ||
+      action === "scope-disable" ||
+      action === "scope-toggle"
     ) {
       return { kind: "model", action, value };
     }
@@ -379,6 +406,10 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
     state: TelegramModelMenuState<TModel>,
     ctx: TContext,
   ) => Promise<void>;
+  updateSettingsMenuMessage?: (
+    state: TelegramModelMenuState<TModel>,
+    ctx: TContext,
+  ) => Promise<void>;
   answerCallbackQuery: (
     callbackQueryId: string,
     text?: string,
@@ -387,6 +418,10 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
   hasActiveTelegramTurn: () => boolean;
   hasAbortHandler: () => boolean;
   getActiveToolExecutions: () => number;
+  persistScopedModelPatterns?: (
+    patterns: string[],
+    ctx: TContext,
+  ) => Promise<void>;
   setModel: (model: TModel) => Promise<boolean>;
   setCurrentModel: (model: TModel, ctx: TContext) => void;
   stagePendingModelSwitch: (
@@ -425,11 +460,13 @@ export function createTelegramMenuCallbackHandlerForContext<
     updateModelMenuMessage: deps.updateModelMenuMessage,
     updateThinkingMenuMessage: deps.updateThinkingMenuMessage,
     updateStatusMessage: deps.updateStatusMessage,
+    updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
     answerCallbackQuery: deps.answerCallbackQuery,
     isIdle: deps.isIdle,
     hasActiveTelegramTurn: deps.hasActiveTelegramTurn,
     hasAbortHandler: deps.hasAbortHandler,
     hasActiveToolExecutions: () => deps.getActiveToolExecutions() > 0,
+    persistScopedModelPatterns: deps.persistScopedModelPatterns,
     setModel: deps.setModel,
     setCurrentModel: deps.setCurrentModel,
     stagePendingModelSwitch: deps.stagePendingModelSwitch,
@@ -467,6 +504,8 @@ export async function handleTelegramMenuCallbackRuntime<
           updateModelMenuMessage: () => deps.updateModelMenuMessage(state, ctx),
           updateThinkingMenuMessage: () =>
             deps.updateThinkingMenuMessage(state, ctx),
+          updateSettingsMenuMessage: () =>
+            deps.updateSettingsMenuMessage?.(state, ctx) ?? Promise.resolve(),
           answerCallbackQuery: deps.answerCallbackQuery,
         },
       ),
@@ -504,6 +543,9 @@ export async function handleTelegramMenuCallbackRuntime<
               deps.updateModelMenuMessage(state, ctx),
             updateStatusMessage: () => deps.updateStatusMessage(state, ctx),
             answerCallbackQuery: deps.answerCallbackQuery,
+            persistScopedModelPatterns: deps.persistScopedModelPatterns
+              ? (patterns) => deps.persistScopedModelPatterns!(patterns, ctx)
+              : undefined,
             setModel: deps.setModel,
             setCurrentModel: (model) => deps.setCurrentModel(model, ctx),
             setThinkingLevel: (level) => {

package/lib/pi.ts

@@ -31,7 +31,9 @@ export type {
 
 export interface PiSettingsManager {
   reload: () => Promise<void>;
+  flush: () => Promise<void>;
   getEnabledModels: () => string[] | undefined;
+  setEnabledModels: (patterns: string[] | undefined) => void;
 }
 
 export type PiSlashCommandInfo = SlashCommandInfo;
@@ -70,6 +72,20 @@ export function createSettingsManager(cwd: string): PiSettingsManager {
   return SettingsManager.create(cwd);
 }
 
+export function createScopedModelPatternPersister(deps: {
+  createSettingsManager: (cwd: string) => PiSettingsManager;
+  clearCachedModelMenuInputs: () => void;
+}): (patterns: string[], ctx: ExtensionContext) => Promise<void> {
+  return async function persistScopedModelPatterns(patterns, ctx) {
+    const settingsManager = deps.createSettingsManager(ctx.cwd);
+    settingsManager.setEnabledModels(
+      patterns.length > 0 ? patterns : undefined,
+    );
+    await settingsManager.flush();
+    deps.clearCachedModelMenuInputs();
+  };
+}
+
 export function getExtensionContextModel(
   ctx: ExtensionContext,
 ): ExtensionContext["model"] {

package/lib/preview.ts

@@ -89,6 +89,7 @@ export interface TelegramPreviewRuntimeDeps<
     chunks: TelegramRenderedChunk[],
     options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
+  canSend?: () => boolean;
 }
 
 export interface TelegramPreviewActiveTurn {
@@ -182,6 +183,7 @@ export interface TelegramPreviewControllerDeps<
     chunks: TelegramRenderedChunk[],
     options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<number | undefined>;
+  canSend?: () => boolean;
   throttleMs?: number;
   maxDraftId?: number;
   setTimer?: (
@@ -418,6 +420,7 @@ export function createTelegramPreviewController<
         options,
       ),
     editRenderedMessage: deps.editRenderedMessage,
+    canSend: deps.canSend,
   });
   return {
     getState: () => state,
@@ -574,6 +577,10 @@ async function performTelegramPreviewFlush<
   state: TelegramPreviewRuntimeState,
   deps: TelegramPreviewRuntimeDeps<TReplyMarkup>,
 ): Promise<void> {
+  if (deps.canSend && !deps.canSend()) {
+    await clearTelegramPreview(chatId, deps);
+    return;
+  }
   const snapshot = buildTelegramPreviewSnapshot({
     state,
     maxMessageLength: deps.maxMessageLength,
@@ -658,6 +665,10 @@ export async function finalizeTelegramPreview<
 ): Promise<boolean> {
   const state = deps.getState();
   if (!state) return false;
+  if (deps.canSend && !deps.canSend()) {
+    await clearTelegramPreview(chatId, deps);
+    return false;
+  }
   await flushTelegramPreview(chatId, deps);
   const finalText = buildTelegramPreviewFinalText(state);
   if (!finalText) {
@@ -683,6 +694,10 @@ export async function finalizeTelegramMarkdownPreview<
 ): Promise<boolean> {
   const state = deps.getState();
   if (!state) return false;
+  if (deps.canSend && !deps.canSend()) {
+    await clearTelegramPreview(chatId, deps);
+    return false;
+  }
   await flushTelegramPreview(chatId, deps);
   const chunks = deps.renderTelegramMessage(markdown, { mode: "markdown" });
   if (chunks.length === 0) {

package/lib/prompts.ts

@@ -18,7 +18,9 @@ Inbound context:
 - Unknown \`[callback] ...\` messages may be intended for another extension; if you see one, say the callback was not handled and the environment may be misconfigured.
 
 Telegram-visible output:
-- Telegram is often phone-width; prefer narrow table columns because wide monospace tables can become unreadable.
+- Telegram is often phone-width; keep tables, dense list items, and compact text blocks at or below 37 visible cells when possible.
+- Count display width, not raw characters: emoji and some glyphs are wide, so prefer shorter labels when unsure.
+- Wide monospace blocks can become unreadable on mobile; use them only when structure or literal code requires them.
 - For requested/generated files, call tool \`telegram_attach(local_path)\`; mentioning a local path in text does not send it.
 
 Native outbound actions:
@@ -55,3 +57,24 @@ export function createTelegramBeforeAgentStartHook(
       systemPromptSuffix: options.systemPromptSuffix ?? SYSTEM_PROMPT_SUFFIX,
     });
 }
+
+export interface TelegramProactivePromptHookDeps<TContext> {
+  baseHook?: (event: BeforeAgentStartEvent) => { systemPrompt: string };
+  isProactivePushEnabled: () => boolean;
+  isCurrentOwner: (ctx: TContext) => boolean;
+}
+
+export function createTelegramProactiveBeforeAgentStartHook<TContext>(
+  deps: TelegramProactivePromptHookDeps<TContext>,
+): (
+  event: BeforeAgentStartEvent,
+  ctx: TContext,
+) => Promise<{ systemPrompt: string }> {
+  const baseHook = deps.baseHook ?? createTelegramBeforeAgentStartHook();
+  return async function onBeforeAgentStart(event, ctx) {
+    const result = baseHook(event);
+    if (!deps.isProactivePushEnabled()) return result;
+    if (!deps.isCurrentOwner(ctx)) return result;
+    return result;
+  };
+}

package/lib/queue.ts

@@ -357,7 +357,7 @@ function formatTelegramQueueItemStatusSummary<TContext = unknown>(
   item: TelegramQueueItem<TContext>,
 ): string {
   if (item.queueLane === "priority") {
-    return `${item.kind === "prompt" ? item.priorityEmoji ?? "⚡" : "⚡"} ${item.statusSummary}`;
+    return `${item.kind === "prompt" ? (item.priorityEmoji ?? "⚡") : "⚡"} ${item.statusSummary}`;
   }
   return item.statusSummary;
 }
@@ -365,15 +365,7 @@ function formatTelegramQueueItemStatusSummary<TContext = unknown>(
 export function formatQueuedTelegramItemsStatus<TContext = unknown>(
   items: TelegramQueueItem<TContext>[],
 ): string {
-  if (items.length === 0) return "";
-  const previewCount = 4;
-  const summaries = items
-    .slice(0, previewCount)
-    .map(formatTelegramQueueItemStatusSummary)
-    .filter(Boolean);
-  if (summaries.length === 0) return ` +${items.length}`;
-  const suffix = items.length > summaries.length ? ", …" : "";
-  return ` +${items.length}: [${summaries.join(", ")}${suffix}]`;
+  return items.length === 0 ? "" : ` +${items.length}`;
 }
 
 export function canDispatchTelegramTurnState(
@@ -771,6 +763,7 @@ export interface TelegramAgentEndRuntimeDeps<
   preserveQueuedTurnsAsHistory: boolean;
   resetRuntimeState: () => void;
   updateStatus: () => void;
+  isCurrentOwner?: () => boolean;
   dispatchNextQueuedTelegramTurn: () => void;
   clearPreview: (chatId: number) => Promise<void>;
   setPreviewPendingText: (text: string) => void;
@@ -782,7 +775,7 @@ export interface TelegramAgentEndRuntimeDeps<
   ) => Promise<boolean>;
   sendMarkdownReply: (
     chatId: number,
-    replyToMessageId: number,
+    replyToMessageId: number | undefined,
     markdown: string,
     options?: { replyMarkup?: TReplyMarkup },
   ) => Promise<unknown>;
@@ -800,6 +793,14 @@ export interface TelegramAgentEndRuntimeDeps<
     plan: TelegramAgentEndOutboundReplyPlan,
     options?: { replyToPrompt?: boolean },
   ) => Promise<void>;
+  getDefaultChatId?: () => number | undefined;
+  consumeProactiveReplyToMessageId?: (chatId: number) => number | undefined;
+  isProactivePushEnabled?: () => boolean;
+  recordRuntimeEvent?: (
+    category: string,
+    error: unknown,
+    details?: Record<string, unknown>,
+  ) => void;
 }
 
 export interface TelegramAgentEndHookRuntimeDeps<
@@ -815,6 +816,7 @@ export interface TelegramAgentEndHookRuntimeDeps<
   getPreserveQueuedTurnsAsHistory: () => boolean;
   resetRuntimeState: () => void;
   updateStatus: (ctx: TContext) => void;
+  isCurrentOwner?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   requestDeferredDispatchNextQueuedTelegramTurn: (
     dispatch: (ctx: TContext) => void,
@@ -836,6 +838,10 @@ export interface TelegramAgentEndHookRuntimeDeps<
     TReplyMarkup
   >["planOutboundReply"];
   sendOutboundReplyArtifacts?: TelegramAgentEndRuntimeDeps<TTurn>["sendOutboundReplyArtifacts"];
+  getDefaultChatId?: TelegramAgentEndRuntimeDeps<TTurn>["getDefaultChatId"];
+  consumeProactiveReplyToMessageId?: TelegramAgentEndRuntimeDeps<TTurn>["consumeProactiveReplyToMessageId"];
+  isProactivePushEnabled?: TelegramAgentEndRuntimeDeps<TTurn>["isProactivePushEnabled"];
+  recordRuntimeEvent?: TelegramAgentEndRuntimeDeps<TTurn>["recordRuntimeEvent"];
 }
 
 export interface TelegramAgentEndHookEvent<TMessage> {
@@ -926,12 +932,17 @@ export function createTelegramAgentEndHook<
     ctx: TContext,
   ): Promise<void> {
     const turn = deps.getActiveTurn();
+    const proactiveEnabled = deps.isProactivePushEnabled?.() ?? false;
     await handleTelegramAgentEndRuntime({
       turn,
-      assistant: turn ? deps.extractAssistant(event.messages) : {},
+      assistant:
+        turn || proactiveEnabled ? deps.extractAssistant(event.messages) : {},
       preserveQueuedTurnsAsHistory: deps.getPreserveQueuedTurnsAsHistory(),
       resetRuntimeState: deps.resetRuntimeState,
       updateStatus: () => deps.updateStatus(ctx),
+      isCurrentOwner: deps.isCurrentOwner
+        ? () => deps.isCurrentOwner?.(ctx) ?? false
+        : undefined,
       dispatchNextQueuedTelegramTurn: () => {
         deps.requestDeferredDispatchNextQueuedTelegramTurn(
           deps.dispatchNextQueuedTelegramTurn,
@@ -945,6 +956,10 @@ export function createTelegramAgentEndHook<
       sendQueuedAttachments: deps.sendQueuedAttachments,
       planOutboundReply: deps.planOutboundReply,
       sendOutboundReplyArtifacts: deps.sendOutboundReplyArtifacts,
+      getDefaultChatId: deps.getDefaultChatId,
+      consumeProactiveReplyToMessageId: deps.consumeProactiveReplyToMessageId,
+      isProactivePushEnabled: deps.isProactivePushEnabled,
+      recordRuntimeEvent: deps.recordRuntimeEvent,
     });
   };
 }
@@ -964,6 +979,10 @@ export async function handleTelegramAgentEndRuntime<
   const replyMarkup = outboundReply?.replyMarkup;
   deps.resetRuntimeState();
   deps.updateStatus();
+  if (deps.isCurrentOwner && !deps.isCurrentOwner()) {
+    if (turn) await deps.clearPreview(turn.chatId);
+    return;
+  }
   const endPlan = buildTelegramAgentEndPlan({
     hasTurn: !!turn,
     stopReason: assistant.stopReason,
@@ -972,6 +991,28 @@ export async function handleTelegramAgentEndRuntime<
     preserveQueuedTurnsAsHistory: deps.preserveQueuedTurnsAsHistory,
   });
   if (!turn) {
+    if (
+      deps.isProactivePushEnabled?.() &&
+      finalText &&
+      !assistant.errorMessage
+    ) {
+      const defaultChatId = deps.getDefaultChatId?.();
+      if (defaultChatId !== undefined) {
+        const replyToMessageId =
+          deps.consumeProactiveReplyToMessageId?.(defaultChatId);
+        try {
+          await deps.sendMarkdownReply(
+            defaultChatId,
+            replyToMessageId,
+            finalText,
+          );
+        } catch (error) {
+          deps.recordRuntimeEvent?.("proactive-push", error, {
+            chatId: defaultChatId,
+          });
+        }
+      }
+    }
     if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
     return;
   }

package/lib/routing.ts

@@ -50,11 +50,24 @@ export interface TelegramInboundRouteRuntimeDeps<
     Model.ScopedTelegramModel<TModel>
   >;
   menuActions: Menu.TelegramMenuActionRuntime<TContext, TModel>;
+  updateSettingsMenuMessage?: (
+    state: Menu.TelegramModelMenuState<TModel>,
+    ctx: TContext,
+  ) => Promise<void>;
   openQueueMenu: (
     chatId: number,
     replyToMessageId: number,
     ctx: TContext,
   ) => Promise<void>;
+  openSettingsMenu?: (
+    chatId: number,
+    replyToMessageId: number,
+    ctx: TContext,
+  ) => Promise<void>;
+  settingsMenuCallbackHandler?: (
+    query: TCallbackQuery,
+    ctx: TContext,
+  ) => Promise<boolean>;
   queueMenuCallbackHandler: (
     query: TCallbackQuery,
     ctx: TContext,
@@ -79,6 +92,10 @@ export interface TelegramInboundRouteRuntimeDeps<
   downloadFile: Media.DownloadTelegramMessageFilesDeps["downloadFile"];
   getThinkingLevel: () => Model.ThinkingLevel;
   setThinkingLevel: (level: Model.ThinkingLevel) => void;
+  persistScopedModelPatterns?: (
+    patterns: string[],
+    ctx: TContext,
+  ) => Promise<void>;
   setModel: (model: TModel) => Promise<boolean>;
   sendUserMessage?: (message: string) => void;
   isIdle: (ctx: TContext) => boolean;
@@ -98,6 +115,7 @@ const TELEGRAM_OWNED_CALLBACK_PREFIXES = [
   "menu:",
   "model:",
   "queue:",
+  "settings:",
   "status:",
   "tgbtn:",
   "thinking:",
@@ -140,12 +158,14 @@ export function createTelegramInboundRouteRuntime<
     updateModelMenuMessage: deps.menuActions.updateModelMenuMessage,
     updateThinkingMenuMessage: deps.menuActions.updateThinkingMenuMessage,
     updateStatusMessage: deps.menuActions.updateStatusMessage,
+    updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
     answerCallbackQuery: deps.answerCallbackQuery,
     isIdle: deps.isIdle,
     hasActiveTelegramTurn: deps.activeTurnRuntime.has,
     hasAbortHandler: deps.bridgeRuntime.abort.hasHandler,
     getActiveToolExecutions:
       deps.bridgeRuntime.lifecycle.getActiveToolExecutions,
+    persistScopedModelPatterns: deps.persistScopedModelPatterns,
     setModel: deps.setModel,
     setCurrentModel: deps.currentModelRuntime.setCurrentModel,
     stagePendingModelSwitch: deps.modelSwitchController.stagePendingSwitch,
@@ -187,6 +207,11 @@ export function createTelegramInboundRouteRuntime<
     }
     const handledByQueue = await deps.queueMenuCallbackHandler(query, ctx);
     if (handledByQueue) return;
+    const handledBySettings = await deps.settingsMenuCallbackHandler?.(
+      query,
+      ctx,
+    );
+    if (handledBySettings) return;
     const callbackData = query.data;
     if (
       deps.sendUserMessage &&
@@ -279,6 +304,7 @@ export function createTelegramInboundRouteRuntime<
       const chatId = (message as { chat: { id: number } }).chat.id;
       return deps.openQueueMenu(chatId, message.message_id, ctx);
     },
+    openSettingsMenu: deps.openSettingsMenu,
     getAllowedUserId: deps.configStore.getAllowedUserId,
     setAllowedUserId: deps.configStore.setAllowedUserId,
     setMyCommands: deps.setMyCommands,

package/lib/status.ts

@@ -44,6 +44,7 @@ export interface TelegramStatusContext {
   getContextUsage(): TelegramContextUsage | undefined;
   isIdle?: () => boolean;
   hasPendingMessages?: () => boolean;
+  isCompactionInProgress?: () => boolean;
   modelRegistry: {
     isUsingOAuth(model: TelegramStatusActiveModel): boolean;
   };
@@ -303,8 +304,13 @@ export function buildTelegramRuntimeEventLines(
 
 export function createTelegramStatusHtmlBuilder<TContext>(deps: {
   getActiveModel: (ctx: TContext) => TelegramStatusActiveModel | undefined;
+  isCompactionInProgress?: () => boolean;
 }): (ctx: TContext & TelegramStatusContext) => string {
-  return (ctx) => buildStatusHtml(ctx, deps.getActiveModel(ctx));
+  return (ctx) =>
+    buildStatusHtml(
+      { ...ctx, isCompactionInProgress: deps.isCompactionInProgress },
+      deps.getActiveModel(ctx),
+    );
 }
 
 export function createTelegramStatusRuntime<
@@ -348,7 +354,11 @@ export function createTelegramBridgeStatusRuntime<
         paired: !!config.allowedUserId,
         compactionInProgress,
         processing:
-          hasActiveTurn || hasPendingDispatch || queuedItems.length > 0,
+          hasActiveTurn ||
+          hasPendingDispatch ||
+          hasPendingModelSwitch ||
+          activeToolExecutions > 0 ||
+          queuedItems.length > 0,
         processingStatus: getTelegramStatusBarProcessingStatus({
           hasActiveTurn,
           hasPendingDispatch,
@@ -388,8 +398,9 @@ export function getTelegramStatusBarProcessingStatus(state: {
   queuedItems: number;
 }): string | undefined {
   if (state.hasPendingModelSwitch) return "model";
-  if (state.activeToolExecutions > 0) return "tool running";
-  if (state.hasActiveTurn) return "active";
+  if (state.hasActiveTurn && state.activeToolExecutions > 0)
+    return "tool running";
+  if (state.hasActiveTurn || state.activeToolExecutions > 0) return "active";
   if (state.hasPendingDispatch) return "dispatching";
   if (state.queuedItems > 0) return "queued";
   return undefined;
@@ -410,13 +421,15 @@ export function buildTelegramStatusBarText(
   if (!state.paired)
     return `${label} ${theme.fg("warning", "awaiting pairing")}`;
   const queued = state.queuedStatus
-    ? theme.fg("muted", state.queuedStatus)
+    ? theme.fg("success", state.queuedStatus)
     : "";
   if (state.compactionInProgress) {
     return `${label} ${theme.fg("accent", "compacting")}${queued}`;
   }
   if (state.processing) {
-    const processingStatus = state.processingStatus ?? "processing";
+    const processingStatus = state.queuedStatus
+      ? "active"
+      : (state.processingStatus ?? "processing");
     const processingToken =
       processingStatus === "active" ? "warning" : "accent";
     return `${label} ${theme.fg(processingToken, processingStatus)}${queued}`;
@@ -537,6 +550,7 @@ function buildContextSummary(
 }
 
 function buildStatusSummary(ctx: TelegramStatusContext): string {
+  if (ctx.isCompactionInProgress?.()) return "compacting";
   if (ctx.hasPendingMessages?.()) return "pending";
   if (ctx.isIdle?.() === false) return "active";
   if (ctx.isIdle?.() === true) return "idle";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "private": false,
   "description": "Better Telegram DM bridge extension for π",
   "type": "module",