@llblab/pi-kit 0.1.12 → 0.1.13

package/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 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.

package/README.md

@@ -9,7 +9,7 @@
 | `@llblab/pi-actors` | `0.50.0` | Extension and Skills |
 | `@llblab/pi-codex-usage` | `0.9.4` | Extension |
 | `@llblab/pi-grow-loop` | `0.7.3` | Extension and Skills |
-| `@llblab/pi-telegram` | `0.39.5` | 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-telegram/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 > 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.

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,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 agentRunActive = false;
+  let terminalAssistantMessagePendingDelivery = false;
   const deferredAutomaticCompactionNotices: string[] = [];
   const sendCompactionNotice = async (text: string): Promise<void> => {
     const turn = activeTurnRuntime.get();
@@ -1094,6 +1098,9 @@ 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) {
@@ -1116,7 +1123,10 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
       if (shouldNotify) {
-        if (activeTurnRuntime.has()) {
+        if (
+          activeTurnRuntime.has() &&
+          terminalAssistantMessagePendingDelivery
+        ) {
           deferredAutomaticCompactionNotices.push(
             Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
           );
@@ -1135,10 +1145,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 +1156,28 @@ export function registerTelegramLifecycleRuntimeHooks({
         }
       }
     },
+    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);
@@ -1195,8 +1222,31 @@ 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) {
@@ -1204,6 +1254,7 @@ export function registerTelegramLifecycleRuntimeHooks({
         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.5",
+  "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.12",
+  "version": "0.1.13",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -43,7 +43,7 @@
     "@llblab/pi-actors": "0.50.0",
     "@llblab/pi-codex-usage": "0.9.4",
     "@llblab/pi-grow-loop": "0.7.3",
-    "@llblab/pi-telegram": "0.39.5"
+    "@llblab/pi-telegram": "0.40.0"
   },
   "bundledDependencies": [
     "@llblab/pi-actors",