@llblab/pi-telegram 0.33.0 → 0.33.1

package/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.33.1: Rendered Command Replies And Visible Compaction
+
+- `Command Rendering`: Restored the `/next` empty-queue emphasis by preserving its HTML source and forwarding `parseMode: "HTML"` through the command reply adapter, so command helpers select the renderer explicitly instead of leaking HTML or Markdown syntax as plain text.
+- `Compaction Visibility`: Reports `compacting` ahead of generic active or pending status and sends the same start/completion notices for observed automatic compaction as for manually requested compaction, while retaining queue blocking and deferred dispatch.
+
 ## 0.33.0: Matrix Controls And Pinned Filesystem Navigation
 
 - `Button Matrix`: Extended `telegram_button` and its plural alias from flat arrays to JSON matrices: top-level objects remain full-width rows, while nested arrays intentionally group one to three peer controls horizontally; empty, oversized, or deeper rows fail closed without changing existing object, attribute, or flat-array behavior.

package/docs/architecture.md

@@ -352,7 +352,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. 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. 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 reactions are reversible shortcut controls for waiting turns. The runtime reconciles each complete `MessageReactionUpdated.new_reaction` set: any removal reaction (`👎`, `👻`, `💔`, `💩`, `🗑`) suppresses the governed prompt without discarding its queue authority; otherwise any promotion reaction (`👍`, `⚡️`, `❤️`, `🕊`, `🔥`) moves it to priority; otherwise it returns to the default lane. Suppressed prompts remain visible in the queue menu, survive authenticated queue handoff, and do not block unrelated dispatch. Reaction changes first flush a matching delayed text or media group so the governed turn exists before mutation. Once Pi has consumed a prompt, reactions cannot retract it.
 

package/lib/bindings.ts

@@ -860,6 +860,21 @@ export function registerTelegramLifecycleRuntimeHooks({
       target: turn?.target,
     });
   };
+  let observedAutomaticCompaction = false;
+  const sendCompactionNotice = async (text: string): Promise<void> => {
+    const turn = activeTurnRuntime.get();
+    const target = turn?.target ?? proactivePushTargetGetter?.();
+    if (!target) return;
+    try {
+      await sendMarkdownReply(target.chatId, turn?.replyToMessageId, text, {
+        target,
+      });
+    } catch (error) {
+      recordRuntimeEvent("delivery", error, {
+        phase: "compaction-notice",
+      });
+    }
+  };
   const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
     isContextActive: isSessionContextActive,
     setCompactionInProgress: lifecycle.setCompactionInProgress,
@@ -870,7 +885,10 @@ export function registerTelegramLifecycleRuntimeHooks({
       deferredQueueDispatchRuntime.request,
     dispatchNextQueuedTelegramTurn,
     recordRuntimeEvent,
-    onCompactionAbandoned: activityRuntime.onCompactionAbandoned,
+    onCompactionAbandoned: () => {
+      observedAutomaticCompaction = false;
+      activityRuntime.onCompactionAbandoned();
+    },
   });
   const messageActivityTypingHooks =
     Lifecycle.createTelegramMessageActivityTypingHooks({
@@ -902,6 +920,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.onSessionShutdown();
       activityVerbosityRuntime?.reset();
       assistantOutputRuntime.stop();
+      observedAutomaticCompaction = false;
       compactionObserver.onSessionShutdown();
       if (event.reason === "quit" && disconnectOnQuit) {
         try {
@@ -916,15 +935,24 @@ export function registerTelegramLifecycleRuntimeHooks({
       }
       await sessionLifecycleRuntime.onSessionShutdown(event, ctx);
     },
-    onSessionBeforeCompact(event, ctx) {
+    async onSessionBeforeCompact(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
+      const shouldNotify = !(lifecycle.isCompactionInProgress?.() ?? false);
+      if (shouldNotify) observedAutomaticCompaction = true;
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
+      if (shouldNotify) {
+        await sendCompactionNotice(Commands.TELEGRAM_COMPACTION_STARTED_TEXT);
+      }
     },
-    onSessionCompact(event, ctx) {
+    async onSessionCompact(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       activityRuntime.onCompactionEnd(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionCompact(event, ctx);
+      if (observedAutomaticCompaction) {
+        observedAutomaticCompaction = false;
+        await sendCompactionNotice(Commands.TELEGRAM_COMPACTION_COMPLETED_TEXT);
+      }
     },
     async onAgentStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;

package/lib/commands.ts

@@ -185,6 +185,10 @@ export function formatTelegramCommandEmojiPrefix(
   return `${getTelegramCommandEmoji(command)} `;
 }
 
+export const TELEGRAM_COMPACTION_STARTED_TEXT =
+  `${formatTelegramCommandEmojiPrefix("compact")}Compaction started.`;
+export const TELEGRAM_COMPACTION_COMPLETED_TEXT = "✅ Compaction completed.";
+
 function formatTelegramBotCommandDescription(
   command: TelegramCommandEmojiName,
   description: string,
@@ -716,7 +720,10 @@ export interface TelegramCommandTargetRuntimeDeps<TContext> {
     chatId: number,
     replyToMessageId: number,
     text: string,
-    options?: { target?: { chatId: number; threadId?: number } },
+    options?: {
+      parseMode?: "HTML";
+      target?: { chatId: number; threadId?: number };
+    },
   ) => Promise<unknown>;
 }
 
@@ -734,7 +741,11 @@ export interface TelegramCommandTargetRuntime<
   showStatus: (message: TMessage, ctx: TContext) => Promise<void>;
   openModelMenu: (message: TMessage, ctx: TContext) => Promise<void>;
   openSettingsMenu: (message: TMessage, ctx: TContext) => Promise<void>;
-  sendTextReply: (message: TMessage, text: string) => Promise<void>;
+  sendTextReply: (
+    message: TMessage,
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
 }
 
 export function getTelegramCommandMessageTarget(
@@ -917,9 +928,10 @@ export function createTelegramCommandTargetRuntime<
         target.threadId,
       );
     },
-    sendTextReply: async (message, text) => {
+    sendTextReply: async (message, text, options) => {
       const target = getTelegramCommandMessageTarget(message);
       await deps.sendTextReply(target.chatId, target.replyToMessageId, text, {
+        ...options,
         target,
       });
     },
@@ -1002,7 +1014,11 @@ export interface TelegramCommandRuntimeDeps<
   registerBotCommands: () => Promise<void>;
   getPromptTemplateCommands?: () => readonly TelegramPromptTemplateMenuCommand[];
   persistConfig: () => Promise<void>;
-  sendTextReply: (message: TMessage, text: string) => Promise<void>;
+  sendTextReply: (
+    message: TMessage,
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
   sendInteractiveMessage?: TelegramCompactConfirmationDeps["sendInteractiveMessage"];
   assertExecutionCurrent?: (message: TMessage) => void;
 }
@@ -1185,11 +1201,14 @@ export async function handleTelegramNextCommand(deps: {
   dispatchNextQueuedTurn: () => void;
   clearFoldForDispatch: () => void;
   updateStatus: () => void;
-  sendTextReply: (text: string) => Promise<void>;
+  sendTextReply: (
+    text: string,
+    options?: { parseMode?: "HTML" },
+  ) => Promise<void>;
 }): Promise<void> {
   deps.clearPendingModelSwitch();
   if (!deps.hasQueuedItems()) {
-    await deps.sendTextReply("**Queue is empty.**");
+    await deps.sendTextReply("<b>Queue is empty.</b>", { parseMode: "HTML" });
     return;
   }
   if (!deps.isIdle() && deps.hasAbortHandler()) {
@@ -1294,7 +1313,7 @@ export async function handleTelegramCompactConfirmationCallback<TContext>(
   await deps.editInteractiveMessage(
     chatId,
     messageId,
-    `${formatTelegramCommandEmojiPrefix("compact")}Compaction started.`,
+    TELEGRAM_COMPACTION_STARTED_TEXT,
     "plain",
     { inline_keyboard: [] },
   );
@@ -1335,7 +1354,7 @@ export async function handleTelegramCompactCommand(
         deps.setCompactionInProgress(false);
         deps.updateStatus();
         dispatchNextQueuedTelegramTurnAfterCompact(deps);
-        void deps.sendTextReply("✅ Compaction completed.");
+        void deps.sendTextReply(TELEGRAM_COMPACTION_COMPLETED_TEXT);
       },
       onError: (error) => {
         deps.stopTypingLoop?.();
@@ -1358,7 +1377,7 @@ export async function handleTelegramCompactCommand(
   }
   if (!deps.suppressStartNotice) {
     await deps.sendTextReply(
-      `${formatTelegramCommandEmojiPrefix("compact")}Compaction started.`,
+      TELEGRAM_COMPACTION_STARTED_TEXT,
     );
   }
 }
@@ -1631,11 +1650,13 @@ async function handleTelegramCommandRuntime<
 ): Promise<boolean> {
   const assertExecutionCurrentFor = (nextMessage: TMessage) => (): void =>
     deps.assertExecutionCurrent?.(nextMessage);
-  const sendReplyFor = (nextMessage: TMessage) => async (text: string) => {
-    deps.assertExecutionCurrent?.(nextMessage);
-    await deps.sendTextReply(nextMessage, text);
-    deps.assertExecutionCurrent?.(nextMessage);
-  };
+  const sendReplyFor =
+    (nextMessage: TMessage) =>
+    async (text: string, options?: { parseMode?: "HTML" }) => {
+      deps.assertExecutionCurrent?.(nextMessage);
+      await deps.sendTextReply(nextMessage, text, options);
+      deps.assertExecutionCurrent?.(nextMessage);
+    };
   const updateStatusFor = (commandCtx: TContext) => () =>
     deps.updateStatus(commandCtx);
   return executeTelegramCommandAction(

package/lib/status.ts

@@ -1505,6 +1505,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.33.0",
+  "version": "0.33.1",
   "private": false,
   "publishConfig": {
     "access": "public"