@llblab/pi-kit 0.1.11 → 0.1.13

package/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.1.13 - 2026-08-30
+
+- `Telegram Minor Release`: Advances `@llblab/pi-telegram` to `0.40.0`, requiring Pi 0.84.4 and adopting native compaction-failure, mid-run compaction, terminal-message, and local UI-prompt lifecycle contracts while increasing bounded inbound text output to 24,000 characters.
+
+## 0.1.12 - 2026-08-28
+
+- `Codex Usage Release`: Advances `@llblab/pi-codex-usage` to `0.9.4`, reducing automatic OpenAI quota polling by increasing the refresh interval from 30 to 60 seconds while preserving the local countdown responsiveness.
+- `Telegram Hotfix`: Advances `@llblab/pi-telegram` to `0.39.5`, preserving terminal-equivalent chronology by delivering an active turn's final Telegram answer before automatic-compaction start and completion notices.
+
 ## 0.1.11 - 2026-08-28
 
 - `Telegram Hotfix`: Advances `@llblab/pi-telegram` to `0.39.4`, preventing repeated extension errors when print, RPC, ACP, or other headless hosts refresh lifecycle status without an initialized theme while preserving interactive status rendering.

package/README.md

@@ -7,9 +7,9 @@
 | Package | Version | Resources |
 | --- | ---: | --- |
 | `@llblab/pi-actors` | `0.50.0` | Extension and Skills |
-| `@llblab/pi-codex-usage` | `0.9.3` | Extension |
+| `@llblab/pi-codex-usage` | `0.9.4` | Extension |
 | `@llblab/pi-grow-loop` | `0.7.3` | Extension and Skills |
-| `@llblab/pi-telegram` | `0.39.4` | Extension and Skills |
+| `@llblab/pi-telegram` | `0.40.0` | Extension and Skills |
 
 Versions are exact by design. Updating an extension does not change an installed kit until this repository explicitly advances that dependency and publishes a new kit version.
 

package/node_modules/@llblab/pi-codex-usage/BACKLOG.md

@@ -1,8 +1,3 @@
 # Backlog
 
-## Pending Release Verification
-
-- [x] Fix stale extension context usage after session replacement or reload. Source: GitHub issue #1. Timers must not keep using captured stale `ctx` after Pi session lifecycle changes.
-- [x] Make usage refresh cache/in-flight state model-aware for Codex vs Spark. A regular Codex cache or request must not temporarily render Spark as `n/a` after model switching.
-- [x] Preserve the active `codex`/`spark` label for failure states. Spark failures should render `spark n/a` or `spark error`, not `codex ...`.
-- [x] Replace the visually full startup/request placeholder with counter-moving upper/lower in-bar loading markers. Keep the last usable active-bucket bar visible during ordinary refreshes, and hold provisional zero-usage reports behind the loader until confirmed stable.
+No open work.

package/node_modules/@llblab/pi-codex-usage/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.9.4: Responsive Quota Polling
+
+- Increased the automatic Codex quota refresh interval from 30 to 60 seconds. Impact: status values remain responsive down to the locally rendered seconds countdown while reducing repeated OpenAI requests, especially when several Pi instances are open.
+
 ## 0.9.3: Trusted Release Automation
 
 - Added tag-gated release automation with exact package/lock/tag identity checks, full package validation, npm Trusted Publisher provenance, public registry verification, and workflow-owned GitHub Release creation through `.github/workflows/release.yml`.

package/node_modules/@llblab/pi-codex-usage/README.md

@@ -14,7 +14,7 @@ This repository is a minimal fork of [`narumiruna/pi-extensions/extensions/pi-co
 
 ## Features
 
-- Shows two counter-moving half-height markers in the statusline bar while the active Codex/Spark quota bucket is loading, then refreshes every 30 seconds
+- Shows two counter-moving half-height markers in the statusline bar while the active Codex/Spark quota bucket is loading, then refreshes every 60 seconds
 - Keeps the last usable active-bucket bar visible during ordinary refreshes instead of replacing known quota with a loading state
 - Statusline output adapts to the response: weekly-only limits show an explicit remaining percentage and reset countdown, while dual-window limits keep the compact themed bar
 - Regular Codex subscription models show the primary `codex` quota bucket

package/node_modules/@llblab/pi-codex-usage/index.ts

@@ -16,7 +16,7 @@ const HOUR_MS = 60 * MINUTE_MS;
 const HOUR_TENTH_MS = 6 * MINUTE_MS;
 const DAY_MS = 24 * HOUR_MS;
 const DAY_TENTH_MS = 144 * MINUTE_MS;
-const REFRESH_INTERVAL_MS = 30 * SECOND_MS;
+const REFRESH_INTERVAL_MS = 60 * SECOND_MS;
 const PROVISIONAL_RETRY_MS = SECOND_MS;
 const FULL_AVAILABILITY_CONFIRMATION_MS = 15 * SECOND_MS;
 const LOADING_FRAME_MS = 30;

package/node_modules/@llblab/pi-codex-usage/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-codex-usage",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "private": false,
   "description": "Minimal Pi extension that shows primary Codex ChatGPT subscription usage limits",
   "keywords": [

package/node_modules/@llblab/pi-telegram/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 > Each release keeps at most 8 outcome records of at most 512 characters.
 
+## 0.40.0: Pi 0.84.4 Lifecycle Alignment
+
+- `Pi Compatibility`: Requires `@earendil-works/pi-coding-agent`, `pi-agent-core`, and `pi-ai` 0.84.4 or newer, aligning the bridge and its validation runtime with native compaction-failure, mid-run compaction, message-finalization, and UI-prompt lifecycle contracts.
+- `Compaction Failure`: Handles `session_compact_failed` immediately by clearing compacting state, stopping observer-owned typing, releasing deferred queue work, abandoning stale activity, and reporting automatic failure or cancellation without duplicating manual `/compact` errors.
+- `Compaction Chronology`: Distinguishes terminal assistant output awaiting Telegram delivery from mid-run tool continuation. Post-answer notices remain ordered after the final reply, while tool-result threshold compaction is reported in place before the next assistant response.
+- `Local UI Waiting`: Pauses Telegram typing while Pi waits on extension-owned local select, confirm, input, editor, or custom prompts and emits coalesced `ui-prompt-start` / `ui-prompt-end` Activity boundaries before resuming active-turn typing.
+- `Inbound Context`: Raises successful inbound handler and built-in text attachment output from 12,000 to 24,000 characters while retaining the 1 MB built-in file admission ceiling and explicit truncation evidence.
+
+## 0.39.5: Auto-Compaction Notice Chronology Hotfix
+
+- `Turn Chronology`: Defers observed automatic-compaction notices while a Telegram turn is still active, preserving the same causal order shown by the terminal: final answer, compaction started, then compaction completed. Abandoned compactions and session shutdown discard deferred notices instead of leaking them into a later turn.
+
 ## 0.39.4: Headless Status Bar Hotfix
 
 - `Headless Hosts`: Skips status-bar rendering when a print, RPC, ACP, or other non-interactive host has not initialized its theme, preventing repeated extension errors during lifecycle status refreshes while preserving normal interactive status updates and error propagation.

package/node_modules/@llblab/pi-telegram/docs/activity.md

@@ -96,7 +96,7 @@ Source classification follows evidence, not guesses:
 
 Automatic retries, overflow compaction retries, and tool continuations inherit the current activity identity/source until `agent_settled`. A new unrelated `agent_start` after settlement allocates a new activity id.
 
-A standalone compaction owns a temporary activity only until `session_compact`. Pi does not expose a sibling-extension cancellation/failure callback after `session_before_compact`, so pi-telegram abandons that temporary identity at the first provable fallback boundary: the next `agent_start`, a replacement compaction start, session shutdown, or the existing five-minute compaction-observer timeout. A late `session_compact` after abandonment is ignored and cannot attach to the next run. Compaction inside an existing agent activity never clears that agent's identity.
+A standalone compaction owns a temporary activity until `session_compact` or `session_compact_failed`. Native failure or cancellation immediately abandons that identity, clears compacting state, releases deferred queue work, and stops observer-owned typing; the five-minute observer timeout remains a compatibility fallback for a host that never emits a terminal compaction event. A late `session_compact` after abandonment is ignored and cannot attach to the next run. Compaction inside an existing agent activity never clears that agent's identity.
 
 ## Event Contract
 
@@ -151,6 +151,12 @@ export type TelegramActivityEvent = TelegramActivityEnvelope & (
       type: "compaction-end";
       reason: "manual" | "threshold" | "overflow" | "unknown";
     }
+  | {
+      type: "ui-prompt-start";
+      kind: "select" | "confirm" | "input" | "editor" | "custom";
+      title?: string;
+    }
+  | { type: "ui-prompt-end" }
   | { type: "agent-end" }
   | { type: "agent-settled" }
 );
@@ -250,7 +256,8 @@ The bridge maps Pi hooks as follows:
 - `agent_start`: allocate or reuse activity identity and emit `agent-start` after Telegram queue consumption establishes active-turn ownership.
 - `message_update.assistantMessageEvent`: normalize text/reasoning/provider boundaries.
 - `tool_execution_start/update/end`: emit executed tool events.
-- `session_before_compact` / `session_compact`: emit compaction boundaries and preserve activity identity across retry compaction; abandon an unterminated standalone compaction at the next lifecycle boundary or observer timeout rather than merging it into another run. A missing or unrecognized reason maps to `unknown` rather than guessing.
+- `session_before_compact` / `session_compact` / `session_compact_failed`: emit successful compaction boundaries, abandon failed or cancelled work immediately, and preserve activity identity across retry compaction. Mid-run threshold compaction stays between tool results and the next assistant response, while terminal assistant output awaiting transport keeps later notices behind its final reply. A missing or unrecognized reason maps to `unknown` rather than guessing.
+- `ui_prompt_start` / `ui_prompt_end`: emit one coalesced waiting span for extension-owned local UI, pause Telegram typing while Pi waits for the operator, and resume active-turn typing when the prompt closes.
 - `agent_end`: emit low-level run completion but keep identity alive for retry/follow-up work.
 - `agent_settled`: emit terminal settlement, flush pending terminal segments, and release activity identity.
 - `session_shutdown`: stop dispatch, clear pending normalization state, and invalidate delivery generation through the existing delivery lifecycle.

package/node_modules/@llblab/pi-telegram/docs/architecture.md

@@ -315,14 +315,15 @@ Queue and menu mutations are reachable through Telegram updates handled by the c
 
 ### Compaction And Typing Status
 
-Manual `/compact` requires inline confirmation because accidental taps are disruptive. Confirmed manual compaction and auto-compaction both set the bridge compaction flag, block queued prompt dispatch, retain that flag in explicit diagnostics, and clear it on compact completion, timeout fallback, or session shutdown. Pi owns its terminal compaction lifecycle; pi-telegram keeps `Active` scoped to Telegram-owned work and otherwise preserves the stable connected/leader/follower role.
+Manual `/compact` requires inline confirmation because accidental taps are disruptive. Confirmed manual compaction and auto-compaction both set the bridge compaction flag, block queued prompt dispatch, retain that flag in explicit diagnostics, and clear it on native compact completion or failure, timeout fallback, or session shutdown. Pi owns its terminal compaction lifecycle; pi-telegram keeps `Active` scoped to Telegram-owned work and otherwise preserves the stable connected/leader/follower role. Mid-run threshold compaction reports notices in place between tool output and the next assistant response; compaction observed after terminal assistant output waits for final Telegram delivery so transport chronology matches the terminal.
 
 Native typing during compaction follows connected-instance activity rather than terminal status:
 
 - Confirmed manual `/compact` starts a native `typing` keepalive in the command target and stops it on completion/failure.
 - Automatic/session compaction with an active Telegram turn reuses that turn's target.
 - Automatic/session compaction without an active Telegram turn uses the connected instance's assigned target; an unconnected instance sends nothing.
-- Thread-targeted typing is sent to the concrete thread and mirrored to `All` as the aggregate activity surface; completion, timeout, and shutdown stop the keyed loop.
+- Thread-targeted typing is sent to the concrete thread and mirrored to `All` as the aggregate activity surface; completion, native failure, timeout, and shutdown stop the keyed loop.
+- Pi `ui_prompt_start` pauses active-turn typing while an extension-owned local prompt waits for the operator; `ui_prompt_end` emits the matching Activity boundary and resumes typing.
 
 At every connected instance `agent_start`, the lifecycle binding starts Telegram's native `…typing` indicator in that instance's assigned target, whether the run came from Telegram, the local TUI, or an autonomous continuation such as Grow Loop. Terminal `Active` remains Telegram-turn-specific; the native indicator answers the separate question of whether the instance is doing agent work. Each loop keeps one action in flight, while the leader API runtime coalesces identical chat/thread/action calls across local and follower traffic for two seconds; expired gates prune opportunistically and at most 256 currently active keys are retained. A Telegram 429 response opens the exact action's shared `retry_after` suppression window without scheduling delayed retries or projecting expected activity throttling as a terminal status error. Assistant message start/update hooks still re-arm it during Telegram-owned turns so transient provider/model errors do not leave a continuing run without activity feedback, and agent/session completion stops it.
 

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

@@ -85,6 +85,12 @@ export type TelegramActivityPayload =
         type: "compaction-end";
         reason: "manual" | "threshold" | "overflow" | "unknown";
       }
+    | {
+        type: "ui-prompt-start";
+        kind: "select" | "confirm" | "input" | "editor" | "custom";
+        title?: string;
+      }
+    | { type: "ui-prompt-end" }
     | { type: "agent-end" }
   | { type: "agent-settled" };
 
@@ -440,6 +446,12 @@ export function createTelegramActivityBridgeRuntime(deps: {
     onCompactionAbandoned() {
       getRuntime()?.onCompactionAbandoned();
     },
+    onUiPromptStart(kind, title) {
+      getRuntime()?.onUiPromptStart(kind, title);
+    },
+    onUiPromptEnd() {
+      getRuntime()?.onUiPromptEnd();
+    },
     onAgentEnd() {
       getRuntime()?.onAgentEnd();
     },
@@ -502,6 +514,11 @@ export interface TelegramActivityRuntime {
     reason: "manual" | "threshold" | "overflow" | "unknown",
   ) => void;
   onCompactionAbandoned: () => void;
+  onUiPromptStart: (
+    kind: "select" | "confirm" | "input" | "editor" | "custom",
+    title?: string,
+  ) => void;
+  onUiPromptEnd: () => void;
   onAgentEnd: () => void;
   onAgentSettled: () => void;
   onSessionShutdown: () => void;
@@ -533,6 +550,7 @@ export function createTelegramActivityRuntime(deps: {
   let pendingAssistantSegment: PendingAssistantSegment | undefined;
   let compactionInProgress = false;
   let compactionOwnedActivity = false;
+  let uiPromptInProgress = false;
   const ensureActivity = (
     activeTelegramTarget?: TelegramActivityTarget,
   ): string => {
@@ -592,6 +610,7 @@ export function createTelegramActivityRuntime(deps: {
     pendingAssistantSegment = undefined;
     compactionInProgress = false;
     compactionOwnedActivity = false;
+    uiPromptInProgress = false;
   };
   const abandonCompaction = (): void => {
     if (!compactionInProgress) return;
@@ -685,6 +704,16 @@ export function createTelegramActivityRuntime(deps: {
     onCompactionAbandoned() {
       abandonCompaction();
     },
+    onUiPromptStart(kind, title) {
+      if (!activityId || uiPromptInProgress) return;
+      uiPromptInProgress = true;
+      emit({ type: "ui-prompt-start", kind, title });
+    },
+    onUiPromptEnd() {
+      if (!activityId || !uiPromptInProgress) return;
+      uiPromptInProgress = false;
+      emit({ type: "ui-prompt-end" });
+    },
     onAgentEnd() {
       if (activityId) emit({ type: "agent-end" });
     },

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

@@ -1012,8 +1012,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 +1023,16 @@ 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 agentRunActive = false;
+  let terminalAssistantMessagePendingDelivery = false;
+  const deferredAutomaticCompactionNotices: string[] = [];
   const sendCompactionNotice = async (text: string): Promise<void> => {
     const turn = activeTurnRuntime.get();
     const target = turn?.target ?? proactivePushTargetGetter?.();
@@ -1042,6 +1047,10 @@ export function registerTelegramLifecycleRuntimeHooks({
       });
     }
   };
+  const flushDeferredAutomaticCompactionNotices = async (): Promise<void> => {
+    const notices = deferredAutomaticCompactionNotices.splice(0);
+    for (const notice of notices) await sendCompactionNotice(notice);
+  };
   const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
     isContextActive: isSessionContextActive,
     setCompactionInProgress: lifecycle.setCompactionInProgress,
@@ -1054,6 +1063,7 @@ export function registerTelegramLifecycleRuntimeHooks({
     recordRuntimeEvent,
     onCompactionAbandoned: () => {
       observedAutomaticCompaction = false;
+      deferredAutomaticCompactionNotices.length = 0;
       activityRuntime.onCompactionAbandoned();
     },
   });
@@ -1088,6 +1098,10 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityVerbosityRuntime?.reset();
       assistantOutputRuntime.stop();
       observedAutomaticCompaction = false;
+      agentRunActive = false;
+      terminalAssistantMessagePendingDelivery = false;
+      uiPromptActive = false;
+      deferredAutomaticCompactionNotices.length = 0;
       compactionObserver.onSessionShutdown();
       if (event.reason === "quit" && disconnectOnQuit) {
         try {
@@ -1109,11 +1123,20 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
       if (shouldNotify) {
-        await waitForActiveTurnDelivery();
-        if (!isSessionContextActive(ctx)) return;
-        await sendCompactionNotice(
-          Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
-        );
+        if (
+          activeTurnRuntime.has() &&
+          terminalAssistantMessagePendingDelivery
+        ) {
+          deferredAutomaticCompactionNotices.push(
+            Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
+          );
+        } else {
+          await waitForActiveTurnDelivery();
+          if (!isSessionContextActive(ctx)) return;
+          await sendCompactionNotice(
+            Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
+          );
+        }
       }
     },
     async onSessionCompact(event, ctx) {
@@ -1122,13 +1145,39 @@ export function registerTelegramLifecycleRuntimeHooks({
       compactionObserver.onSessionCompact(event, ctx);
       if (observedAutomaticCompaction) {
         observedAutomaticCompaction = false;
-        await sendCompactionNotice(
-          Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
-        );
+        if (deferredAutomaticCompactionNotices.length > 0) {
+          deferredAutomaticCompactionNotices.push(
+            Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
+          );
+        } else {
+          await sendCompactionNotice(
+            Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
+          );
+        }
+      }
+    },
+    async onSessionCompactFailed(event, ctx) {
+      if (!isSessionContextActive(ctx)) return;
+      const shouldNotify = observedAutomaticCompaction;
+      const deferredNotices = deferredAutomaticCompactionNotices.splice(0);
+      const shouldDefer =
+        deferredNotices.length > 0 ||
+        (activeTurnRuntime.has() && 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;
+      agentRunActive = true;
+      terminalAssistantMessagePendingDelivery = false;
       await agentStartWithDedupReset(event, ctx);
       activityRuntime.onAgentStart(activeTurnRuntime.get()?.target);
       startAgentActivityTypingLoop(ctx);
@@ -1173,10 +1222,39 @@ 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 (agentRunActive) startAgentActivityTypingLoop(ctx);
+      updateStatus(ctx);
+    },
     async onAgentEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
+      agentRunActive = false;
       activityRuntime.onAgentEnd();
       await agentLifecycleHooks.onAgentEnd(event, ctx);
+      if (deferredAutomaticCompactionNotices.length > 0) {
+        await waitForActiveTurnDelivery();
+        if (!isSessionContextActive(ctx)) return;
+        await flushDeferredAutomaticCompactionNotices();
+      }
+      terminalAssistantMessagePendingDelivery = false;
     },
     async onAgentSettled(event, ctx) {
       if (!isSessionContextActive(ctx)) return;

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.39.4",
+  "version": "0.40.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": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -41,9 +41,9 @@
   ],
   "dependencies": {
     "@llblab/pi-actors": "0.50.0",
-    "@llblab/pi-codex-usage": "0.9.3",
+    "@llblab/pi-codex-usage": "0.9.4",
     "@llblab/pi-grow-loop": "0.7.3",
-    "@llblab/pi-telegram": "0.39.4"
+    "@llblab/pi-telegram": "0.40.0"
   },
   "bundledDependencies": [
     "@llblab/pi-actors",