@llblab/pi-telegram 0.10.6 → 0.10.8

package/AGENTS.md

@@ -57,6 +57,7 @@
 - The bridge is session-local, paired to one allowed Telegram user, and owns a local queue aligned with π lifecycle hooks
 - Queue admission is explicit and validated: immediate commands, control lane, priority lane, and default lane must preserve allowed kind/lane pairings
 - Dispatch is gated by active turns, pending dispatch, unsettled control work, compaction, `ctx.isIdle()`, and π pending messages; dispatched prompts remain queued until `agent_start` consumes them
+- Telegram `/compact` owns a native `typing` keepalive for the compaction window so phone clients show activity between the started/completed notices; stop it on both completion and failure
 - `/stop`, `/abort`, `/next`, and `/continue` have distinct contracts: reset queue and abort; abort while preserving queue; force next queued turn; enqueue a priority `continue` prompt
 - `/start`, `/help`, and `/status` open the unified command-help/status-row/control menu; `/model`, `/thinking`, and `/queue` jump to sections directly; visible bot commands are `/start`, `/compact`, `/next`, `/continue`, `/abort`, `/stop`
 - Command/menu emoji are fixed UI adornments owned by the `commands` map; do not add a persisted emoji toggle or Settings menu until there is a real setting to own

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.10.8: Compact Typing Timing Hotfix
+
+- `[Compaction]` Telegram `/compact` now starts the native `typing` chat-action keepalive after the "Compaction started" notice is sent, then stops it on completion or failure. Impact: operators see the same Telegram activity indicator during context compression that they already see during normal agent/tool work, without showing `typing` before the explicit start confirmation arrives.
+
+## 0.10.7: Stale Context Hardening Hotfix
+
+- `[Session Reloads]` Context-sensitive command, pairing, queue, session-start, and update-dispatch paths now ignore only stale-session/stale-context failures instead of swallowing broad runtime errors. Impact: the bridge survives ctx replacement/fork/reload races while real bugs still surface for diagnostics.
+- `[Runtime Status]` Restored status update error propagation so existing polling/dispatch safety wrappers can record stale status failures as structured runtime events instead of losing diagnostics inside the status domain.
+- `[Release]` Added a tag-triggered GitHub Actions release workflow that verifies the `vX.Y.Z` tag matches `package.json`, extracts the matching `CHANGELOG.md` section, and publishes a GitHub Release automatically.
+- `[Tests]` Added focused regressions proving the newly guarded call sites tolerate stale context errors and still rethrow unrelated failures.
+
 ## 0.10.6: Native Typing Keepalive Hotfix
 
 - `[Typing]` Telegram native `typing` chat actions now refresh every 2.5s instead of every 4s. Impact: the bot's Telegram-side typing animation has more headroom to stay visible during model retries, transient model/API errors, and other long-running agent work.

package/README.md

@@ -85,7 +85,7 @@ What it feels like:
 Use these inside the Telegram DM with your bot. The main entrypoint is `/start`: it opens the operator menu and exposes many of the important agent controls that normally live in the CLI, adapted for Telegram.
 
 - **`/start`**: Pair the first Telegram user when needed, register bot commands, and open the inline application menu with command help, prompt-template commands, status rows, model controls, thinking controls, settings, and queue controls.
-- **`/compact`**: Start session compaction when the session is idle.
+- **`/compact`**: Start session compaction when the session is idle; Telegram shows the native typing indicator while compaction is running.
 - **`/next`**: Dispatch the next queued turn, aborting π first if needed.
 - **`/continue`**: Enqueue a priority `continue` prompt.
 - **`/abort`**: Abort the active run without touching the queue.

package/docs/architecture.md

@@ -114,7 +114,7 @@ Dispatch is gated by:
 
 This prevents queue races around rapid follow-ups, `/compact`, and mixed local plus Telegram activity. Post-agent-end dispatch retries are scheduled through a session-bound deferred dispatcher that activates on session start, cancels timers on session shutdown, and skips callbacks from older generations before they touch `ExtensionContext`. Telegram `/start` and hidden compatibility shortcuts `/status`, `/model`, `/thinking`, `/queue`, and `/settings` execute immediately; the dispatch controller still serializes any deferred control items so a queued control action must settle before the next queued action can dispatch.
 
-`/start` opens the main application menu: visible command help, compact command-only prompt-template rows when π exposes Telegram-compatible prompt-template names, status rows (`Status`, `Usage`, `Cost`, `Context`), and top-level buttons for model, thinking, and queue sections. The `Status` row reports `compacting` while a Telegram `/compact` run is active. The Queue button includes the current queued-item count. Hidden compatibility shortcuts `/help`, `/status`, `/model`, `/thinking`, and `/queue` jump directly to their corresponding menu screens, while `/settings` opens the hidden settings menu for bridge toggles such as proactive push. Settings options open detail submenus; checkbox-like settings use Back plus green/black/yellow On and Off controls instead of mutating directly from the list. Command emoji come from the `commands` domain map so visible command descriptions and matching menu buttons share one fixed adornment source. Prompt-template commands use a fixed `🧩` marker, map π template names to Telegram-safe aliases such as `fix-tests` → `/fix_tests`, stay visible only inside the `/start` menu, and expand before queueing because `ExtensionAPI.sendUserMessage()` intentionally bypasses π prompt-template expansion for extension-originated messages. Every submenu starts with a top Back row so navigation stays anchored near the original user message above the inline keyboard; model-menu pagination controls sit near the top, tapping the pagination indicator opens a compact page picker headed by `<b>Choose a page:</b>`, and tapping a model opens a detail submenu with Back, ☑️ Activate/🟢 Active selection, and yellow/black-marked Scoped/All membership tabs. `menu-model` owns model-menu state, scoped model pages, model detail rendering, scoped-list persistence planning, and model-menu rendering while `model` owns core model identity/switching semantics. `menu-thinking` owns thinking-menu text, reply markup, callback handling, and message rendering. `menu-status` owns status-menu payloads, status callback handling, and status-message rendering. `menu-queue` owns queue-menu UI only: queue items are rendered under a compact `<b>Queue:</b>` heading, top-to-bottom in dispatch order, numbered, and marked with `⚡` for priority prompts or `📎` for prompts with attachments. An empty queue renders bold message text with the bottom-filled `⌛` hourglass plus the top Main menu button, while non-empty queue states keep the running `⏳` hourglass. Selecting an item opens a submenu that displays the queue item number above the full queued prompt text with Back, side-by-side Priority/Normal tabs, and Cancel. If a callback targets an item that has already left the queue, the menu refreshes the list instead of applying a stale mutation.
+`/start` opens the main application menu: visible command help, compact command-only prompt-template rows when π exposes Telegram-compatible prompt-template names, status rows (`Status`, `Usage`, `Cost`, `Context`), and top-level buttons for model, thinking, and queue sections. The `Status` row reports `compacting` while a Telegram `/compact` run is active, and the bridge sends Telegram's native `typing` chat action as a keepalive for the same compaction window. The Queue button includes the current queued-item count. Hidden compatibility shortcuts `/help`, `/status`, `/model`, `/thinking`, and `/queue` jump directly to their corresponding menu screens, while `/settings` opens the hidden settings menu for bridge toggles such as proactive push. Settings options open detail submenus; checkbox-like settings use Back plus green/black/yellow On and Off controls instead of mutating directly from the list. Command emoji come from the `commands` domain map so visible command descriptions and matching menu buttons share one fixed adornment source. Prompt-template commands use a fixed `🧩` marker, map π template names to Telegram-safe aliases such as `fix-tests` → `/fix_tests`, stay visible only inside the `/start` menu, and expand before queueing because `ExtensionAPI.sendUserMessage()` intentionally bypasses π prompt-template expansion for extension-originated messages. Every submenu starts with a top Back row so navigation stays anchored near the original user message above the inline keyboard; model-menu pagination controls sit near the top, tapping the pagination indicator opens a compact page picker headed by `<b>Choose a page:</b>`, and tapping a model opens a detail submenu with Back, ☑️ Activate/🟢 Active selection, and yellow/black-marked Scoped/All membership tabs. `menu-model` owns model-menu state, scoped model pages, model detail rendering, scoped-list persistence planning, and model-menu rendering while `model` owns core model identity/switching semantics. `menu-thinking` owns thinking-menu text, reply markup, callback handling, and message rendering. `menu-status` owns status-menu payloads, status callback handling, and status-message rendering. `menu-queue` owns queue-menu UI only: queue items are rendered under a compact `<b>Queue:</b>` heading, top-to-bottom in dispatch order, numbered, and marked with `⚡` for priority prompts or `📎` for prompts with attachments. An empty queue renders bold message text with the bottom-filled `⌛` hourglass plus the top Main menu button, while non-empty queue states keep the running `⏳` hourglass. Selecting an item opens a submenu that displays the queue item number above the full queued prompt text with Back, side-by-side Priority/Normal tabs, and Cancel. If a callback targets an item that has already left the queue, the menu refreshes the list instead of applying a stale mutation.
 
 ### Abort Behavior
 

package/index.ts

@@ -354,6 +354,8 @@ export default function (pi: Pi.ExtensionAPI) {
     dispatchNextQueuedTelegramTurn,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deferredQueueDispatchRuntime.request,
+    startTypingLoop: promptDispatchRuntime.startTypingLoop,
+    stopTypingLoop: typing.stop,
     answerCallbackQuery,
     editInteractiveMessage,
     sendInteractiveMessage,

package/lib/commands.ts

@@ -320,6 +320,8 @@ export interface TelegramCompactCommandDeps extends TelegramRuntimeEventRecorder
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: () => void,
   ) => void;
+  startTypingLoop?: () => void;
+  stopTypingLoop?: () => void;
   compact: (callbacks: {
     onComplete: () => void;
     onError: (error: unknown) => void;
@@ -553,6 +555,8 @@ export interface TelegramCommandRuntimeDeps<
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
+  startTypingLoop?: (ctx: TContext, chatId?: number) => void;
+  stopTypingLoop?: () => void;
   enqueueContinueTurn: (message: TMessage, ctx: TContext) => Promise<void>;
   compact: (
     ctx: TContext,
@@ -579,7 +583,7 @@ export interface TelegramCommandRuntimeDeps<
 }
 
 export const TELEGRAM_APP_MENU_INTRO_HTML = [
-  "<b>π Telegram bridge</b>",
+  "<b>π Telegram</b>",
   "",
   `${formatTelegramCommandEmojiPrefix("start")}/start — Open menu / Pair bridge`,
   `${formatTelegramCommandEmojiPrefix("compact")}/compact — Compact current session`,
@@ -798,15 +802,20 @@ export async function handleTelegramCompactCommand(
   }
   deps.setCompactionInProgress(true);
   deps.updateStatus();
+  let compactionStillInProgress = true;
   try {
     deps.compact({
       onComplete: () => {
+        compactionStillInProgress = false;
+        deps.stopTypingLoop?.();
         deps.setCompactionInProgress(false);
         deps.updateStatus();
         dispatchNextQueuedTelegramTurnAfterCompact(deps);
         void deps.sendTextReply("Compaction completed.");
       },
       onError: (error) => {
+        compactionStillInProgress = false;
+        deps.stopTypingLoop?.();
         deps.setCompactionInProgress(false);
         deps.updateStatus();
         dispatchNextQueuedTelegramTurnAfterCompact(deps);
@@ -816,6 +825,8 @@ export async function handleTelegramCompactCommand(
       },
     });
   } catch (error) {
+    compactionStillInProgress = false;
+    deps.stopTypingLoop?.();
     deps.setCompactionInProgress(false);
     deps.updateStatus();
     deps.recordRuntimeEvent?.("compact", error);
@@ -824,20 +835,37 @@ export async function handleTelegramCompactCommand(
     return;
   }
   await deps.sendTextReply("Compaction started.");
+  if (compactionStillInProgress) deps.startTypingLoop?.();
+}
+
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
 }
 
 export async function handleTelegramStatusCommand<TContext>(deps: {
   ctx: TContext;
   showStatus: (ctx: TContext) => Promise<void>;
 }): Promise<void> {
-  await deps.showStatus(deps.ctx);
+  try {
+    await deps.showStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
 }
 
 export async function handleTelegramModelCommand<TContext>(deps: {
   ctx: TContext;
   openModelMenu: (ctx: TContext) => Promise<void>;
 }): Promise<void> {
-  await deps.openModelMenu(deps.ctx);
+  try {
+    await deps.openModelMenu(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
 }
 
 export async function executeTelegramCommandAction<TMessage, TContext>(
@@ -946,6 +974,8 @@ export function createTelegramCommandHandlerTargetRuntime<
     setCompactionInProgress: deps.setCompactionInProgress,
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+    startTypingLoop: deps.startTypingLoop,
+    stopTypingLoop: deps.stopTypingLoop,
     enqueueContinueTurn: deps.enqueueContinueTurn,
     compact: deps.compact,
     enqueueControlItem: commandTargetRuntime.enqueueControlItem,
@@ -1099,6 +1129,10 @@ async function handleTelegramCommandRuntime<
                   )
               : undefined,
           compact: (callbacks) => deps.compact(commandCtx, callbacks),
+          startTypingLoop: deps.startTypingLoop
+            ? () => deps.startTypingLoop?.(commandCtx, nextMessage.chat.id)
+            : undefined,
+          stopTypingLoop: deps.stopTypingLoop,
           sendTextReply: sendReplyFor(nextMessage),
           recordRuntimeEvent: deps.recordRuntimeEvent,
         });

package/lib/config.ts

@@ -185,6 +185,14 @@ export function getTelegramAuthorizationState(
   return { kind: "deny" };
 }
 
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
+}
+
 export async function pairTelegramUserIfNeeded<TContext>(
   userId: number,
   deps: TelegramUserPairingDeps<TContext>,
@@ -196,7 +204,11 @@ export async function pairTelegramUserIfNeeded<TContext>(
   if (authorization.kind !== "pair") return false;
   deps.setAllowedUserId(authorization.userId);
   await deps.persistConfig();
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   return true;
 }
 

package/lib/queue.ts

@@ -1289,6 +1289,14 @@ export interface TelegramPromptEnqueueController<TMessage, TContext = unknown> {
   enqueue: (messages: TMessage[], ctx: TContext) => Promise<void>;
 }
 
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
+}
+
 export function buildTelegramSessionStartState<TModel = unknown>(
   currentModel: TModel | undefined,
 ): TelegramSessionStartState<TModel> {
@@ -1326,7 +1334,11 @@ export async function startTelegramSessionRuntime<TContext, TModel = unknown>(
   await deps.loadConfig();
   deps.applyState(buildTelegramSessionStartState(deps.currentModel));
   await deps.prepareTempDir();
-  deps.bindDeferredDispatchContext?.(deps.ctx);
+  try {
+    deps.bindDeferredDispatchContext?.(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   deps.updateStatus();
 }
 
@@ -1478,7 +1490,11 @@ export function reorderTelegramQueueItemsRuntime<TContext>(
   deps.setQueuedItems(
     [...deps.getQueuedItems()].sort(compareTelegramQueueItems),
   );
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
 }
 
 export function clearTelegramQueueItemsRuntime<TContext>(
@@ -1487,7 +1503,11 @@ export function clearTelegramQueueItemsRuntime<TContext>(
   const removedCount = deps.getQueuedItems().length;
   if (removedCount === 0) return 0;
   deps.setQueuedItems([]);
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   return removedCount;
 }
 
@@ -1501,7 +1521,11 @@ export function removeTelegramQueueItemsByMessageIdsRuntime<TContext>(
   );
   if (removedCount === 0) return 0;
   deps.setQueuedItems(items);
-  deps.updateStatus(deps.ctx);
+  try {
+    deps.updateStatus(deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
+  }
   return removedCount;
 }
 

package/lib/routing.ts

@@ -82,6 +82,8 @@ export interface TelegramInboundRouteRuntimeDeps<
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
+  startTypingLoop?: (ctx: TContext, chatId?: number) => void;
+  stopTypingLoop?: () => void;
   answerCallbackQuery: (
     callbackQueryId: string,
     text?: string,
@@ -344,6 +346,8 @@ export function createTelegramInboundRouteRuntime<
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
     requestDeferredDispatchNextQueuedTelegramTurn:
       deps.requestDeferredDispatchNextQueuedTelegramTurn,
+    startTypingLoop: deps.startTypingLoop,
+    stopTypingLoop: deps.stopTypingLoop,
     enqueueContinueTurn,
     compact: deps.compact,
     allocateItemOrder: deps.bridgeRuntime.queue.allocateItemOrder,

package/lib/updates.ts

@@ -746,6 +746,14 @@ export async function handleAuthorizedTelegramReactionUpdate<TContext>(
   );
 }
 
+function isTelegramStaleContextError(error: unknown): boolean {
+  return (
+    error instanceof Error &&
+    (error.message.includes("stale after session") ||
+      error.message.includes("stale ctx"))
+  );
+}
+
 export async function executeTelegramUpdatePlan<
   TContext = unknown,
   TReactionUpdate extends TelegramMessageReactionUpdated =
@@ -761,81 +769,85 @@ export async function executeTelegramUpdatePlan<
     TMessage
   >,
 ): Promise<void> {
-  if (plan.kind === "ignore") return;
-  if (plan.kind === "deleted") {
-    deps.removePendingMediaGroupMessages(plan.messageIds);
-    deps.removeQueuedTelegramTurnsByMessageIds(plan.messageIds, deps.ctx);
-    return;
-  }
-  if (plan.kind === "reaction") {
-    await deps.handleAuthorizedTelegramReactionUpdate(
-      plan.reactionUpdate,
-      deps.ctx,
-    );
-    return;
-  }
-  if (plan.kind === "callback") {
-    if (plan.shouldPair) {
-      await deps.pairTelegramUserIfNeeded(plan.query.from.id, deps.ctx);
-    }
-    if (plan.shouldDeny) {
-      const callbackQueryId = getTelegramCallbackQueryId(plan.query);
-      if (callbackQueryId) {
-        await deps.answerCallbackQuery(
-          callbackQueryId,
-          "This bot is not authorized for your account.",
-        );
-      }
+  try {
+    if (plan.kind === "ignore") return;
+    if (plan.kind === "deleted") {
+      deps.removePendingMediaGroupMessages(plan.messageIds);
+      deps.removeQueuedTelegramTurnsByMessageIds(plan.messageIds, deps.ctx);
       return;
     }
-    await deps.handleAuthorizedTelegramCallbackQuery(plan.query, deps.ctx);
-    return;
-  }
-  if (plan.kind === "guest") {
-    if (plan.shouldDeny) {
-      await deps.answerGuestQuery(
-        plan.guestMessage.guest_query_id,
-        "Access denied.",
+    if (plan.kind === "reaction") {
+      await deps.handleAuthorizedTelegramReactionUpdate(
+        plan.reactionUpdate,
+        deps.ctx,
       );
       return;
     }
-    if (deps.handleAuthorizedTelegramGuestMessage) {
-      await deps.handleAuthorizedTelegramGuestMessage(
-        plan.guestMessage,
-        deps.ctx,
-      );
+    if (plan.kind === "callback") {
+      if (plan.shouldPair) {
+        await deps.pairTelegramUserIfNeeded(plan.query.from.id, deps.ctx);
+      }
+      if (plan.shouldDeny) {
+        const callbackQueryId = getTelegramCallbackQueryId(plan.query);
+        if (callbackQueryId) {
+          await deps.answerCallbackQuery(
+            callbackQueryId,
+            "This bot is not authorized for your account.",
+          );
+        }
+        return;
+      }
+      await deps.handleAuthorizedTelegramCallbackQuery(plan.query, deps.ctx);
+      return;
     }
-    return;
-  }
-  const pairedNow = plan.shouldPair
-    ? await deps.pairTelegramUserIfNeeded(plan.message.from.id, deps.ctx)
-    : false;
-  const replyTarget = getTelegramMessageReplyTarget(plan.message);
-  if (
-    plan.kind === "message" &&
-    pairedNow &&
-    plan.shouldNotifyPaired &&
-    replyTarget
-  ) {
-    await deps.sendTextReply(
-      replyTarget.chatId,
-      replyTarget.messageId,
-      "Telegram bridge paired with this account.",
-    );
-  }
-  if (plan.shouldDeny) {
-    if (replyTarget) {
+    if (plan.kind === "guest") {
+      if (plan.shouldDeny) {
+        await deps.answerGuestQuery(
+          plan.guestMessage.guest_query_id,
+          "Access denied.",
+        );
+        return;
+      }
+      if (deps.handleAuthorizedTelegramGuestMessage) {
+        await deps.handleAuthorizedTelegramGuestMessage(
+          plan.guestMessage,
+          deps.ctx,
+        );
+      }
+      return;
+    }
+    const pairedNow = plan.shouldPair
+      ? await deps.pairTelegramUserIfNeeded(plan.message.from.id, deps.ctx)
+      : false;
+    const replyTarget = getTelegramMessageReplyTarget(plan.message);
+    if (
+      plan.kind === "message" &&
+      pairedNow &&
+      plan.shouldNotifyPaired &&
+      replyTarget
+    ) {
       await deps.sendTextReply(
         replyTarget.chatId,
         replyTarget.messageId,
-        "This bot is not authorized for your account.",
+        "Telegram bridge paired with this account.",
       );
     }
-    return;
-  }
-  if (plan.kind === "edited-message") {
-    await deps.handleAuthorizedTelegramEditedMessage(plan.message, deps.ctx);
-    return;
+    if (plan.shouldDeny) {
+      if (replyTarget) {
+        await deps.sendTextReply(
+          replyTarget.chatId,
+          replyTarget.messageId,
+          "This bot is not authorized for your account.",
+        );
+      }
+      return;
+    }
+    if (plan.kind === "edited-message") {
+      await deps.handleAuthorizedTelegramEditedMessage(plan.message, deps.ctx);
+      return;
+    }
+    await deps.handleAuthorizedTelegramMessage(plan.message, deps.ctx);
+  } catch (error) {
+    if (!isTelegramStaleContextError(error)) throw error;
   }
-  await deps.handleAuthorizedTelegramMessage(plan.message, deps.ctx);
 }

package/package.json

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