@llblab/pi-kit 0.1.12 → 0.2.0

package/node_modules/@llblab/pi-telegram/lib/bindings.ts

@@ -337,7 +337,6 @@ export interface TelegramAssistantOutputBindingRuntime<TTransportStamp> {
 export function createTelegramAssistantOutputBindingRuntime<
   TTransportStamp,
 >(deps: {
-  isEnabled: () => boolean;
   authority: {
     getPreferredTarget: () =>
       | OutboundAttachments.TelegramQueuedOutboundAttachmentTurnView["target"]
@@ -364,7 +363,6 @@ export function createTelegramAssistantOutputBindingRuntime<
       deps.sender,
     );
   const runtime = Activity.createTelegramAssistantOutputRuntime({
-    isEnabled: deps.isEnabled,
     ...authority,
     async send(event, authority, isAuthorityActive) {
       await deps.waitForActivityIdle?.();
@@ -1012,8 +1010,9 @@ export function registerTelegramLifecycleRuntimeHooks({
   const agentStartWithDedupReset = Lifecycle.createAgentStartDedupHook(
     agentLifecycleHooks.onAgentStart,
   );
+  let uiPromptActive = false;
   const startAgentActivityTypingLoop = (ctx: Pi.ExtensionContext): boolean => {
-    if (!canSendAgentActivity(ctx)) return false;
+    if (uiPromptActive || !canSendAgentActivity(ctx)) return false;
     const turn = activeTurnRuntime.get();
     const target = turn?.target ?? proactivePushTargetGetter();
     promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, {
@@ -1022,12 +1021,15 @@ export function registerTelegramLifecycleRuntimeHooks({
     return true;
   };
   const startActiveTurnTypingLoop = (ctx: Pi.ExtensionContext): void => {
+    if (uiPromptActive) return;
     const turn = activeTurnRuntime.get();
     promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId, {
       target: turn?.target,
     });
   };
   let observedAutomaticCompaction = false;
+  let agentWorkActive = false;
+  let terminalAssistantMessagePendingDelivery = false;
   const deferredAutomaticCompactionNotices: string[] = [];
   const sendCompactionNotice = async (text: string): Promise<void> => {
     const turn = activeTurnRuntime.get();
@@ -1094,6 +1096,9 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityVerbosityRuntime?.reset();
       assistantOutputRuntime.stop();
       observedAutomaticCompaction = false;
+      agentWorkActive = false;
+      terminalAssistantMessagePendingDelivery = false;
+      uiPromptActive = false;
       deferredAutomaticCompactionNotices.length = 0;
       compactionObserver.onSessionShutdown();
       if (event.reason === "quit" && disconnectOnQuit) {
@@ -1116,7 +1121,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
       if (shouldNotify) {
-        if (activeTurnRuntime.has()) {
+        if (terminalAssistantMessagePendingDelivery) {
           deferredAutomaticCompactionNotices.push(
             Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
           );
@@ -1135,10 +1140,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       compactionObserver.onSessionCompact(event, ctx);
       if (observedAutomaticCompaction) {
         observedAutomaticCompaction = false;
-        if (
-          activeTurnRuntime.has() ||
-          deferredAutomaticCompactionNotices.length > 0
-        ) {
+        if (deferredAutomaticCompactionNotices.length > 0) {
           deferredAutomaticCompactionNotices.push(
             Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
           );
@@ -1149,8 +1151,27 @@ export function registerTelegramLifecycleRuntimeHooks({
         }
       }
     },
+    async onSessionCompactFailed(event, ctx) {
+      if (!isSessionContextActive(ctx)) return;
+      const shouldNotify = observedAutomaticCompaction;
+      const deferredNotices = deferredAutomaticCompactionNotices.splice(0);
+      const shouldDefer =
+        deferredNotices.length > 0 || terminalAssistantMessagePendingDelivery;
+      compactionObserver.onSessionCompactFailed(event, ctx);
+      if (!shouldNotify) return;
+      const notice = event.aborted
+        ? "**⚠️ Compaction cancelled.**"
+        : "**⚠️ Compaction failed.**";
+      if (shouldDefer) {
+        deferredAutomaticCompactionNotices.push(...deferredNotices, notice);
+      } else {
+        await sendCompactionNotice(notice);
+      }
+    },
     async onAgentStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
+      agentWorkActive = true;
+      terminalAssistantMessagePendingDelivery = false;
       await agentStartWithDedupReset(event, ctx);
       activityRuntime.onAgentStart(activeTurnRuntime.get()?.target);
       startAgentActivityTypingLoop(ctx);
@@ -1195,19 +1216,45 @@ export function registerTelegramLifecycleRuntimeHooks({
       }
       await messageActivityHooks.onMessageUpdate(event, ctx);
     },
+    onMessageEnd(event, ctx) {
+      if (!isSessionContextActive(ctx)) return;
+      terminalAssistantMessagePendingDelivery =
+        event.message.role === "assistant" &&
+        event.message.stopReason !== "toolUse" &&
+        event.message.stopReason !== "error" &&
+        event.message.stopReason !== "aborted";
+    },
+    onUiPromptStart(event, ctx) {
+      if (!isSessionContextActive(ctx)) return;
+      uiPromptActive = true;
+      typing.stop();
+      activityRuntime.onUiPromptStart(event.kind, event.title);
+      updateStatus(ctx);
+    },
+    onUiPromptEnd(_event, ctx) {
+      if (!isSessionContextActive(ctx)) return;
+      uiPromptActive = false;
+      activityRuntime.onUiPromptEnd();
+      if (agentWorkActive || lifecycle.isCompactionInProgress()) {
+        startAgentActivityTypingLoop(ctx);
+      }
+      updateStatus(ctx);
+    },
     async onAgentEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
       activityRuntime.onAgentEnd();
       await agentLifecycleHooks.onAgentEnd(event, ctx);
+    },
+    async onAgentSettled(event, ctx) {
+      if (!isSessionContextActive(ctx)) return;
+      await agentLifecycleHooks.onAgentSettled(event, ctx);
       if (deferredAutomaticCompactionNotices.length > 0) {
         await waitForActiveTurnDelivery();
         if (!isSessionContextActive(ctx)) return;
         await flushDeferredAutomaticCompactionNotices();
       }
-    },
-    async onAgentSettled(event, ctx) {
-      if (!isSessionContextActive(ctx)) return;
-      await agentLifecycleHooks.onAgentSettled(event, ctx);
+      terminalAssistantMessagePendingDelivery = false;
+      agentWorkActive = false;
       activityRuntime.onAgentSettled();
       modelContextAvailabilityRuntime.reconcile();
     },

package/node_modules/@llblab/pi-telegram/lib/bus-leader.ts

@@ -335,7 +335,7 @@ export function createTelegramBusInstanceLifecycleAnnouncement(input: {
 }): TelegramBusFollowerLifecycleAnnouncement {
   return {
     target: { ...input.target },
-    text: `📡 Instance <b>${formatTelegramBusInstanceLabel(input)}</b> ${input.state}.`,
+    text: `<b>📡 Instance <i>${formatTelegramBusInstanceLabel(input)}</i> ${input.state}.</b>`,
     parseMode: "HTML",
   };
 }

package/node_modules/@llblab/pi-telegram/lib/config.ts

@@ -105,7 +105,6 @@ export interface TelegramConfig {
   assistant?: {
     draftPreviews?: boolean;
     rendering?: TelegramAssistantRenderingMode;
-    proactivePush?: boolean;
     activity?: TelegramActivityVerbosity;
     timeInjection?: TelegramTimeMode;
     /** @deprecated use activity */
@@ -454,10 +453,32 @@ function omitTelegramRootProfileFields(config: TelegramConfig): TelegramConfig {
   return sharedConfig;
 }
 
+function omitRetiredProactivePush(config: TelegramConfig): {
+  config: TelegramConfig;
+  changed: boolean;
+} {
+  const assistant = config.assistant as
+    | (NonNullable<TelegramConfig["assistant"]> & { proactivePush?: unknown })
+    | undefined;
+  if (!assistant || !Object.hasOwn(assistant, "proactivePush")) {
+    return { config, changed: false };
+  }
+  const { proactivePush: _proactivePush, ...remainingAssistant } = assistant;
+  const next = { ...config };
+  if (Object.keys(remainingAssistant).length > 0) {
+    next.assistant = remainingAssistant;
+  } else {
+    delete next.assistant;
+  }
+  return { config: next, changed: true };
+}
+
 export function normalizeTelegramDefaultProfileConfig(config: TelegramConfig): {
   config: TelegramConfig;
   changed: boolean;
 } {
+  const retiredProactivePush = omitRetiredProactivePush(config);
+  config = retiredProactivePush.config;
   const hasLegacyRootProfile = [
     "botToken",
     "botUsername",
@@ -465,7 +486,9 @@ export function normalizeTelegramDefaultProfileConfig(config: TelegramConfig): {
     "allowedUserId",
     "lastUpdateId",
   ].some((field) => Object.hasOwn(config, field));
-  if (!hasLegacyRootProfile) return { config, changed: false };
+  if (!hasLegacyRootProfile) {
+    return { config, changed: retiredProactivePush.changed };
+  }
   const canonicalProfile = config.profiles?.[TELEGRAM_DEFAULT_PROFILE_NAME];
   const legacyToken = config.botToken?.trim();
   if (Object.hasOwn(config, "botToken") && !legacyToken) {
@@ -712,27 +735,6 @@ export function createTelegramConfigStore(
   };
 }
 
-export function createTelegramProactivePushChecker(
-  configStore: Pick<TelegramConfigStore, "get">,
-): () => boolean {
-  return () => configStore.get().assistant?.proactivePush ?? true;
-}
-
-export function createTelegramProactivePushSetter(
-  configStore: TelegramMutableConfigStore,
-): (enabled: boolean) => Promise<void> {
-  return async (enabled) => {
-    await loadLatestTelegramConfig(configStore);
-    const current = configStore.get();
-    const config: TelegramConfig = {
-      ...current,
-      assistant: { ...current.assistant, proactivePush: enabled },
-    };
-    configStore.set(config);
-    await configStore.persist(config);
-  };
-}
-
 export function createTelegramDraftPreviewsChecker(
   configStore: Pick<TelegramConfigStore, "get">,
 ): () => boolean {
@@ -1019,8 +1021,6 @@ export function createTelegramConfigControls(
   configStore: TelegramMutableConfigStore,
 ) {
   return {
-    isProactivePushEnabled: createTelegramProactivePushChecker(configStore),
-    setProactivePushEnabled: createTelegramProactivePushSetter(configStore),
     areDraftPreviewsEnabled: createTelegramDraftPreviewsChecker(configStore),
     setDraftPreviewsEnabled: createTelegramDraftPreviewsSetter(configStore),
     getAssistantRenderingMode:

package/node_modules/@llblab/pi-telegram/lib/inbound.ts

@@ -19,7 +19,7 @@ import { getTelegramVoiceTranscriptionProviders } from "./voice.ts";
 
 const DEFAULT_INBOUND_HANDLER_TIMEOUT_MS = 120_000;
 const INBOUND_HANDLER_REGISTRY_KEY = "__piTelegramInboundHandlers__";
-const MAX_INBOUND_HANDLER_OUTPUT_LENGTH = 12_000;
+const MAX_INBOUND_HANDLER_OUTPUT_LENGTH = 24_000;
 const MAX_INBOUND_HANDLER_FAILURE_STREAM_LENGTH = 4_000;
 
 type TelegramInboundCommandTemplateConfig =

package/node_modules/@llblab/pi-telegram/lib/lifecycle.ts

@@ -16,13 +16,17 @@ import type {
   ExtensionAPI,
   ExtensionContext,
   InputEvent,
+  MessageEndEvent,
   SessionBeforeCompactEvent,
   SessionCompactEvent,
+  SessionCompactFailedEvent,
   SessionShutdownEvent,
   SessionStartEvent,
   ToolExecutionEndEvent,
   ToolExecutionStartEvent,
   ToolExecutionUpdateEvent,
+  UIPromptEndEvent,
+  UIPromptStartEvent,
 } from "./pi.ts";
 
 let resetTransportReplyDedupFn: (() => void) | undefined;
@@ -78,6 +82,10 @@ export interface TelegramLifecycleRegistrationDeps {
     event: SessionCompactEvent,
     ctx: ExtensionContext,
   ) => Promise<void> | void;
+  onSessionCompactFailed?: (
+    event: SessionCompactFailedEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
   onBeforeAgentStart: (
     event: TelegramBeforeAgentStartEvent,
     ctx: ExtensionContext,
@@ -113,6 +121,18 @@ export interface TelegramLifecycleRegistrationDeps {
     },
     ctx: ExtensionContext,
   ) => Promise<void>;
+  onMessageEnd?: (
+    event: MessageEndEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
+  onUiPromptStart?: (
+    event: UIPromptStartEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
+  onUiPromptEnd?: (
+    event: UIPromptEndEvent,
+    ctx: ExtensionContext,
+  ) => Promise<void> | void;
   onAgentEnd: (event: AgentEndEvent, ctx: ExtensionContext) => Promise<void>;
   onAgentSettled?: (
     event: AgentSettledEvent,
@@ -416,6 +436,10 @@ export interface TelegramCompactionObserverRuntime<TContext> {
     ctx: TContext,
   ) => void;
   onSessionCompact: (event: SessionCompactEvent, ctx: TContext) => void;
+  onSessionCompactFailed: (
+    event: SessionCompactFailedEvent,
+    ctx: TContext,
+  ) => void;
   onSessionShutdown: () => void;
 }
 
@@ -471,6 +495,16 @@ export function createTelegramCompactionObserverRuntime<TContext>(
       deps.updateStatus(ctx);
       requestDispatch();
     },
+    onSessionCompactFailed: (_event, ctx) => {
+      clearFallbackTimer();
+      if (deps.isContextActive && !deps.isContextActive(ctx)) return;
+      deps.setCompactionInProgress(false);
+      if (typingStartedByObserver) deps.stopTypingLoop?.();
+      typingStartedByObserver = false;
+      deps.updateStatus(ctx);
+      deps.onCompactionAbandoned?.();
+      requestDispatch();
+    },
     onSessionShutdown: () => {
       clearFallbackTimer();
       if (typingStartedByObserver) deps.stopTypingLoop?.();
@@ -590,6 +624,10 @@ export function registerTelegramLifecycleHooks(
     if (!isActive(ctx)) return;
     await deps.onSessionCompact?.(event, ctx);
   });
+  pi.on("session_compact_failed", async (event, ctx) => {
+    if (!isActive(ctx)) return;
+    await deps.onSessionCompactFailed?.(event, ctx);
+  });
   // The Pi SDK still types this result as a string; compatible runtimes may
   // preserve ordered system prompt blocks through the same public hook.
   const registerBeforeAgentStart = pi.on.bind(pi) as unknown as (
@@ -630,6 +668,18 @@ export function registerTelegramLifecycleHooks(
     if (!isActive(ctx)) return;
     await deps.onMessageUpdate(event, ctx);
   });
+  pi.on("message_end", async (event, ctx) => {
+    if (!isActive(ctx)) return;
+    await deps.onMessageEnd?.(event, ctx);
+  });
+  pi.on("ui_prompt_start", async (event, ctx) => {
+    if (!isActive(ctx)) return;
+    await deps.onUiPromptStart?.(event, ctx);
+  });
+  pi.on("ui_prompt_end", async (event, ctx) => {
+    if (!isActive(ctx)) return;
+    await deps.onUiPromptEnd?.(event, ctx);
+  });
   pi.on("agent_end", async (event, ctx) => {
     if (!isActive(ctx)) return;
     await deps.onAgentEnd(event, ctx);

package/node_modules/@llblab/pi-telegram/lib/menu-settings.ts

@@ -21,7 +21,6 @@ import type { TelegramVoiceReplyMode } from "./voice.ts";
 export type TelegramSettingsMenuReplyMarkup = TelegramInlineKeyboardMarkup;
 
 export interface TelegramSettingsStateDeps {
-  isProactivePushEnabled: () => boolean;
   areDraftPreviewsEnabled: () => boolean;
   getAssistantRenderingMode: () => TelegramAssistantRenderingMode;
   getActivityVerbosity: () => TelegramActivityVerbosity;
@@ -32,7 +31,6 @@ export interface TelegramSettingsStateDeps {
 }
 
 export interface TelegramSettingsMutationDeps extends TelegramSettingsStateDeps {
-  setProactivePushEnabled: (enabled: boolean) => Promise<void>;
   setDraftPreviewsEnabled: (enabled: boolean) => Promise<void>;
   setAssistantRenderingMode: (
     mode: TelegramAssistantRenderingMode,
@@ -139,7 +137,6 @@ export interface TelegramSettingsMenuRuntimeDeps<
 export const SETTINGS_MENU_TITLE = "<b>⚙️ Settings:</b>";
 export const AUTOMATIC_THREAD_CLEANUP_SETTINGS_TITLE =
   "<b>🧹 Thread cleanup:</b>";
-export const PROACTIVE_PUSH_SETTINGS_TITLE = "<b>📌 Proactive push:</b>";
 export const DRAFT_PREVIEWS_SETTINGS_TITLE = "<b>📝 Draft previews:</b>";
 export const ASSISTANT_RENDERING_SETTINGS_TITLE =
   "<b>🧾 Assistant rendering:</b>";
@@ -181,19 +178,6 @@ export function buildAutomaticThreadCleanupSettingsText(
   ].join("\n");
 }
 
-export function buildProactivePushSettingsText(
-  proactivePushEnabled: boolean,
-): string {
-  return [
-    `${PROACTIVE_PUSH_SETTINGS_TITLE} <code>${proactivePushEnabled ? "on" : "off"}</code>`,
-    "",
-    "Control whether public assistant output from local/autonomous work is projected to Telegram.",
-    "",
-    "<code>-</code> <code>on</code> (default): send each completed public block, including visible checkpoints and the final answer, while connected.",
-    "<code>-</code> <code>off</code>: keep local/autonomous assistant blocks in Pi; Telegram-originated replies still use their normal delivery path.",
-  ].join("\n");
-}
-
 export function buildDraftPreviewsSettingsText(enabled: boolean): string {
   return [
     `${DRAFT_PREVIEWS_SETTINGS_TITLE} <code>${enabled ? "on" : "off"}</code>`,
@@ -265,7 +249,6 @@ export function buildTimeInjectionModeSettingsText(
 }
 
 export function buildTelegramSettingsMenuReplyMarkup(
-  proactivePushEnabled: boolean,
   draftPreviewsEnabled: boolean,
   assistantRenderingModeOrVoiceReplyMode:
     TelegramAssistantRenderingMode | TelegramVoiceReplyMode,
@@ -325,10 +308,6 @@ export function buildTelegramSettingsMenuReplyMarkup(
       text: `🔬 Activity: ${activityVerbosity}`,
       callback_data: "settings:open:activity-verbosity",
     },
-    {
-      text: `📌 Proactive push: ${proactivePushEnabled ? "on" : "off"}`,
-      callback_data: "settings:open:proactive",
-    },
     {
       text: `🕒 Time injection: ${getTelegramSettingsStateValueLabel(timeInjectionMode)}`,
       callback_data: "settings:open:time-injection",
@@ -362,7 +341,6 @@ export async function openTelegramSettingsMenu<
     state,
     buildTelegramSettingsMenuText(),
     buildTelegramSettingsMenuReplyMarkup(
-      deps.isProactivePushEnabled(),
       deps.areDraftPreviewsEnabled(),
       deps.getAssistantRenderingMode(),
       deps.getVoiceReplyMode(),
@@ -399,26 +377,6 @@ export function buildAutomaticThreadCleanupSettingsReplyMarkup(
   };
 }
 
-export function buildProactivePushSettingsReplyMarkup(
-  proactivePushEnabled: boolean,
-): TelegramSettingsMenuReplyMarkup {
-  return {
-    inline_keyboard: [
-      [{ text: "⬆️ Back", callback_data: "settings:list" }],
-      [
-        {
-          text: proactivePushEnabled ? "🟢 On" : "⚫️ On",
-          callback_data: "settings:set:proactive:on",
-        },
-        {
-          text: proactivePushEnabled ? "⚫️ Off" : "🟡 Off",
-          callback_data: "settings:set:proactive:off",
-        },
-      ],
-    ],
-  };
-}
-
 export function buildDraftPreviewsSettingsReplyMarkup(
   enabled: boolean,
 ): TelegramSettingsMenuReplyMarkup {
@@ -521,7 +479,6 @@ export async function updateTelegramSettingsMenuMessage(
   await deps.updateSettingsMessage(
     buildTelegramSettingsMenuText(),
     buildTelegramSettingsMenuReplyMarkup(
-      deps.isProactivePushEnabled(),
       deps.areDraftPreviewsEnabled(),
       deps.getAssistantRenderingMode(),
       deps.getVoiceReplyMode(),
@@ -544,16 +501,6 @@ export async function updateAutomaticThreadCleanupSettingsMessage(
   );
 }
 
-export async function updateProactivePushSettingsMessage(
-  deps: TelegramSettingsMenuCallbackDeps,
-): Promise<void> {
-  const proactivePushEnabled = deps.isProactivePushEnabled();
-  await deps.updateSettingsMessage(
-    buildProactivePushSettingsText(proactivePushEnabled),
-    buildProactivePushSettingsReplyMarkup(proactivePushEnabled),
-  );
-}
-
 export async function updateDraftPreviewsSettingsMessage(
   deps: TelegramSettingsMenuCallbackDeps,
 ): Promise<void> {
@@ -621,9 +568,16 @@ export async function handleTelegramSettingsMenuCallbackAction(
     await deps.answerCallbackQuery(callbackQueryId);
     return true;
   }
-  if (data === "settings:open:proactive") {
-    await updateProactivePushSettingsMessage(deps);
-    await deps.answerCallbackQuery(callbackQueryId);
+  if (
+    data === "settings:open:proactive" ||
+    data === "settings:set:proactive:on" ||
+    data === "settings:set:proactive:off"
+  ) {
+    await updateTelegramSettingsMenuMessage(deps, deps.sectionRegistry);
+    await deps.answerCallbackQuery(
+      callbackQueryId,
+      "Public assistant output is always delivered while Telegram is connected.",
+    );
     return true;
   }
   if (
@@ -751,19 +705,6 @@ export async function handleTelegramSettingsMenuCallbackAction(
     );
     return true;
   }
-  if (
-    data === "settings:set:proactive:on" ||
-    data === "settings:set:proactive:off"
-  ) {
-    const enabled = data.endsWith(":on");
-    await deps.setProactivePushEnabled(enabled);
-    await updateProactivePushSettingsMessage(deps);
-    await deps.answerCallbackQuery(
-      callbackQueryId,
-      `Proactive push ${enabled ? "enabled" : "disabled"}`,
-    );
-    return true;
-  }
   await deps.answerCallbackQuery(callbackQueryId);
   return true;
 }
@@ -781,7 +722,6 @@ export function createTelegramSettingsMenuRuntime<
       return openTelegramSettingsMenu(
         {
           getModelMenuState: () => deps.getModelMenuState(chatId, ctx),
-          isProactivePushEnabled: deps.isProactivePushEnabled,
           areDraftPreviewsEnabled: deps.areDraftPreviewsEnabled,
           getAssistantRenderingMode: deps.getAssistantRenderingMode,
           getActivityVerbosity: deps.getActivityVerbosity,
@@ -805,7 +745,6 @@ export function createTelegramSettingsMenuRuntime<
       await deps.reloadConfig?.();
       return updateTelegramSettingsMenuMessage(
         {
-          isProactivePushEnabled: deps.isProactivePushEnabled,
           areDraftPreviewsEnabled: deps.areDraftPreviewsEnabled,
           getAssistantRenderingMode: deps.getAssistantRenderingMode,
           getActivityVerbosity: deps.getActivityVerbosity,
@@ -849,7 +788,6 @@ export function createTelegramSettingsMenuRuntime<
         deps.storeModelMenuState(state);
       }
       return handleTelegramSettingsMenuCallbackAction(query.id, query.data, {
-        isProactivePushEnabled: deps.isProactivePushEnabled,
         areDraftPreviewsEnabled: deps.areDraftPreviewsEnabled,
         getAssistantRenderingMode: deps.getAssistantRenderingMode,
         getActivityVerbosity: deps.getActivityVerbosity,
@@ -857,7 +795,6 @@ export function createTelegramSettingsMenuRuntime<
         isVoiceReplyModeConfigured: deps.isVoiceReplyModeConfigured,
         getTimeInjectionMode: deps.getTimeInjectionMode,
         isAutomaticThreadCleanupEnabled: deps.isAutomaticThreadCleanupEnabled,
-        setProactivePushEnabled: deps.setProactivePushEnabled,
         setDraftPreviewsEnabled: deps.setDraftPreviewsEnabled,
         setAssistantRenderingMode: deps.setAssistantRenderingMode,
         setActivityVerbosity: deps.setActivityVerbosity,

package/node_modules/@llblab/pi-telegram/lib/pi.ts

@@ -14,11 +14,14 @@ import {
   type ExtensionCommandContext,
   type ExtensionContext,
   type InputEvent,
+  type MessageEndEvent,
   type SessionBeforeCompactEvent,
   type SessionCompactEvent,
   type SessionShutdownEvent,
   type SessionStartEvent,
   type SlashCommandInfo,
+  type UIPromptEndEvent,
+  type UIPromptStartEvent,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 
@@ -32,13 +35,25 @@ export type {
   ExtensionCommandContext,
   ExtensionContext,
   InputEvent,
+  MessageEndEvent,
   SessionBeforeCompactEvent,
   SessionCompactEvent,
   SessionShutdownEvent,
   SessionStartEvent,
   SlashCommandInfo,
+  UIPromptEndEvent,
+  UIPromptStartEvent,
 };
 
+export interface SessionCompactFailedEvent {
+  type: "session_compact_failed";
+  reason: "manual" | "threshold" | "overflow";
+  errorMessage?: string;
+  aborted: boolean;
+  willRetry: boolean;
+  fromExtension: boolean;
+}
+
 export interface ToolExecutionStartEvent {
   type: "tool_execution_start";
   toolCallId: string;

package/node_modules/@llblab/pi-telegram/lib/status.ts

@@ -14,6 +14,7 @@ export interface TelegramUsageStats {
   totalCacheRead: number;
   totalCacheWrite: number;
   totalCost: number;
+  latestCacheHitRate?: number;
 }
 
 interface TelegramUsageMessage {
@@ -1473,6 +1474,9 @@ function collectUsageStats(ctx: TelegramStatusContext): TelegramUsageStats {
     stats.totalCacheRead += usage.cacheRead;
     stats.totalCacheWrite += usage.cacheWrite;
     stats.totalCost += usage.cost.total;
+    const promptTokens = usage.input + usage.cacheRead + usage.cacheWrite;
+    stats.latestCacheHitRate =
+      promptTokens > 0 ? (usage.cacheRead / promptTokens) * 100 : undefined;
   }
   return stats;
 }
@@ -1494,6 +1498,12 @@ function buildUsageSummary(stats: TelegramUsageStats): string | undefined {
     tokenParts.push(`R${formatTokens(stats.totalCacheRead)}`);
   if (stats.totalCacheWrite)
     tokenParts.push(`W${formatTokens(stats.totalCacheWrite)}`);
+  if (
+    (stats.totalCacheRead > 0 || stats.totalCacheWrite > 0) &&
+    stats.latestCacheHitRate !== undefined
+  ) {
+    tokenParts.push(`CH${stats.latestCacheHitRate.toFixed(1)}%`);
+  }
   return tokenParts.length > 0 ? tokenParts.join(" ") : undefined;
 }
 
@@ -1549,7 +1559,7 @@ export function buildStatusHtml(
   const usageSummary = buildUsageSummary(stats);
   const costSummary = buildCostSummary(stats, usesSubscription);
   if (usageSummary) {
-    lines.push(buildStatusRow("Usage", usageSummary));
+    lines.push(buildStatusRow("Tokens", usageSummary));
   }
   if (costSummary) {
     lines.push(buildStatusRow("Cost", costSummary));

package/node_modules/@llblab/pi-telegram/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.39.5",
+  "version": "0.41.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -71,9 +71,9 @@
     "image": "https://raw.githubusercontent.com/llblab/pi-telegram/main/screenshot.png"
   },
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": ">=0.80.6",
-    "@earendil-works/pi-ai": ">=0.80.6",
-    "@earendil-works/pi-coding-agent": ">=0.80.6",
+    "@earendil-works/pi-agent-core": ">=0.84.4",
+    "@earendil-works/pi-ai": ">=0.84.4",
+    "@earendil-works/pi-coding-agent": ">=0.84.4",
     "@sinclair/typebox": "*"
   },
   "devDependencies": {