@llblab/pi-kit 0.17.1 → 0.18.0

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.18.0 - 2026-09-18
+
+- `Telegram Lifecycle Gateway`: Advances the exact Telegram pin to `0.50.0`, replacing the session-specific technical command with one guarded internal gateway for runtime-armed lifecycle actions while preserving `/new` settlement, continuity, and terminal-result guarantees.
+- `Thinking Cadence`: Buffers the first Telegram thinking frame for two seconds and throttles later updates to the same two-second cadence as answer drafts, while still flushing remaining reasoning when the block completes.
+- `Package Cohort`: Keeps every other bundled package at its current exact version; the package set, resource inventory, and explicit load order remain unchanged.
+
 ## 0.17.1 - 2026-09-18
 
 - `State Flow Activation Hotfixes`: Advances the exact State Flow pin to `0.16.2`, allowing resumed activation to reassert its selected session cohort and allowing passive global memory before a new CWD has materialized, while retaining fail-closed handling for genuinely incomplete ownership.

package/README.md

@@ -15,7 +15,7 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.10.0` | Compact Codex/Spark subscription-limit and Business credit-usage status |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.8.1` | Visible continuation scheduling and bounded worker Skills |
 | [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.16.2` | Incremental scoped state/context/memory compiler with proportional operational guidance, intentional agency, reactive dangling-reference diagnostics, compiled runtime delivery, safe compaction, and exact publication |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.49.0` | Telegram companion with native fresh-session replacement, adaptive Thread continuity, exact queues, files, voice, controls, and Generative Apps guidance |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.50.0` | Telegram companion with native fresh-session replacement, a guarded internal lifecycle gateway, buffered thinking cadence, adaptive Thread continuity, exact queues, files, voice, controls, and Generative Apps guidance |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.

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

@@ -121,7 +121,7 @@ The detailed map is canonical in [`docs/architecture.md`](./docs/architecture.md
 - Command templates remain compact and shell-free. Use string leaves or ordered `template` arrays; shell operators are not an execution contract. Examples use portable executable placeholders, never machine-local paths.
 - `telegram_attach` is the canonical file path and `telegram_message` the direct Markdown text/buttons path. Both require current direct or registered-follower authority and must not replace the normal active-turn reply.
 - Inbound handlers transform text/media before queueing; outbound handlers precede programmatic/provider fallbacks. Public contracts and ordering live in `docs/inbound.md`, `docs/outbound.md`, and `docs/public-api.md`.
-- Pi integration uses public hooks and APIs. Telegram `/new` is scheduled against the exact durable update, dispatched only after that update is removed from the journal, and then routed through an internal Pi command via `pi.sendUserMessage(..., { expandPromptTemplates: true })`; the command handler receives the real `ExtensionCommandContext` and calls `ctx.newSession()`. Before replacement, CAS-publish one exact expiring handoff in the profile target snapshot. `workspace-thread` successors re-key the matching Workspace binding; `classic-chat` successors preserve Profile/CWD/session/chat continuity without creating a binding or invoking topic APIs. Both atomically claim the intent before one terminal result, and the old `withSession` path never publishes the same success. Never replace the session while inbound authority is unsettled, store stale command contexts, accept an expired or mismatched handoff, inject terminal input, spawn a shadow Pi process, or mutate session files.
+- Pi integration uses public hooks and APIs. Telegram `/new` is scheduled against the exact durable update, dispatched only after that update is removed from the journal, and then routed through the single `/telegram-internal` Pi gateway via `pi.sendUserMessage(..., { expandPromptTemplates: true })`; only a runtime-armed typed action may execute, manual invocation reports that the command cannot be run manually, and the handler receives the real `ExtensionCommandContext` before calling `ctx.newSession()`. Before replacement, CAS-publish one exact expiring handoff in the profile target snapshot. `workspace-thread` successors re-key the matching Workspace binding; `classic-chat` successors preserve Profile/CWD/session/chat continuity without creating a binding or invoking topic APIs. Both atomically claim the intent before one terminal result, and the old `withSession` path never publishes the same success. Never replace the session while inbound authority is unsettled, store stale command contexts, accept an expired or mismatched handoff, inject terminal input, spawn a shadow Pi process, or mutate session files.
 
 ## 7. Engineering Conventions
 

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

@@ -4,6 +4,11 @@
 
 ## Unreleased
 
+## 0.50.0: Internal lifecycle gateway and thinking cadence
+
+- `Internal lifecycle gateway`: Replaces the session-specific technical command with one `/telegram-internal` gateway for runtime-armed typed actions. Manual invocation performs no action and explains that the command cannot be run manually; settled `/new` replacement retains the same lifecycle and terminal-result guarantees.
+- `Thinking cadence`: Thinking now follows the same cadence as answer drafts: it accumulates the opening frame for two seconds, then updates at most once every two seconds while still flushing buffered reasoning when the block completes.
+
 ## 0.49.0: Unified fresh-session continuity
 
 - `/new`: Classic and Threaded Mode now share one confirmed fresh-session flow. The settled callback deletes its dialog and publishes an expiring exact-target intent; a same- or cross-process successor preserves the classic chat or re-keys the Thread/slot/name, atomically claims once, then sends one terminal result. Identity mismatches fail closed.

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

@@ -126,7 +126,7 @@ Enable the optional capabilities the bridge needs in the [@BotFather](https://t.
 | Model and thinking | Switch model or thinking level from Telegram through safe continuation flows. | Mobile control can adjust execution strategy without tearing down the current session. |
 | Compaction | Confirm `/compact`, show native active status during compaction, and preserve Telegram-owned turn semantics. | Context maintenance is visible and safe from the phone. |
 | Draft previews | Show Telegram's native `…typing` indicator whenever the connected instance is doing agent work, or enable Rich Draft previews for streamed answer text. | Local prompts, Telegram turns, and autonomous continuations remain visibly active while draft visibility stays independent from final rendering. |
-| Activity | Keep the default `verbose` technical surface, show only `thinking`, show only `tools`, or select `quiet` for answer-only delivery. Every instance reloads this shared file-backed choice before a new agent run; thinking uses a headerless expandable quote, while each tool uses one iconless closed root row containing nested evidence details. | Persistent collapsed technical activity minimizes chat height and stays bounded, redacted, target-fenced, free of URL previews, and visually separate from semantic assistant answers. |
+| Activity | Keep the default `verbose` technical surface, show only `thinking`, show only `tools`, or select `quiet` for answer-only delivery. Every instance reloads this shared file-backed choice before a new agent run; thinking accumulates for two seconds and then updates at most every two seconds in a headerless expandable quote, while each tool uses one iconless closed root row containing nested evidence details. | Persistent collapsed technical activity minimizes chat height and stays bounded, redacted, target-fenced, free of URL previews, and visually separate from semantic assistant answers. |
 | Assistant rendering | Choose Native Rich Markdown or legacy Markdown-to-HTML for final assistant replies. | Renderer compatibility is explicit instead of being conflated with draft previews. |
 | Bridge UI rendering | Render thinking through headerless expandable HTML with inline emphasis/code, render each tool as an iconless native Rich root details tree with immediately visible arguments and collapsed secondary evidence, and keep menus, queue controls, status, settings, diagnostics, and sections on Telegram HTML/plain UI. | Harness-owned surfaces remain operationally predictable and visually distinct from model-authored answers. |
 | Inbound files | Download inbound files to the Pi agent temp directory with size limits. | Screenshots, PDFs, datasets, and artifacts enter Pi as inspectable local files. |

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

@@ -11,7 +11,7 @@ export declare const TELEGRAM_ACTIVITY_MESSAGE_MAX_CHARS = 3900;
 export declare const TELEGRAM_ACTIVITY_MESSAGE_MAX_TOOLS = 6;
 export declare const TELEGRAM_REASONING_MESSAGE_MAX_FRAMES = 24;
 export declare const TELEGRAM_REASONING_BUFFER_MAX_CHARS = 1200;
-export declare const TELEGRAM_REASONING_MIN_INTERVAL_MS = 1200;
+export declare const TELEGRAM_REASONING_MIN_INTERVAL_MS = 2000;
 export declare const TELEGRAM_TOOL_UPDATE_MAX_ENTRIES = 4;
 interface ToolActivity {
     id: string;
@@ -41,6 +41,8 @@ export declare function createTelegramActivityVerbosityRuntime<TAuthority>(deps:
     getActivityMode: () => "quiet" | "thinking" | "tools" | "verbose";
     refreshActivityMode?: () => Promise<void>;
     getNowMs?: () => number;
+    setReasoningTimeout?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    clearReasoningTimeout?: (timer: ReturnType<typeof setTimeout>) => void;
     resolveTarget: (event: TelegramActivityEvent) => TelegramTarget | undefined;
     captureAuthority: () => TAuthority;
     isAuthorityActive: (authority: TAuthority) => boolean;

package/node_modules/@llblab/pi-telegram/dist/lib/activity-verbosity.js

@@ -9,7 +9,9 @@ export const TELEGRAM_ACTIVITY_MESSAGE_MAX_CHARS = 3_900;
 export const TELEGRAM_ACTIVITY_MESSAGE_MAX_TOOLS = 6;
 export const TELEGRAM_REASONING_MESSAGE_MAX_FRAMES = 24;
 export const TELEGRAM_REASONING_BUFFER_MAX_CHARS = 1_200;
-export const TELEGRAM_REASONING_MIN_INTERVAL_MS = 1_200;
+// Match native answer drafts: accumulate the opening frame for one full
+// interval, then publish at most one updated frame per interval.
+export const TELEGRAM_REASONING_MIN_INTERVAL_MS = 2_000;
 export const TELEGRAM_TOOL_UPDATE_MAX_ENTRIES = 4;
 function targetEquals(left, right) {
     return left.chatId === right.chatId && left.threadId === right.threadId;
@@ -234,10 +236,18 @@ export function createTelegramActivityVerbosityRuntime(deps) {
     let reasoningMessage;
     let reasoningBlocked = false;
     let lastReasoningPublishMs = 0;
+    let reasoningFlushTimer;
     let toolMessage;
     const tools = new Map();
     const toolOrder = [];
+    const clearReasoningFlushTimer = () => {
+        if (!reasoningFlushTimer)
+            return;
+        (deps.clearReasoningTimeout ?? clearTimeout)(reasoningFlushTimer);
+        reasoningFlushTimer = undefined;
+    };
     const clearActivity = () => {
+        clearReasoningFlushTimer();
         activityId = undefined;
         authority = undefined;
         target = undefined;
@@ -330,6 +340,30 @@ export function createTelegramActivityVerbosityRuntime(deps) {
             deps.recordFailure?.(canEdit ? "reasoning-edit" : "reasoning-send", event, error);
         }
     };
+    const scheduleReasoningPublish = (event, acceptedGeneration) => {
+        if (reasoningFlushTimer || reasoningBlocked)
+            return;
+        const elapsed = reasoningMessageFrames === 0
+            ? 0
+            : getNowMs() - lastReasoningPublishMs;
+        const delayMs = Math.max(0, TELEGRAM_REASONING_MIN_INTERVAL_MS - elapsed);
+        const schedule = deps.setReasoningTimeout ?? setTimeout;
+        reasoningFlushTimer = schedule(() => {
+            reasoningFlushTimer = undefined;
+            const admittedAuthority = authority;
+            const task = async () => {
+                if (!isCurrent(acceptedGeneration, admittedAuthority) ||
+                    reasoningChars <= lastReasoningMessageChars)
+                    return;
+                await publishReasoning(event, acceptedGeneration);
+            };
+            const enqueue = deps.enqueue ?? ((next) => tail.then(next));
+            tail = enqueue(task).catch((error) => {
+                deps.recordFailure?.("reasoning-send", event, error);
+            });
+        }, delayMs);
+        reasoningFlushTimer?.unref?.();
+    };
     const publishTool = async (event, tool, acceptedGeneration) => {
         const admittedAuthority = authority;
         if (!isCurrent(acceptedGeneration, admittedAuthority) || !target) {
@@ -461,12 +495,8 @@ export function createTelegramActivityVerbosityRuntime(deps) {
                 return;
             reasoningChars += event.delta.length;
             reasoningBuffer = `${reasoningBuffer}${event.delta}`.slice(-TELEGRAM_REASONING_BUFFER_MAX_CHARS);
-            if (reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES &&
-                (reasoningMessageFrames === 0 ||
-                    (getNowMs() - lastReasoningPublishMs >=
-                        TELEGRAM_REASONING_MIN_INTERVAL_MS &&
-                        reasoningChars - lastReasoningMessageChars >= 160))) {
-                await publishReasoning(event, acceptedGeneration);
+            if (reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES) {
+                scheduleReasoningPublish(event, acceptedGeneration);
             }
             return;
         }
@@ -477,6 +507,7 @@ export function createTelegramActivityVerbosityRuntime(deps) {
                 reasoningChars = event.text.length;
                 reasoningBuffer = event.text.slice(-TELEGRAM_REASONING_BUFFER_MAX_CHARS);
             }
+            clearReasoningFlushTimer();
             if (reasoningChars > 0 &&
                 reasoningChars > lastReasoningMessageChars &&
                 !reasoningBlocked) {
@@ -550,8 +581,8 @@ export function createTelegramActivityVerbosityRuntime(deps) {
             return;
         }
         if (event.type === "agent-end" || event.type === "agent-settled") {
-            if (reasoningMessage &&
-                reasoningChars > lastReasoningMessageChars &&
+            clearReasoningFlushTimer();
+            if (reasoningChars > lastReasoningMessageChars &&
                 !reasoningBlocked) {
                 await publishReasoning(event, acceptedGeneration);
             }

package/node_modules/@llblab/pi-telegram/dist/lib/commands.d.ts

@@ -574,8 +574,9 @@ export declare function createTelegramCommandHandler<TMessage extends TelegramCo
 export declare function createTelegramCommandOrPromptRuntime<TMessage, TContext>(deps: TelegramCommandOrPromptRuntimeDeps<TMessage, TContext>): {
     dispatchMessages: (messages: TMessage[], ctx: TContext) => Promise<void>;
 };
-export declare const TELEGRAM_SESSION_ACTION_COMMAND_NAME = "telegram-session-action";
-export declare const TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION = "(internal) replace the current Pi session after Telegram settlement";
+export declare const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
+export declare const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "(internal) dispatch one settled Telegram lifecycle action";
+export declare const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram command cannot be run manually.";
 export declare function delayTelegramSessionAction(delayMs: number): Promise<void>;
 export interface TelegramSessionActionRuntimeDeps {
     registerCommand: Pi.ExtensionAPI["registerCommand"];

package/node_modules/@llblab/pi-telegram/dist/lib/commands.js

@@ -1232,8 +1232,9 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
         },
     }, commandArgs);
 }
-export const TELEGRAM_SESSION_ACTION_COMMAND_NAME = "telegram-session-action";
-export const TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION = "(internal) replace the current Pi session after Telegram settlement";
+export const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
+export const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "(internal) dispatch one settled Telegram lifecycle action";
+export const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram command cannot be run manually.";
 export function delayTelegramSessionAction(delayMs) {
     return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
@@ -1364,8 +1365,7 @@ export function createTelegramSessionActionAssembly(deps) {
 export function createTelegramSessionActionRuntime(deps) {
     let pendingUpdateId;
     let pendingTarget;
-    let commandPending = false;
-    let commandUpdateId;
+    let pendingAction;
     let registered = false;
     const reportFailure = (error) => {
         try {
@@ -1380,33 +1380,34 @@ export function createTelegramSessionActionRuntime(deps) {
             if (registered)
                 return;
             registered = true;
-            deps.registerCommand(TELEGRAM_SESSION_ACTION_COMMAND_NAME, {
-                description: TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION,
+            deps.registerCommand(TELEGRAM_INTERNAL_COMMAND_NAME, {
+                description: TELEGRAM_INTERNAL_COMMAND_DESCRIPTION,
                 handler: async (_args, ctx) => {
-                    if (!commandPending)
+                    const action = pendingAction;
+                    if (!action) {
+                        ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
                         return;
-                    commandPending = false;
-                    const target = pendingTarget;
-                    const updateId = commandUpdateId;
-                    pendingTarget = undefined;
-                    commandUpdateId = undefined;
-                    if (!target || updateId === undefined)
-                        return;
-                    try {
-                        await deps.prepareReplacement?.(ctx, updateId, target);
-                        const result = await ctx.newSession();
-                        if (result.cancelled)
-                            await deps.notifyResult(target, "cancelled");
                     }
-                    catch (error) {
-                        reportFailure(error);
-                        await deps.notifyResult(target, "failure");
+                    pendingAction = undefined;
+                    switch (action.kind) {
+                        case "replace-session":
+                            try {
+                                await deps.prepareReplacement?.(ctx, action.updateId, action.target);
+                                const result = await ctx.newSession();
+                                if (result.cancelled)
+                                    await deps.notifyResult(action.target, "cancelled");
+                            }
+                            catch (error) {
+                                reportFailure(error);
+                                await deps.notifyResult(action.target, "failure");
+                            }
+                            return;
                     }
                 },
             });
         },
         scheduleAfterUpdate(updateId, target) {
-            if (pendingUpdateId !== undefined || commandPending)
+            if (pendingUpdateId !== undefined || pendingAction !== undefined)
                 return false;
             pendingUpdateId = updateId;
             pendingTarget = { ...target };
@@ -1416,21 +1417,22 @@ export function createTelegramSessionActionRuntime(deps) {
             if (pendingUpdateId !== updateId)
                 return;
             pendingUpdateId = undefined;
-            commandUpdateId = updateId;
-            commandPending = true;
+            const target = pendingTarget;
+            pendingTarget = undefined;
+            if (!target)
+                return;
+            pendingAction = { kind: "replace-session", updateId, target };
             void Promise.resolve()
-                .then(() => deps.sendUserMessage(`/${TELEGRAM_SESSION_ACTION_COMMAND_NAME}`, {
+                .then(() => deps.sendUserMessage(`/${TELEGRAM_INTERNAL_COMMAND_NAME}`, {
                 expandPromptTemplates: true,
             }))
                 .catch((error) => {
-                commandPending = false;
-                commandUpdateId = undefined;
-                pendingTarget = undefined;
+                pendingAction = undefined;
                 reportFailure(error);
             });
         },
         hasPending() {
-            return pendingUpdateId !== undefined || commandPending;
+            return pendingUpdateId !== undefined || pendingAction !== undefined;
         },
     };
 }

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

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

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

@@ -610,7 +610,7 @@ Queue reaction behavior, lane-tail transitions, Keep/Skip independence, multi-re
 
 Complete intermediate assistant text blocks from Telegram-originated activity are sent once to the immutable originating target before active-turn final delivery; final and terminal-partial segments stay with settlement so replies are not duplicated. While this instance has exact direct or follower transport authority, completed public blocks from local/autonomous work are always sent once and in source order to the instance's authorized target. Connected companion projection is not configurable; disconnect or authority loss is its boundary. Both paths use the configured Rich or HTML renderer and exclude reasoning, tool traffic, token deltas, local prompt text, unknown sources, and stale generations. Each admitted block remains fenced to its exact target, profile/token stamp, leader epoch or follower registration generation, and session generation; non-idempotent acknowledgement ambiguity never authorizes replay.
 
-`assistant.activity` is an independent bridge-owned projection over normalized Activity events. Each process reloads the shared file-backed setting at `agent-start` before activity admission, so multi-instance mode cannot continue projecting a stale broader process-local selection. Omitted values resolve to `verbose`, while invalid values fail closed to `quiet`; `thinking` and `tools` select one technical class, while `verbose` enables both. Provider-exposed thinking uses persistent ordinary HTML containing only a standard expandable blockquote with a bounded redacted latest-text window and inline Markdown rendered as Telegram HTML. Completed executed tools use native Rich Messages: each closed `<Tool>: <status>` root details node renders snake-case names as title words while preserving an uppercase two- or three-letter repeated prefix per word, then the native disclosure chevron reveals an open-by-default `arguments` child plus closed retained `update N` and `result`/`error` child details with lowercase monospaced, marker-free summaries and JSON pre blocks; known-safe Rich rejections fall back to the previous HTML disclosure. The projection captures the exact target and transport stamp at activity admission, serializes updates, preserves tool-start order, closes coalescing across assistant/thinking boundaries, bounds retained text/update memory plus edit frames and message/tool size, disables previews and HTTP(S) auto-link recognition inside technical evidence, and never replays a possibly committed send. Session generations own independent queues, so replacement drops queued old work without waiting on an old call. Bridge-owned assistant output and activity projection share one activity-publication sequence admitted synchronously from the activity bus, so later tool disclosures cannot overtake earlier assistant blocks. Activity targets and transport authority are captured before queued work starts. Active Telegram-turn final replies/artifacts and automatic compaction notices use that same publication owner before the existing direct/follower transport split, without mutually waiting on separate output tails. Final settlement captures the exact active turn and assistant result and reserves its publication position before config loading. Empty outcomes without a publication candidate reserve no position. Replacement, preparation failure, or an unused reservation releases the position without resetting or replying for a replacement turn. Final errors also publish through this owner. Reservations accept one task; cancellation cannot undo a published task, and session reset releases unresolved reservations while fencing old queued tasks. Terminal assistant messages with a publication candidate reserve the final position synchronously; settlement consumes that reservation only for the exact originating turn. Compaction notices enter the same queue immediately, behind the reserved final rather than through a separate notice buffer. Settlement, a new agent run, or session replacement cancels an unconsumed reservation. Notice target and authority are captured when the event is observed. Pi lifecycle completion does not wait for network publication. This order is process-local and does not serialize unrelated instances or independent registered activity handlers. Settlement, replacement, disconnect, failure, or stale authority clears only local ownership; already-sent activity messages remain in chat.
+`assistant.activity` is an independent bridge-owned projection over normalized Activity events. Each process reloads the shared file-backed setting at `agent-start` before activity admission, so multi-instance mode cannot continue projecting a stale broader process-local selection. Omitted values resolve to `verbose`, while invalid values fail closed to `quiet`; `thinking` and `tools` select one technical class, while `verbose` enables both. Provider-exposed thinking uses persistent ordinary HTML containing only a standard expandable blockquote with a bounded redacted latest-text window and inline Markdown rendered as Telegram HTML. Like answer drafts, it accumulates for two seconds before the first frame, publishes at most one update every two seconds, and flushes remaining buffered reasoning on terminal completion. Completed executed tools use native Rich Messages: each closed `<Tool>: <status>` root details node renders snake-case names as title words while preserving an uppercase two- or three-letter repeated prefix per word, then the native disclosure chevron reveals an open-by-default `arguments` child plus closed retained `update N` and `result`/`error` child details with lowercase monospaced, marker-free summaries and JSON pre blocks; known-safe Rich rejections fall back to the previous HTML disclosure. The projection captures the exact target and transport stamp at activity admission, serializes updates, preserves tool-start order, closes coalescing across assistant/thinking boundaries, bounds retained text/update memory plus edit frames and message/tool size, disables previews and HTTP(S) auto-link recognition inside technical evidence, and never replays a possibly committed send. Session generations own independent queues, so replacement drops queued old work without waiting on an old call. Bridge-owned assistant output and activity projection share one activity-publication sequence admitted synchronously from the activity bus, so later tool disclosures cannot overtake earlier assistant blocks. Activity targets and transport authority are captured before queued work starts. Active Telegram-turn final replies/artifacts and automatic compaction notices use that same publication owner before the existing direct/follower transport split, without mutually waiting on separate output tails. Final settlement captures the exact active turn and assistant result and reserves its publication position before config loading. Empty outcomes without a publication candidate reserve no position. Replacement, preparation failure, or an unused reservation releases the position without resetting or replying for a replacement turn. Final errors also publish through this owner. Reservations accept one task; cancellation cannot undo a published task, and session reset releases unresolved reservations while fencing old queued tasks. Terminal assistant messages with a publication candidate reserve the final position synchronously; settlement consumes that reservation only for the exact originating turn. Compaction notices enter the same queue immediately, behind the reserved final rather than through a separate notice buffer. Settlement, a new agent run, or session replacement cancels an unconsumed reservation. Notice target and authority are captured when the event is observed. Pi lifecycle completion does not wait for network publication. This order is process-local and does not serialize unrelated instances or independent registered activity handlers. Settlement, replacement, disconnect, failure, or stale authority clears only local ownership; already-sent activity messages remain in chat.
 
 Telegram prompt guidance is context- and authority-aware. The package and source-checkout extension contribute `telegram-bridge`, optional `generated-control-surface`, and `generative-apps` Skills through Pi resource discovery. Generated Control Surface treats `interface = f(state, capabilities, intent)` as a renderer-neutral primitive, compiling transient evidence-backed controls over domain-owned workflows, systems, navigation, supervision, and decisions without creating parallel application state. It composes an ordered ragged sequence of independently sized semantic rows rather than filling a rectangular grid: compact rows contain genuine peers, singleton rows isolate structurally independent actions, and rectangular layouts remain reserved for genuinely spatial state. Text-bearing controls use at most two columns and flow into additional rows, while denser rows are reserved for short position-bearing glyphs or codes and never exceed the eight-column phone-width UX maximum. Vertical extent is independent: a true spatial surface may retain substantially more rows, while non-spatial button walls route to grouping, disclosure, or pagination. Symmetry is treated as an evidence claim about equal relationships or real spatial topology; an abstract layout catalog supplies adaptable singleton, peer, staged, navigational, repeated-pair, and rectangular shapes without forcing tasks into preset grids. Repeated controls carry the smallest sufficient action delta when visible conversation is unambiguous; larger or error-prone state moves to a deterministic task-owned Markdown artifact, correctness-sensitive transitions move to a small domain-owned transition implementation, and repeated clicks are adjudicated against current state rather than stale button appearance. Its filesystem adapter reserves the first full-width row for parent traversal outside root, places available Previous/Next controls together in one compact row immediately afterward, orders visible directories, hidden directories, visible files, and hidden files alphabetically within each category before fixed ten-entry pagination, renders path/range metadata as stacked status-style key-value rows instead of middle-dot prose, emits the complete Telegram control set through one JSON-matrix action, suppresses duplicate plain/monospaced listings and default Refresh unless user preference overrides presentation, and retains an ordinary numbered fallback when buttons are unavailable. Only an exact direct owner or live registered follower exposes the two pi-telegram delivery tools, their active-tool metadata, and the compact routing suffix. Disconnect or authority loss removes those tool surfaces for subsequent requests without touching foreign tools; reconnect/recovery restores only the pi-telegram subset that was active before suspension, including across same-process reload. Repeated stable interactions may graduate from that model-mediated surface into a reviewed Generative App whose deterministic bound methods bypass Pi queue admission; the `generative-apps` Skill owns this compilation and operating workflow while the underlying capability retains domain authority. Telegram-originated turns route to the stable Skill contracts and retain dynamic blocks such as `[voice] delivery: automatic voice`; the Skills and public documentation own syntax, target routing, Threaded Mode behavior, Generative App operation, and diagnostics.
 

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

@@ -51,7 +51,7 @@ Stable commands inside Pi:
 Stable commands inside the paired Telegram DM:
 
 - `/start` — pair when needed and open the main application menu.
-- `/new` — after idle and empty-queue checks, request a new Pi session in the current classic chat or Thread. The bridge acknowledges the callback, deletes its confirmation, completes and removes the exact durable update, then dispatches an internal Pi command through `pi.sendUserMessage(..., { expandPromptTemplates: true })`. Its real `ExtensionCommandContext` calls `ctx.newSession()`; one discriminated durable intent preserves either exact classic Profile/CWD/session/chat continuity or the Thread binding with slot/name re-key. The successor CAS-claims that intent before sending one terminal result. Busy, identity-mismatch, and unavailable-host paths fail closed.
+- `/new` — after idle and empty-queue checks, request a new Pi session in the current classic chat or Thread. The bridge acknowledges the callback, deletes its confirmation, completes and removes the exact durable update, then dispatches one runtime-armed typed action through the internal `/telegram-internal` Pi gateway using `pi.sendUserMessage(..., { expandPromptTemplates: true })`. Manual invocation reports that the gateway cannot be run manually; the armed handler receives a real `ExtensionCommandContext` and calls `ctx.newSession()`; one discriminated durable intent preserves either exact classic Profile/CWD/session/chat continuity or the Thread binding with slot/name re-key. The successor CAS-claims that intent before sending one terminal result. Busy, identity-mismatch, and unavailable-host paths fail closed.
 - `/compact` — open confirmation and compact when idle.
 - `/next` — abort active work first when needed, let the interrupted prompt receive its abort notice, then reply `Dispatching next queued turn.` to the exact queued prompt selected for the next model turn. The command itself is never the lifecycle-notice reply target, and aborted pending assistant text is suppressed.
 - `/continue` — enqueue a priority `continue` prompt.

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

@@ -24,7 +24,9 @@ export const TELEGRAM_ACTIVITY_MESSAGE_MAX_CHARS = 3_900;
 export const TELEGRAM_ACTIVITY_MESSAGE_MAX_TOOLS = 6;
 export const TELEGRAM_REASONING_MESSAGE_MAX_FRAMES = 24;
 export const TELEGRAM_REASONING_BUFFER_MAX_CHARS = 1_200;
-export const TELEGRAM_REASONING_MIN_INTERVAL_MS = 1_200;
+// Match native answer drafts: accumulate the opening frame for one full
+// interval, then publish at most one updated frame per interval.
+export const TELEGRAM_REASONING_MIN_INTERVAL_MS = 2_000;
 export const TELEGRAM_TOOL_UPDATE_MAX_ENTRIES = 4;
 
 interface ToolActivity {
@@ -325,6 +327,11 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
   getActivityMode: () => "quiet" | "thinking" | "tools" | "verbose";
   refreshActivityMode?: () => Promise<void>;
   getNowMs?: () => number;
+  setReasoningTimeout?: (
+    callback: () => void,
+    delayMs: number,
+  ) => ReturnType<typeof setTimeout>;
+  clearReasoningTimeout?: (timer: ReturnType<typeof setTimeout>) => void;
   resolveTarget: (event: TelegramActivityEvent) => TelegramTarget | undefined;
   captureAuthority: () => TAuthority;
   isAuthorityActive: (authority: TAuthority) => boolean;
@@ -360,11 +367,18 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
   let reasoningMessage: ReasoningMessage | undefined;
   let reasoningBlocked = false;
   let lastReasoningPublishMs = 0;
+  let reasoningFlushTimer: ReturnType<typeof setTimeout> | undefined;
   let toolMessage: ToolMessage | undefined;
   const tools = new Map<string, ToolActivity>();
   const toolOrder: string[] = [];
 
+  const clearReasoningFlushTimer = () => {
+    if (!reasoningFlushTimer) return;
+    (deps.clearReasoningTimeout ?? clearTimeout)(reasoningFlushTimer);
+    reasoningFlushTimer = undefined;
+  };
   const clearActivity = () => {
+    clearReasoningFlushTimer();
     activityId = undefined;
     authority = undefined;
     target = undefined;
@@ -466,6 +480,33 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       );
     }
   };
+  const scheduleReasoningPublish = (
+    event: TelegramActivityEvent,
+    acceptedGeneration: number,
+  ) => {
+    if (reasoningFlushTimer || reasoningBlocked) return;
+    const elapsed = reasoningMessageFrames === 0
+      ? 0
+      : getNowMs() - lastReasoningPublishMs;
+    const delayMs = Math.max(0, TELEGRAM_REASONING_MIN_INTERVAL_MS - elapsed);
+    const schedule = deps.setReasoningTimeout ?? setTimeout;
+    reasoningFlushTimer = schedule(() => {
+      reasoningFlushTimer = undefined;
+      const admittedAuthority = authority;
+      const task = async () => {
+        if (
+          !isCurrent(acceptedGeneration, admittedAuthority) ||
+          reasoningChars <= lastReasoningMessageChars
+        ) return;
+        await publishReasoning(event, acceptedGeneration);
+      };
+      const enqueue = deps.enqueue ?? ((next: () => Promise<void>) => tail.then(next));
+      tail = enqueue(task).catch((error) => {
+        deps.recordFailure?.("reasoning-send", event, error);
+      });
+    }, delayMs) as ReturnType<typeof setTimeout>;
+    reasoningFlushTimer?.unref?.();
+  };
   const publishTool = async (
     event: TelegramActivityEvent,
     tool: ToolActivity,
@@ -602,13 +643,8 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       reasoningBuffer = `${reasoningBuffer}${event.delta}`.slice(
         -TELEGRAM_REASONING_BUFFER_MAX_CHARS,
       );
-      if (reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES &&
-        (reasoningMessageFrames === 0 ||
-          (getNowMs() - lastReasoningPublishMs >=
-            TELEGRAM_REASONING_MIN_INTERVAL_MS &&
-            reasoningChars - lastReasoningMessageChars >= 160))
-      ) {
-        await publishReasoning(event, acceptedGeneration);
+      if (reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES) {
+        scheduleReasoningPublish(event, acceptedGeneration);
       }
       return;
     }
@@ -620,6 +656,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
           -TELEGRAM_REASONING_BUFFER_MAX_CHARS,
         );
       }
+      clearReasoningFlushTimer();
       if (
         reasoningChars > 0 &&
         reasoningChars > lastReasoningMessageChars &&
@@ -687,8 +724,8 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       return;
     }
     if (event.type === "agent-end" || event.type === "agent-settled") {
+      clearReasoningFlushTimer();
       if (
-        reasoningMessage &&
         reasoningChars > lastReasoningMessageChars &&
         !reasoningBlocked
       ) {

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

@@ -2335,9 +2335,11 @@ async function handleTelegramCommandRuntime<
   );
 }
 
-export const TELEGRAM_SESSION_ACTION_COMMAND_NAME = "telegram-session-action";
-export const TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION =
-  "(internal) replace the current Pi session after Telegram settlement";
+export const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
+export const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION =
+  "(internal) dispatch one settled Telegram lifecycle action";
+export const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE =
+  "This internal Telegram command cannot be run manually.";
 
 export function delayTelegramSessionAction(delayMs: number): Promise<void> {
   return new Promise<void>((resolve) => setTimeout(resolve, delayMs));
@@ -2538,6 +2540,12 @@ export function createTelegramSessionActionAssembly(
   return { action, settlement };
 }
 
+type TelegramPendingInternalAction = {
+  kind: "replace-session";
+  updateId: number;
+  target: { chatId: number; threadId?: number; messageId: number };
+};
+
 export interface TelegramSessionActionRuntime {
   register: () => void;
   scheduleAfterUpdate: (
@@ -2557,8 +2565,7 @@ export function createTelegramSessionActionRuntime(
     threadId?: number;
     messageId: number;
   } | undefined;
-  let commandPending = false;
-  let commandUpdateId: number | undefined;
+  let pendingAction: TelegramPendingInternalAction | undefined;
   let registered = false;
 
   const reportFailure = (error: unknown): void => {
@@ -2573,29 +2580,32 @@ export function createTelegramSessionActionRuntime(
     register() {
       if (registered) return;
       registered = true;
-      deps.registerCommand(TELEGRAM_SESSION_ACTION_COMMAND_NAME, {
-        description: TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION,
+      deps.registerCommand(TELEGRAM_INTERNAL_COMMAND_NAME, {
+        description: TELEGRAM_INTERNAL_COMMAND_DESCRIPTION,
         handler: async (_args, ctx) => {
-          if (!commandPending) return;
-          commandPending = false;
-          const target = pendingTarget;
-          const updateId = commandUpdateId;
-          pendingTarget = undefined;
-          commandUpdateId = undefined;
-          if (!target || updateId === undefined) return;
-          try {
-            await deps.prepareReplacement?.(ctx, updateId, target);
-            const result = await ctx.newSession();
-            if (result.cancelled) await deps.notifyResult(target, "cancelled");
-          } catch (error) {
-            reportFailure(error);
-            await deps.notifyResult(target, "failure");
+          const action = pendingAction;
+          if (!action) {
+            ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
+            return;
+          }
+          pendingAction = undefined;
+          switch (action.kind) {
+            case "replace-session":
+              try {
+                await deps.prepareReplacement?.(ctx, action.updateId, action.target);
+                const result = await ctx.newSession();
+                if (result.cancelled) await deps.notifyResult(action.target, "cancelled");
+              } catch (error) {
+                reportFailure(error);
+                await deps.notifyResult(action.target, "failure");
+              }
+              return;
           }
         },
       });
     },
     scheduleAfterUpdate(updateId, target) {
-      if (pendingUpdateId !== undefined || commandPending) return false;
+      if (pendingUpdateId !== undefined || pendingAction !== undefined) return false;
       pendingUpdateId = updateId;
       pendingTarget = { ...target };
       return true;
@@ -2603,23 +2613,23 @@ export function createTelegramSessionActionRuntime(
     onUpdateCompleted(updateId) {
       if (pendingUpdateId !== updateId) return;
       pendingUpdateId = undefined;
-      commandUpdateId = updateId;
-      commandPending = true;
+      const target = pendingTarget;
+      pendingTarget = undefined;
+      if (!target) return;
+      pendingAction = { kind: "replace-session", updateId, target };
       void Promise.resolve()
         .then(() =>
-          deps.sendUserMessage(`/${TELEGRAM_SESSION_ACTION_COMMAND_NAME}`, {
+          deps.sendUserMessage(`/${TELEGRAM_INTERNAL_COMMAND_NAME}`, {
             expandPromptTemplates: true,
           }),
         )
         .catch((error) => {
-          commandPending = false;
-          commandUpdateId = undefined;
-          pendingTarget = undefined;
+          pendingAction = undefined;
           reportFailure(error);
         });
     },
     hasPending() {
-      return pendingUpdateId !== undefined || commandPending;
+      return pendingUpdateId !== undefined || pendingAction !== undefined;
     },
   };
 }

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-kit",
-  "version": "0.17.1",
+  "version": "0.18.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -45,7 +45,7 @@
     "@llblab/pi-codex-usage": "0.10.0",
     "@llblab/pi-grow-loop": "0.8.1",
     "@llblab/pi-state-flow": "0.16.2",
-    "@llblab/pi-telegram": "0.49.0",
+    "@llblab/pi-telegram": "0.50.0",
     "@llblab/skills": "1.15.0"
   },
   "bundledDependencies": [