@llblab/pi-kit 0.1.13 → 0.3.0

package/node_modules/@llblab/pi-telegram/docs/public-api.md

@@ -50,7 +50,7 @@ Stable commands inside the paired Telegram DM:
 
 - `/start` — pair when needed and open the main application menu.
 - `/compact` — open confirmation and compact when idle.
-- `/next` — dispatch the next queued turn, aborting active work first when needed.
+- `/next` — dispatch the next queued turn, aborting active work first when needed; one Pi-aligned informational reply anchors to a pre-abort snapshot of the Telegram turn or falls back to the command, and aborted pending assistant text is suppressed.
 - `/continue` — enqueue a priority `continue` prompt.
 - `/abort` — abort active work and keep the queue; abort-history is scoped to Telegram-owned active turns.
 - `/stop` — abort active Telegram-owned work and clear waiting Telegram queue items.
@@ -65,8 +65,8 @@ This command surface is a mobile companion subset, not a raw terminal-command br
 - `telegram_attach(paths, chat_id?, thread_id?, caption?)` is the stable artifact delivery tool for generated files. During Telegram turns it queues files for the active reply; with `assistant.rendering: "rich"`, exactly one PNG/JPEG, MP4, or MP3 artifact plus non-empty final Markdown can become one reply-anchored Rich Message. HTML mode, multiple/unsupported files, Guest Mode, and voice outputs retain their established paths. Outside Telegram turns the tool sends files directly to the paired/default chat, the registered follower's assigned thread, or an explicit `chat_id` plus optional `thread_id` when this Pi instance owns `/telegram-connect` or is registered with the multi-instance bus.
 - `telegram_message(text, chat_id?, thread_id?)` sends a direct Telegram Markdown message when this Pi instance owns `/telegram-connect` or is registered with the multi-instance bus. During an active Telegram turn, omitted targeting and an explicit target equal to that turn are rejected so the ordinary final-reply path remains the sole current-target response; an explicit different chat/thread target remains allowed for requested cross-target delivery. Outside active turns, paired/default local/TUI delivery remains unchanged. Top-level `telegram_button` comments inside `text` are parsed with the same planner used for normal replies and attached to that message; buttons are never standalone Telegram messages.
 - The bundled `telegram-bridge` Skill owns action syntax, target routing, Threaded Mode, formatting, Generative App operation, and profile-specific debugging guidance. The regular prompt routes applicable turns to that Skill. `telegram_attach`, `telegram_bind`, and `telegram_message` remain registered but are model-active only while this instance owns direct transport or holds a live follower registration; disconnect/loss suppresses their schemas and prompt metadata, and recovery restores only the operator's previously active pi-telegram subset.
-- `telegram_voice` hidden comments request Telegram-native voice delivery through either a JSON object or double-quoted attributes. Equivalent `text` or `value` supplies the spoken payload; explicit `text` takes precedence.
-- `telegram_button` hidden comments create inline buttons whose taps enqueue prompts. One marker accepts a JSON object, adaptive JSON/CML matrix, positional [Compact Matrix Literal](./compact-matrix-literal.md), or double-quoted attributes; `telegram_buttons` is an exact plural alias. Named JSON objects and positional cells may coexist in one matrix or row, and commas are optional only between completed elements. Top-level cells become full-width rows, while nested rows group one or more buttons horizontally without an artificial parser-width cap. CML uses `{value}`, `{label|prompt}`, or `{label|prompt|selected_style}`; the optional third atom requires a prompt and accepts only `primary`, `success`, or `danger`. It trims atom boundaries and supports only the minimal escapes `\|`, `\}`, and `\\`. Prefer one matrix comment for multiple buttons. Use JSON `label` plus `prompt`, or `value` when both strings are identical. Action markers are colon-free; colon-prefixed payloads are rejected. Use top-level column-zero comments outside code, quotes, lists, and indented examples; do not emit standalone button actions.
+- `telegram_voice` hidden comments request Telegram-native voice delivery through `{text}`, `{text|lang}`, `{text|lang|rate}`, or a JSON object. JSON is the fallback for multiline content, named fields, or escaping; equivalent `text` or `value` supplies the spoken payload, with explicit `text` taking precedence.
+- `telegram_button` hidden comments create inline buttons whose taps enqueue prompts. One marker accepts a JSON object, adaptive JSON/CML matrix, or positional [Compact Matrix Literal](./compact-matrix-literal.md). Named JSON objects and positional cells may coexist in one matrix or row; separators are optional and one trailing comma is tolerated at matrix, row, and JSON-object boundaries. Top-level cells become full-width rows, while nested rows group one or more buttons horizontally without an artificial parser-width cap. CML uses `{value}`, `{label|prompt}`, or `{label|prompt|selected_style}`; the optional third atom requires a prompt and accepts only `primary`, `success`, or `danger`. It trims atom boundaries and supports only the minimal escapes `\|`, `\}`, and `\\`. Prefer one matrix comment for multiple buttons. Use JSON `label` plus `prompt`, or `value` when both strings are identical. Action markers are colon-free; colon-prefixed payloads are rejected. Use top-level column-zero comments outside code, quotes, lists, and indented examples; do not emit standalone button actions.
 
 Prompt guidance is context-aware: local/TUI prompts see only explicit direct-delivery guidance, while Telegram-originated turns receive the full action-comment syntax and phone-width output contract.
 
@@ -94,7 +94,6 @@ interface TelegramConfig {
   assistant?: {
     draftPreviews?: boolean;
     rendering?: "rich" | "html";
-    proactivePush?: boolean;
     activity?: "quiet" | "thinking" | "tools" | "verbose";
     timeInjection?: "hidden" | "always" | "interval";
   };
@@ -117,10 +116,10 @@ The file is global across Pi instances and contains configuration only. The per-
 Hidden/default semantics are represented by absence:
 
 - `threads.automaticCleanup` defaults to `true`; graceful Pi quit deletes the instance's bound Threaded Mode tab without prompting but preserves the owner slot as independent restart intent. Set it to `false`, or use `🧹 Thread cleanup` in Telegram Settings, to preserve the tab too. A confirmed `/telegram-disconnect`, unlike quit, clears restart ownership. Settings views and cleanup reload shared config before evaluating this switch, so another live Pi instance's update takes effect without restarting. Confirmed leader/follower teardown persists an exact target/runtime-generation cleanup intent before Telegram deletion; an interrupted attempt remains retryable by the current or successor leader under current authority and clears only after confirmed deletion. A same-profile replacement leader first adopts any still-active binding and cancels its superseded cleanup, so startup never deletes and recreates a reusable thread. If a follower's graceful envelope is missed, the leader may create the same fenced cleanup only after its heartbeat is stale, the OS confirms the exact registered PID no longer exists, cleanup remains enabled, and no replacement registration can overtake deletion. Heartbeat loss alone, live/unknown process liveness, IPC failure, and auth failure remain non-destructive. Invalid-config recovery makes the setting unresolved and therefore skips destructive cleanup. Manual `/telegram-disconnect` keeps its confirmation and teardown behavior regardless of this setting.
-- Every complete intermediate assistant text block from a Telegram-originated turn is delivered once to its immutable target before the existing final reply. This active-turn commentary path remains enabled when `assistant.proactivePush` is `false`; final and terminal-partial segments stay with settlement to prevent duplicate replies. `assistant.proactivePush` defaults to `true` only for local/autonomous work: omit it to project every completed public block, including commentary and the final block, or set it explicitly to `false` to disable that projection. Both paths exclude token deltas, hidden reasoning, tool calls/arguments/results, empty blocks, unknown sources, and stale authority. Projection uses the configured Rich or HTML assistant renderer and binds admitted work to the exact target, profile/token transport generation, direct leader epoch or follower registration generation, and session generation. The old top-level `proactivePush` key is ignored; move the setting manually under `assistant`.
+- Every complete intermediate assistant text block from a Telegram-originated turn is delivered once to its immutable target before the existing final reply; final and terminal-partial segments stay with settlement to prevent duplicate replies. While Telegram transport remains authorized, local/autonomous work also projects every completed public block, including commentary and the final block. This connected companion projection is always active and excludes token deltas, hidden reasoning, tool calls/arguments/results, empty blocks, unknown sources, and stale authority. Projection uses the configured Rich or HTML assistant renderer and binds admitted work to the exact target, profile/token transport generation, direct leader epoch or follower registration generation, and session generation. Retired top-level and `assistant.proactivePush` keys are ignored; the nested key is removed during config normalization.
 - `assistant.activity` accepts exactly `"quiet"`, `"thinking"`, `"tools"`, or `"verbose"`; omitted values default to `"verbose"`, explicit values remain unchanged, and invalid values fail closed to `"quiet"`. Each Pi process reloads the shared file-backed value at `agent-start`, so multi-instance activity isolation never relies on a stale process-local config snapshot. `thinking` shows only provider-exposed thinking, `tools` shows only completed tool activity, and `verbose` shows both. Thinking uses persistent ordinary HTML `sendMessage`/`editMessageText` disclosure with a standard expandable blockquote, a `🧠` header carrying the current Pi thinking level, and bounded redacted text whose inline Markdown renders as Telegram HTML. Tools use native Rich Messages with one header followed by separate closed details and JSON pre blocks for bounded redacted arguments, retained updates, and results/errors. Thinking disables link previews on every HTML send/edit and neutralizes HTTP(S) auto-link detection; Rich tool output disables automatic entity detection, with the same protections retained by its HTML fallback. Consecutive tools coalesce only inside the same ordered activity segment and bounded message. Legacy `assistant.activityVerbosity` is read only when `assistant.activity` is absent and is removed by the next Activity Settings write.
 - Voice Reply `hidden`: no `voice.replyMode` key is persisted; legacy `manual` resolves to this silent default. `mirror` adds `[voice] delivery: automatic voice` only to voice/audio-input turns, while `always` adds the same effective line to every Telegram turn.
-- Agent activity status is not configurable in this release. Telegram uses native `sendChatAction(typing)` / product `...active` status as the only automatic in-chat work signal before the final reply.
+- Agent activity status is not configurable. While Telegram transport remains authorized, Telegram uses native `sendChatAction(typing)` / product `...active` status as the automatic in-chat work signal for unsettled agent and compaction work. Extension-owned blocking UI prompts pause it and completion resumes it while either work owner remains active.
 - `assistant.timeInjection` accepts `hidden`, `always`, or `interval` and defaults to `interval` when absent without migrating an explicit stored value. Settings writes the selected value there, including `hidden`; the old `time.injectionMode` key is ignored and is not migrated. `time.interval` remains the optional interval duration in milliseconds.
 
 With `assistant.rendering: "rich"` (the default), assistant Markdown delivery is native: final replies are sent as `InputRichMessage.markdown` via `sendRichMessage`, and draft previews use `sendRichMessageDraft` when a structurally closed preview frame is available. Draft-frame failures are recorded and skipped rather than converted into raw plain preview messages, because partial Markdown can be temporarily invalid while the final answer remains valid. Long native replies are split at Telegram Rich Message transport limits, with oversized fenced code, display-math, and fully wrapped inline-formatting blocks rewrapped per chunk so persisted chunks remain structurally valid. Guest replies use `InputRichMessageContent` in `answerGuestQuery` results. Bridge-owned UI surfaces such as menus, status, queue controls, commands, and sections keep explicit Telegram HTML/plain rendering by default because those texts are authored by the bridge or companion extensions for Telegram UI. Companion extension sections may explicitly request `"markdown"`, `"html"`, or `"plain"` per view. `assistant.rendering: "html"` keeps the compatibility path that converts assistant Markdown to Telegram HTML before ordinary message delivery. The bridge sets `skip_entity_detection: true` for assistant and guest Markdown so technical text such as `/commands`, hashtags, URLs, phone numbers, and card-like numbers does not gain unintended automatic entities; explicit Markdown links still belong in the Markdown source.
@@ -337,7 +336,7 @@ Contract:
 - Providers are synchronous because `/start` status text is rendered inline with the menu.
 - Return `undefined` when the line is not relevant for the active model.
 - Provider failures are isolated and skipped so optional companion status cannot break the core Telegram menu.
-- The bridge renders rows as `<Label>: <value>` in the same HTML status block as Status, Usage, Cost, and Context, capitalizing the first label character for Telegram UI consistency.
+- The bridge renders rows as `<Label>: <value>` in the same HTML status block as Status, Tokens, Cache, Cost, and Context, capitalizing the first label character for Telegram UI consistency. Tokens contains only `↑` input and `↓` output totals. Cache groups `R` cache-read tokens, `W` cache-write tokens, and `CH` for the latest assistant request's `cacheRead / (input + cacheRead + cacheWrite)`, shown to one decimal place only after the session reports cache activity. These precise labels avoid conflating token telemetry with companion-provided usage-limit rows.
 
 ## Updates
 

package/node_modules/@llblab/pi-telegram/docs/ui-style.md

@@ -32,7 +32,6 @@ Use emoji as stable semantic markers, not decoration. Emoji carry transportable
 | `🧩` | Extension-provided surface | Extension command examples, extension section examples | Companion extensions may choose their own emoji, but `🧩` means generic extension/plugin. |
 | `👄` | Voice reply policy | Voice reply settings row and detail card | Not a generic audio attachment marker. |
 | `🕒` | Time injection / wall-clock context | Time injection settings row and detail card | Clock-face marker with hands; not a generic duration/progress marker. |
-| `📌` | Proactive push / pinned behavior | Proactive push settings row and detail card | Not generic active/selected state. |
 | `🔬` | Activity / technical detail | Activity settings row and detail card | Chooses quiet, thinking, tools, or verbose bridge activity; not a generic diagnostics marker. |
 | `🧠` | Model thinking controls | Thinking menus and status rows | Thinking activity quotes omit this icon and their header entirely to minimize chat height. |
 | `📎` | Attachment | Attachment summaries, queue rows for attachment-only turns | Not for thread binding. |
@@ -138,7 +137,6 @@ Rules:
 Examples:
 
 - `🟢 Active` — model detail, navigates back to model list
-- `📌 Proactive push: On` — settings row, opens the toggle submenu
 - `👄 Voice reply: Mirror` — settings row, opens the option list
 
 ## Boolean Toggles
@@ -199,7 +197,7 @@ Examples:
 
 ## Generated Prompt Buttons
 
-A button-only assistant reply uses the standard Rich Markdown heading `☑️ **Choose an option:**`: semantic icon first, one space, bold heading text, and a final colon. Assistant-generated prompt buttons use the default app style before selection. After queue admission, edit only the selected button to its agent-configured `selected_style`: `primary` (default/blue), `success` (green), or `danger` (red). Preserve its agent-authored text and emoji, leave other choices at their default style, and always queue the selected prompt regardless of color. The callback acknowledgement remains the compatibility fallback when a client does not render button styles.
+A button-only assistant reply uses the standard Rich Markdown heading `☑️ **Choose an option:**`: semantic icon first, one space, bold heading text, and a final colon. Every generated human-readable action label starts with the most semantically appropriate emoji, one ASCII space, then concise action text. Emoji selection is part of authoring the control, including compact label-equals-prompt forms. Emoji-free text remains a syntax-compatible fallback only when no honest semantic marker exists after considering the action, domain, and state—not merely for convenience or label pressure; genuine coordinate and symbolic spatial controls retain their established grammar. Generated non-spatial controls default to vertical full-width buttons represented as top-level matrix cells. Nested row arrays are a compact-peer exception only when every label is unmistakably short—roughly 15 visible characters or fewer including emoji and space; this is a judgment heuristic rather than a mechanical count, and any plausible ellipsis or wrapping risk returns the controls to vertical rows. Assistant-generated prompt buttons use the default app style before selection. After queue admission, edit only the selected button to its agent-configured `selected_style`: `primary` (default/blue), `success` (green), or `danger` (red). Preserve its agent-authored text and emoji, leave other choices at their default style, and always queue the selected prompt regardless of color. The callback acknowledgement remains the compatibility fallback when a client does not render button styles.
 
 ## Navigation
 
@@ -225,8 +223,9 @@ Message cards and standalone informational notices sent by the bot should start
 Rules:
 
 - Start with a bold heading or, for dialogs, a bold question.
-- Format standalone notices as one fully bold line: relevant emoji, one space, concise sentence, and terminal period or colon.
-- Apply the same hierarchy to success, progress, empty, busy, unavailable, cancellation, and failure notices; do not bold only a fragment of a standalone notice.
+- Format standalone notices as one fully bold line: relevant emoji, one space, concise sentence, and terminal period. Menu or chooser headings use the same fully bold form but end in a colon when controls or detail follow.
+- Keep the emoji and complete sentence or heading inside the single bold span; do not bold only a fragment. A material name or phrase may receive nested italic emphasis without breaking the outer bold hierarchy—for example `<b>📡 Instance <i>Cedar</i> connected.</b>`.
+- Apply the same hierarchy to success, progress, empty, busy, unavailable, cancellation, and failure notices.
 - Callback alerts remain plain text because Telegram does not support rich text there, but still keep the relevant emoji and concise sentence.
 - Setting detail cards may include an emoji in the heading, then a colon and the current value in `<code>`.
 - Explain what the setting does and what the options mean only as much as needed.

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

@@ -1,6 +1,6 @@
 # Voice Integration
 
-Voice messages flow through an **inbound transcription → outbound voice reply** pipeline. This document describes the bridge's role in that pipeline; provider-specific mechanics (TTS/STT backends, voice IDs, languages) are owned by voice provider extensions. This is a first-class extension surface: one companion extension can provide STT fallbacks for inbound voice/audio files and TTS fallbacks for outbound Telegram voice replies without owning a second bot polling loop.
+Voice messages flow through an **inbound transcription → outbound voice reply** pipeline. This document describes the bridge's role in that pipeline; provider-specific mechanics (TTS/STT backends, voice IDs, languages) are owned by configured handler scripts or voice provider extensions. This is a first-class extension surface: one companion extension can provide STT fallbacks for inbound voice/audio files and TTS fallbacks for outbound Telegram voice replies without owning a second bot polling loop.
 
 ## Overview
 
@@ -18,7 +18,17 @@ Use the smallest path that fits the operator's available capabilities:
 2. **Companion extension:** Register programmatic STT/TTS providers when installation, provider-owned settings, lifecycle integration, or zero-config reuse justifies code.
 3. **Hybrid:** Keep explicit operator command templates first and let installed providers supply progressive fallbacks.
 
-pi-telegram does not catalog speech providers. Configuration agents should discover applicable Skills or trusted local executables, verify required environment variables by presence without exposing values, preserve unrelated `telegram.json` state, ensure TTS ends as OGG/Opus, and test each stage before the live Telegram path. `hidden` remains the safe and useful default: it disables only automatic voice replies, while explicit `telegram_voice` actions continue to use the configured synthesis pipeline.
+pi-telegram does not maintain a built-in or exhaustive speech-provider catalog. Configuration agents should discover applicable Skills or trusted local executables, verify required environment variables by presence without exposing values, preserve unrelated `telegram.json` state, ensure TTS ends as OGG/Opus, and test each stage before the live Telegram path. `hidden` remains the safe and useful default: it disables only automatic voice replies, while explicit `telegram_voice` actions continue to use the configured synthesis pipeline.
+
+### Ready-made command-template examples
+
+The public [`llblab/skills`](https://github.com/llblab/skills) repository provides three maintained Skills with standalone scripts that can be wired directly into `telegram.json`; no additional Pi extension or local inference engine is required:
+
+- [`groq-stt`](https://github.com/llblab/skills/tree/main/groq-stt) — Groq Whisper speech-to-text through `scripts/transcribe.sh`. It outputs plain transcript text and requires `GROQ_API_KEY` in the Pi process environment.
+- [`mistral-stt`](https://github.com/llblab/skills/tree/main/mistral-stt) — Mistral Voxtral speech-to-text through `scripts/transcribe.sh`. It outputs plain transcript text and requires `MISTRAL_API_KEY` in the Pi process environment.
+- [`edge-tts`](https://github.com/llblab/skills/tree/main/edge-tts) — Microsoft Edge neural text-to-speech through `scripts/say.sh`. It requires internet access but no account or API key and can write MP3 output for the outbound pipeline.
+
+The two hosted STT options avoid running a local transcription model and offer useful free-tier capacity after provider registration; provider limits and terms may change. Install or clone the Skill repository, verify the required API-key variable by presence without printing its value, and point the matching `inboundHandlers` template at the Skill's transcription script. For Edge TTS, point an `outboundHandlers` voice pipeline at `say.sh --file - --write-media {mp3}`, then convert `{mp3}` to `{ogg}` with ffmpeg as shown in [Outbound Voice Handlers](#outbound-voice-handlers), because Telegram native voice notes require OGG/Opus. Read each linked Skill's current `SKILL.md` for its exact CLI, defaults, dependencies, and optional language/model controls.
 
 ## Voice Detection
 

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

@@ -548,7 +548,6 @@ export default function (pi: Pi.ExtensionAPI) {
   } = Bindings.createTelegramActivityBindingRuntime({
     generation: deliveryGenerationSeed,
     assistantOutput: {
-      isEnabled: configControls.isProactivePushEnabled,
       authority: {
         getPreferredTarget: proactivePushTargetGetter,
         getFallbackChatId: proactivePushChatIdGetter,

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

@@ -428,6 +428,9 @@ export function createTelegramActivityBridgeRuntime(deps: {
     onAssistantEvent(event) {
       getRuntime()?.onAssistantEvent(event);
     },
+    onAssistantMessageEnd(stopReason) {
+      getRuntime()?.onAssistantMessageEnd(stopReason);
+    },
     onToolStart(event) {
       getRuntime()?.onToolStart(event);
     },
@@ -491,6 +494,7 @@ export interface TelegramActivityRuntime {
   recordInputSource: (source: TelegramActivityInputSource) => void;
   onAgentStart: (activeTelegramTarget?: TelegramActivityTarget) => void;
   onAssistantEvent: (event: TelegramAssistantStreamEvent) => void;
+  onAssistantMessageEnd: (stopReason?: string) => void;
   onToolStart: (event: {
     toolCallId: string;
     toolName: string;
@@ -677,6 +681,9 @@ export function createTelegramActivityRuntime(deps: {
       }
       if (event.type === "error") flushPendingSegment("terminal-partial");
     },
+    onAssistantMessageEnd(stopReason) {
+      if (stopReason === "aborted") pendingAssistantSegment = undefined;
+    },
     onToolStart(event) {
       emit({ type: "tool-start", ...event });
     },
@@ -741,7 +748,6 @@ export interface TelegramAssistantOutputRuntime {
 }
 
 export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(deps: {
-  isEnabled: () => boolean;
   captureAuthority?: () => TAuthority;
   isAuthorityActive?: (authority: TAuthority) => boolean;
   canDeliver: (event: TelegramAssistantSegmentEvent) => boolean;
@@ -761,10 +767,9 @@ export function createTelegramAssistantOutputRuntime<TAuthority = undefined>(dep
   const admitted = new Set<string>();
   const isEligibleEvent = (event: TelegramAssistantSegmentEvent): boolean =>
     (event.source === "telegram" && event.placement === "intermediate") ||
-    ((event.source === "local" ||
-      event.source === "autonomous" ||
-      event.source === "unknown") &&
-      deps.isEnabled());
+    event.source === "local" ||
+    event.source === "autonomous" ||
+    event.source === "unknown";
 
   return {
     start() {

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?.();
@@ -1030,7 +1028,7 @@ export function registerTelegramLifecycleRuntimeHooks({
     });
   };
   let observedAutomaticCompaction = false;
-  let agentRunActive = false;
+  let agentWorkActive = false;
   let terminalAssistantMessagePendingDelivery = false;
   const deferredAutomaticCompactionNotices: string[] = [];
   const sendCompactionNotice = async (text: string): Promise<void> => {
@@ -1098,7 +1096,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityVerbosityRuntime?.reset();
       assistantOutputRuntime.stop();
       observedAutomaticCompaction = false;
-      agentRunActive = false;
+      agentWorkActive = false;
       terminalAssistantMessagePendingDelivery = false;
       uiPromptActive = false;
       deferredAutomaticCompactionNotices.length = 0;
@@ -1123,10 +1121,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
       if (shouldNotify) {
-        if (
-          activeTurnRuntime.has() &&
-          terminalAssistantMessagePendingDelivery
-        ) {
+        if (terminalAssistantMessagePendingDelivery) {
           deferredAutomaticCompactionNotices.push(
             Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
           );
@@ -1161,8 +1156,7 @@ export function registerTelegramLifecycleRuntimeHooks({
       const shouldNotify = observedAutomaticCompaction;
       const deferredNotices = deferredAutomaticCompactionNotices.splice(0);
       const shouldDefer =
-        deferredNotices.length > 0 ||
-        (activeTurnRuntime.has() && terminalAssistantMessagePendingDelivery);
+        deferredNotices.length > 0 || terminalAssistantMessagePendingDelivery;
       compactionObserver.onSessionCompactFailed(event, ctx);
       if (!shouldNotify) return;
       const notice = event.aborted
@@ -1176,7 +1170,7 @@ export function registerTelegramLifecycleRuntimeHooks({
     },
     async onAgentStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
-      agentRunActive = true;
+      agentWorkActive = true;
       terminalAssistantMessagePendingDelivery = false;
       await agentStartWithDedupReset(event, ctx);
       activityRuntime.onAgentStart(activeTurnRuntime.get()?.target);
@@ -1224,6 +1218,9 @@ export function registerTelegramLifecycleRuntimeHooks({
     },
     onMessageEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
+      if (event.message.role === "assistant") {
+        activityRuntime.onAssistantMessageEnd(event.message.stopReason);
+      }
       terminalAssistantMessagePendingDelivery =
         event.message.role === "assistant" &&
         event.message.stopReason !== "toolUse" &&
@@ -1241,24 +1238,26 @@ export function registerTelegramLifecycleRuntimeHooks({
       if (!isSessionContextActive(ctx)) return;
       uiPromptActive = false;
       activityRuntime.onUiPromptEnd();
-      if (agentRunActive) startAgentActivityTypingLoop(ctx);
+      if (agentWorkActive || lifecycle.isCompactionInProgress()) {
+        startAgentActivityTypingLoop(ctx);
+      }
       updateStatus(ctx);
     },
     async onAgentEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
-      agentRunActive = false;
       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();
       }
       terminalAssistantMessagePendingDelivery = false;
-    },
-    async onAgentSettled(event, ctx) {
-      if (!isSessionContextActive(ctx)) return;
-      await agentLifecycleHooks.onAgentSettled(event, ctx);
+      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/commands.ts

@@ -1049,6 +1049,9 @@ export interface TelegramCommandRuntimeDeps<
     text: string,
     options?: { parseMode?: "HTML" },
   ) => Promise<void>;
+  getActiveTurnReply?: () =>
+    | ((text: string, options?: { parseMode?: "HTML" }) => Promise<void>)
+    | undefined;
   sendInteractiveMessage?: TelegramCompactConfirmationDeps["sendInteractiveMessage"];
   assertExecutionCurrent?: (message: TMessage) => void;
 }
@@ -1272,6 +1275,9 @@ export async function handleTelegramNextCommand(deps: {
     text: string,
     options?: { parseMode?: "HTML" },
   ) => Promise<void>;
+  getActiveTurnReply?: () =>
+    | ((text: string, options?: { parseMode?: "HTML" }) => Promise<void>)
+    | undefined;
 }): Promise<void> {
   deps.clearPendingModelSwitch();
   if (!deps.hasQueuedItems()) {
@@ -1282,16 +1288,19 @@ export async function handleTelegramNextCommand(deps: {
     return;
   }
   if (!deps.isIdle() && deps.hasAbortHandler()) {
+    const activeTurnReply = deps.getActiveTurnReply?.();
     deps.clearFoldForDispatch();
     deps.abortCurrentTurn();
     deps.updateStatus();
-    await deps.sendTextReply(
-      formatTelegramInformationHeading(
-        "⏩",
-        "Aborted! Dispatching next queued turn.",
-      ),
-      { parseMode: "HTML" },
+    const notice = formatTelegramInformationHeading(
+      "⏩",
+      "Operation aborted. Dispatching next queued turn.",
     );
+    if (activeTurnReply) {
+      await activeTurnReply(notice, { parseMode: "HTML" });
+    } else {
+      await deps.sendTextReply(notice, { parseMode: "HTML" });
+    }
     return;
   }
   if (!deps.isIdle()) {
@@ -1799,6 +1808,7 @@ async function handleTelegramCommandRuntime<
             deps.setFoldQueuedPromptsIntoHistory(false),
           updateStatus: updateStatusFor(commandCtx),
           sendTextReply: sendReplyFor(nextMessage),
+          getActiveTurnReply: deps.getActiveTurnReply,
         });
       },
       handleContinue: async (nextMessage, commandCtx) => {

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/media.ts

@@ -366,6 +366,7 @@ export function extractTelegramReplyContextText(
 export function buildTelegramReplyContextBlock(
   message: TelegramMediaMessage,
   replyFiles: Pick<DownloadedTelegramFile, "path">[] = [],
+  replyOutputs: readonly string[] = [],
 ): string {
   const from = formatTelegramUser(message.reply_to_message?.from);
   const header = from ? `[reply|from:${from}]` : "[reply]";
@@ -379,10 +380,19 @@ export function buildTelegramReplyContextBlock(
     ? replyFiles.map((file) => `- /${basename(file.path)}`)
     : replyFiles.map((file) => `- ${file.path}`);
   const replyBlock = text ? `${header} ${text}` : header;
+  const sections = [replyBlock];
   if (fileLines.length > 0) {
-    return `${replyBlock}\n\n${attachmentHeader}\n${fileLines.join("\n")}`;
+    sections.push(`${attachmentHeader}\n${fileLines.join("\n")}`);
+  }
+  if (replyOutputs.length > 0) {
+    const outputHeader = `[outputs${from ? `|from:${from}` : ""}]`;
+    sections.push(
+      `${outputHeader}\n${replyOutputs.map((output) => `- ${output}`).join("\n")}`,
+    );
+  }
+  if (text || fileLines.length > 0 || replyOutputs.length > 0) {
+    return sections.join("\n\n");
   }
-  if (text) return replyBlock;
   return "";
 }