@llblab/pi-kit 0.22.0 → 0.22.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.22.1 - 2026-09-24
+
+- `In-Flight Model Switching`: Advances the exact Telegram pin to `0.51.2`. Telegram model selection can stop, switch, and continue any interruptible run in the current Pi session, including local/TUI work, while preserving the authorized chat, Thread, and reply target and deferring abort until active tools settle.
+- `Typing Continuity`: Native presence refreshes only the assigned Thread, coalesces concurrent chat actions, shares Telegram cooldown across Thread keys, and preserves an existing agent typing loop through compaction. Best-effort typing failures no longer replace healthy leader/follower status with an error.
+- `Package Cohort`: Keeps every other bundled package at its current exact version. Package membership, resource paths, load order, Pi minimum, and bundled Skill ownership remain unchanged.
+
 ## 0.22.0 - 2026-09-23
 
 - `Named npm Extensions`: Advances the exact Clean Room pin to `0.2.0`. `/clean-room <package-name>` now loads installed npm Pi extensions by name, including scoped packages, while preserving explicit resource isolation and project-local precedence.

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.18.1` | Incremental scoped context/memory compiler with independent scope revisions, canonical file persistence, bounded and diagnosable Git backup replication, native working context within each run, and targeted historical reads |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.51.1` | Telegram companion with stable follower heartbeats, exact queue-transition notices, pressure-safe Workspace rotation, adaptive Thread continuity, files, voice, controls, and bundled Telegram interaction Skills |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.51.2` | Telegram companion with in-flight model switching, continuous exact-Thread typing, truthful transport status, pressure-safe Workspace rotation, files, voice, controls, and bundled Telegram interaction Skills |
 | [`@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

@@ -96,10 +96,11 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 
 - Queue lane/kind admission is explicit. Dispatch waits for active-turn, pending-dispatch, control, compaction, `ctx.isIdle()`, and Pi pending-message guards; a dispatched prompt stays queued until `agent_start` consumes it. The terminal `+N` suffix is a yellow count of executable prompts still waiting, excludes the dispatched head immediately, and never counts current agent work from any source. Each prompt is one object with one active lane and no reserved return slot. Normal and Priority are separate FIFO lanes: crossing lanes removes it from the source and appends it at the destination tail, while Keep/Skip and same-category emoji changes preserve lane position. Complete reaction sets independently derive Priority from recognized positive emoji and Skip from recognized negative emoji; both may coexist, suppressed turns retain durable receipts while waiting, and Skip settles them only when the prompt reaches dispatch before dropping it without inference. Suppressed turns remain visible at a struck-through physical ordinal without contributing to executable queue counters, while graceful session shutdown discards all remaining queue authority before clearing memory.
 - `/stop`, `/abort`, `/next`, and `/continue` respectively reset+abort, abort while preserving queue, force the next turn, and enqueue a control-lane continuation. Abort-history folding applies only to Telegram-owned active turns. A busy `/next` marks only its exact active Telegram turn: terminal abort settlement attempts one explicit abort notice before the exact selected queued prompt receives its dispatch notice. Notice failure is diagnostic and cannot block dispatch; a later `/abort` or `/stop` cancels both pending transition notices before taking ownership. Target command adapters must forward these transition ports. A successful dispatch notice keeps the queued prompt's one reply-header claim across agent start, so later messages in that turn never repeat it.
+- A model selection from an authorized Telegram target may stop and continue any interruptible active agent run in that same Pi session, including local/TUI work. Queue the synthetic control-lane continuation before aborting; when no Telegram prompt owns the run, bind continuation and reply ownership to the exact model-menu chat/Thread/message. Delay abort until every active tool execution settles, and clear both selection and fallback target on cancellation, agent start, settlement, or session replacement.
 - Telegram extension side effects must not hold Pi's core lifecycle hostage after semantic completion. Preserve ordering in extension-owned background work, record failures, and fence target/profile/transport/session authority.
 - Complete assistant/guest model answers use Telegram-native Rich Markdown. Harness-owned menus, status, diagnostics, thinking, and tool evidence remain explicit HTML/plain or their documented native surface. Before Telegram preview or final delivery, strip every assistant-authored HTML comment regardless of Markdown position while keeping action activation top-level-only; a comment-only result sends no text message. Preserve literal code outside comments and structurally safe chunking; never split invalid markup.
 - `preview` owns streaming lifecycle only, not assistant rendering. Finalization waits for active preview flushes and must not issue pre/post-final draft-clear calls that create transient Telegram draft UI. Turns that already answer as one atomic reply (voice replies, Guest Mode queries) never stream previews.
-- Native `sendChatAction(typing)` is the automatic activity signal for unsettled agent and compaction work while Telegram transport is authorized. Extension-owned blocking UI prompts pause it and completion resumes it while either work owner remains active. Do not invent extra in-chat work indicators or emit activity for startup/connect/reload/recovery alone.
+- Native `sendChatAction(typing)` is the automatic activity signal for unsettled agent and compaction work while Telegram transport is authorized. Extension-owned blocking UI prompts pause it and completion resumes it while either work owner remains active. Compaction may stop only a typing loop it actually started; it must preserve a pre-existing agent-owned loop. Refresh only the assigned Thread on a conservative three-second cadence; do not mirror typing to aggregate `All` and multiply shared-chat flood pressure. Typing is best-effort presence only: a failed exact-target action remains a structured diagnostic and must not replace a healthy connected/leader/follower status with `error`. Do not invent extra in-chat work indicators or emit activity for startup/connect/reload/recovery alone.
 - Public activity handlers and connected companion delivery are asynchronous, target-bound, generation-fenced surfaces. Connected companion projection has no independent opt-out: disconnect or authority loss is its boundary. Token deltas, hidden reasoning, unknown sources, and stale authority never enter public projection.
 - Thread display defaults to the profile-scoped Letters strategy, with Names, Directory Snake, and Directory Title as the other automatic choices; Names projects the generated dictionary name for the slot. Unsupported retained display keys resolve to Letters without rewriting persisted configuration. A durable manual Thread display name retained on its Workspace binding overrides any automatic projection until exact reset; keep generated/recovery identity separate from manual and acknowledged display fields. After leader startup, automatic display contraction waits one follower-staleness window so election and follower re-registration cannot briefly remove and restore an acknowledged same-cwd suffix; stop/start generation cancels stale reconciliation. UI labels, emoji semantics, navigation, settings controls, callback namespaces, voice behavior, command templates, and assistant markup follow the linked `/docs` contracts. Generated human-readable prompt-button labels use `emoji + space + text`; emoji-free text is only a reasoned no-semantic-marker fallback. Non-spatial generated controls default to top-level vertical cells, with nested rows reserved for unmistakably compact peers. Do not restate other evolving UI details here.
 

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

@@ -2,16 +2,11 @@
 
 _This file owns unresolved project work only. Completed behavior belongs in `CHANGELOG.md`; durable contracts belong in `AGENTS.md` and `/docs`._
 
-- [ ] `Unified Telegram /new continuity` ([#81](https://github.com/llblab/pi-telegram/issues/81), `live-acceptance-gated`): Run operator-authorized Classic and Threaded live smoke for the implemented one-shot successor handoff, then close the issue. Verify confirmation deletion, exact-target/session continuity, one terminal result, and no duplicate settlement.
-- [ ] `Manual Thread naming` (`live-acceptance-gated`): Exercise command ordering, dialog/cancel, invalid input, duplicate callbacks, leader/follower rename, manual override, and reset against disposable Threads. Local generation/target fencing and Bot-API-wait replacement regressions are complete.
-- [ ] [`Workspace Thread recovery`](./docs/multi-instance-bus.md) (`operator-/environment-gated`): Finish live and platform evidence without weakening exact owner, admission, journal, or deletion fences.
-  - [ ] Confirm the retired K Thread/history is absent after the successful full-A–Z pressure rotation, and repeat the rebuilt leader-election smoke to verify a returning same-directory follower causes no temporary suffix contraction.
-  - [ ] Complete follower Restore, inaccessible-callback, already-absent chooser, stale-target, Singleton↔Threaded, and native-Windows acceptance with disposable targets; preserve accepted work and current ownership.
+- [ ] [`Workspace Thread recovery`](./docs/multi-instance-bus.md) (`environment-gated`): Complete native-Windows coverage for follower restore, inaccessible callbacks, stale targets, and Singleton↔Threaded transitions while preserving accepted work and current ownership.
   - [ ] Select an approved exact-absence observation before implementing ambiguous `deletion-issued` recovery. Never replay an unknown deletion or infer absence from cache, heartbeat silence, empty `editForumTopic`, or `sendChatAction` success.
 - [ ] [`Automatic pairing and follower input custody`](./docs/architecture.md#automatic-pairing-confirmation-design) (`activation-gated`): Keep production custody disabled until historical sources and physical references are reconciled, all legacy writers/consumers are retired or excluded under operator authority, migration is complete, and every participating peer supports the final protocol. Preserve outcome-unknown running work, exact receipt/group authority, authenticated handoff, and rollback/downgrade safety. Then compose the prepared v3 lifecycle/bus ports, add bounded operator disposition for retained legacy retry state, and run real-process plus native-Windows acceptance.
-- [ ] `Thread Cleanup Manager` (`activation-gated`): Production currently exposes non-destructive review only. Before enabling deletion, compose the exact cleanup fence/permit coordinator, prove successor recovery for `commit-ready` without transport replay, and run operator-authorized live acceptance against disposable inactive Threads. Unknown outcomes remain retained.
-- [ ] `Channel operations` (`live-acceptance-gated`): On a disposable channel with real sender rights, verify media rejection, duplicate-send suppression, caption edit, and the durable authored-post create/list/edit/delete flow. Preserve direct-leader authority and outcome-unknown no-replay semantics.
+- [ ] `Thread Cleanup Manager` (`activation-gated`): Production currently exposes non-destructive review only. Before enabling deletion, compose the exact cleanup fence/permit coordinator and prove successor recovery for `commit-ready` without transport replay. Unknown outcomes remain retained.
 - [ ] [`Inference-bypass Generative Apps`](./docs/generative-apps.md) (`hardening`): Complete removal/replacement recovery, process-birth lock recovery, follower routing, refresh/backoff, stale revision rejection, redacted failure diagnostics, CML/JSON parity, and no-model-turn acceptance. Extend the Music Player adapter evidence across volume, toggle, previous, status, restart, unavailable backend, and bounded process failures.
 - [ ] `External compatibility acceptance` (`environment-gated`): Confirm one `telegram_bind` request through the reporter's OMP + llama-server build ([#267](https://github.com/llblab/pi-telegram/issues/267)); validate environment-backed bot-token setup/status for default and named profiles; and extend native in-body controls to a second client, follower routing, disabled cells, and app-method revision rejection.
-- [ ] `Queue recovery evidence` (`operator-gated`): Establish a supported preservation/discard path for any already-wedged in-memory queue before mutation. Optional disposable-follower smoke may overlap delayed voice processing with turn completion to confirm one-time ordered consumption. Never clear journals, replay settled input, or treat restart as repair.
+- [ ] `Queue recovery evidence` (`operator-gated`): Establish a supported preservation/discard path for any already-wedged in-memory queue before mutation. Never clear journals, replay settled input, or treat restart as repair.
 - [ ] `Show Me ownership transfer` (`release-coordination`): After a pi-telegram release containing the bundled `show-me` Skill is available, remove the former copy from `@llblab/skills` under that package's release policy, then update Pi Kit. The coordinated final install must expose exactly one Skill identity.

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

@@ -4,6 +4,12 @@
 
 ## Unreleased
 
+## 0.51.2: Model switching and typing continuity
+
+- `In-flight model switching`: Telegram model selection can again stop, switch, and continue any interruptible agent run in the current Pi session, including local/TUI work without an active Telegram prompt. The exact model-menu chat/Thread/message supplies fallback continuation ownership, active tools defer abort until settlement, and cancellation/session boundaries clear both selection and target state instead of returning a false busy response.
+- `Typing continuity`: Native presence now refreshes only the assigned Thread every three seconds instead of duplicating each action into aggregate `All`. The leader admits at most one concurrent action per chat and shares Telegram 429 cooldown across that chat's Thread keys. Compaction preserves a pre-existing agent typing loop instead of claiming and stopping it, addressing both multi-instance flicker and lifecycle gaps.
+- `Typing status truthfulness`: Failed `sendChatAction(typing)` calls remain bounded structured diagnostics but no longer replace a healthy connected/leader/follower status with `error`. Optional presence failures therefore cannot misreport transport health after the actual turn and delivery continue successfully.
+
 ## 0.51.1: Queue transitions and follower heartbeat stability
 
 - `/next lifecycle notices`: Target command composition now forwards request, exact-turn marker, and cancellation ports. Busy `/next` orders abort then selected-prompt dispatch notices; failures cannot block dispatch, and `/abort`/`/stop` cancel stale notices. A successful dispatch notice keeps first-reply ownership through agent start, so later answer messages do not repeat the queued-prompt reply. Rapid ordinary messages remain distinct turns.

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

@@ -123,7 +123,7 @@ Enable the optional capabilities the bridge needs in the [@BotFather](https://t.
 | Queue control | Inspect waiting turns, keep or skip stale work, promote important prompts, continue, abort, stop, or force the next queued item. | Long Pi tasks keep running while new mobile prompts stay visible and controllable instead of interrupting or disappearing. |
 | Operator menu | Use `/start` for status, prompt templates, model, thinking, settings, queue, extension sections, and diagnostics. | The bot is an operator panel, not a command cheat sheet. |
 | Prompt templates | Run Pi prompt templates as Telegram-safe commands such as `/fix_tests`. | Reusable local workflows become phone-accessible without exposing arbitrary terminal commands. |
-| 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. |
+| Model and thinking | Switch model or thinking level from Telegram through safe continuation flows, including an active local/TUI agent run. | Mobile control can stop, switch, and resume in the same session context instead of returning a false busy dead end. |
 | 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 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. |

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

@@ -676,10 +676,7 @@ export function registerTelegramLifecycleRuntimeHooks({ pi, publicationRuntime,
             return false;
         const turn = activeTurnRuntime.get();
         const target = turn?.target ?? proactivePushTargetGetter();
-        promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, {
-            target,
-        });
-        return true;
+        return (promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, { target }) !== false);
     };
     const startActiveTurnTypingLoop = (ctx) => {
         if (uiPromptActive)

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

@@ -14,5 +14,4 @@ export interface TelegramBusAwareApiRuntimeDeps {
         threadId?: number;
     } | undefined;
 }
-export declare function createTelegramAggregateTypingActionSender(runtime: Pick<TelegramBridgeApiRuntime, "call">): (chatId: number) => Promise<unknown>;
 export declare function createTelegramBusAwareApiRuntime(deps: TelegramBusAwareApiRuntimeDeps): TelegramBridgeApiRuntime;

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

@@ -37,9 +37,6 @@ function markFollowerCrossTargetDelivery(body, defaultTarget) {
 function rejectTelegramDirectOwnership(method) {
     return Promise.reject(new Error(`Telegram ${method} requires direct transport ownership.`));
 }
-export function createTelegramAggregateTypingActionSender(runtime) {
-    return (chatId) => runtime.call("sendChatAction", { chat_id: chatId, action: "typing" });
-}
 export function createTelegramBusAwareApiRuntime(deps) {
     return {
         call(method, body, options) {

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

@@ -514,7 +514,6 @@ export default function (pi) {
         typing,
         getDefaultChatId: proactivePushChatIdGetter,
         sendTypingAction,
-        sendAggregateTypingAction: BusApi.createTelegramAggregateTypingActionSender(telegramApiRuntime),
         updateStatus,
         isContextActive: telegramSessionContextStore.isCurrent,
         getTransportAuthority() {
@@ -1353,7 +1352,7 @@ export default function (pi) {
             loadConfig: configStore.load,
             setQueuedItems: telegramQueueStore.setQueuedItems,
             setCurrentModel: currentModelRuntime.set,
-            setPendingModelSwitch: pendingModelSwitchStore.set,
+            setPendingModelSwitch: modelSwitchController.clearPendingSwitch,
             syncCounters: queue.syncCounters,
             syncFlags: lifecycle.syncFlags,
             bindDeferredDispatchContext: deferredQueueDispatchRuntime.bind,

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

@@ -4,7 +4,7 @@
  * Owns model-menu state, scoped model pages, model callback planning, and model-menu message rendering
  */
 import type { TelegramInlineKeyboardMarkup } from "./keyboard.ts";
-import { type MenuModel, type ScopedTelegramModel, type ThinkingLevel } from "./model.ts";
+import { type MenuModel, type ScopedTelegramModel, type TelegramModelSwitchContinuationSource, type ThinkingLevel } from "./model.ts";
 export type TelegramModelScope = "all" | "scoped";
 export interface TelegramModelMenuState<TModel extends MenuModel = MenuModel> {
     chatId: number;
@@ -93,8 +93,8 @@ export type TelegramModelMenuCallbackDeps<TModel extends MenuModel = MenuModel>
     setModel: (model: TModel) => Promise<boolean>;
     setCurrentModel: (model: TModel) => void;
     setThinkingLevel: (level: ThinkingLevel) => void;
-    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>) => void;
-    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>) => Promise<boolean> | boolean;
+    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>, continuationTurn: TelegramModelSwitchContinuationSource) => void;
+    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, continuationTurn: TelegramModelSwitchContinuationSource) => Promise<boolean> | boolean;
 };
 export interface TelegramModelMenuOpenDeps<TModel extends MenuModel = MenuModel> {
     isIdle: () => boolean;

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

@@ -506,19 +506,33 @@ export async function handleTelegramModelMenuCallbackAction(callbackQueryId, par
     if (plan.selection.thinkingLevel) {
         deps.setThinkingLevel(plan.selection.thinkingLevel);
     }
-    await deps.updateModelMenuMessage();
+    const continuationTurn = {
+        chatId: params.state.chatId,
+        replyToMessageId: params.state.messageId,
+        target: {
+            chatId: params.state.chatId,
+            ...(params.state.threadId === undefined
+                ? {}
+                : { threadId: params.state.threadId }),
+        },
+    };
     if (plan.mode === "restart-after-tool") {
-        deps.stagePendingModelSwitch(plan.selection);
+        deps.stagePendingModelSwitch(plan.selection, continuationTurn);
+        await deps.updateModelMenuMessage();
         await deps.answerCallbackQuery(callbackQueryId, plan.callbackText);
         return true;
     }
     if (plan.mode === "restart-now") {
-        const restarted = await deps.restartInterruptedTelegramTurn(plan.selection);
+        const restarted = await deps.restartInterruptedTelegramTurn(plan.selection, continuationTurn);
+        await deps.updateModelMenuMessage();
         if (!restarted) {
             await deps.answerCallbackQuery(callbackQueryId, "Pi is busy. Send /abort, /next, or /stop.");
             return true;
         }
     }
+    else {
+        await deps.updateModelMenuMessage();
+    }
     await deps.answerCallbackQuery(callbackQueryId, plan.callbackText);
     return true;
 }

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

@@ -4,7 +4,7 @@
  * Owns app-menu/status state, inline UI text, and callback composition while model/thinking/queue menu details live in dedicated domains
  */
 import { type TelegramMenuMessageRuntimeDeps, type TelegramModelMenuState, type TelegramModelMenuStateBuilderContext, type TelegramModelMenuStateBuilderDeps, type TelegramReplyMarkup } from "./menu-model.ts";
-import { type MenuModel, type ScopedTelegramModel, type ThinkingLevel } from "./model.ts";
+import { type MenuModel, type ScopedTelegramModel, type TelegramModelSwitchContinuationSource, type ThinkingLevel } from "./model.ts";
 import type { TelegramInputRichMessage } from "./telegram-api.ts";
 import { type TelegramSectionRegistry } from "./sections.ts";
 export { applyTelegramModelPageSelection, applyTelegramModelScopeSelection, buildModelMenuReplyMarkup, buildModelPageMenuReplyMarkup, buildTelegramModelCallbackPlan, buildTelegramModelMenuRenderPayload, buildTelegramModelMenuState, buildTelegramModelMenuStateRuntime, buildTelegramModelPageMenuRenderPayload, createTelegramModelMenuRuntime, createTelegramModelMenuStateBuilder, formatScopedModelButtonText, getModelMenuItems, getStoredTelegramModelMenuState, getTelegramModelMenuPage, getTelegramModelSelection, handleTelegramModelMenuCallbackAction, MODEL_MENU_TITLE, MODEL_PAGE_MENU_TITLE, openTelegramModelMenu, pruneStoredTelegramModelMenus, resolveCachedTelegramModelMenuInputs, sendTelegramModelMenuMessage, storeTelegramModelMenuState, TELEGRAM_MODEL_PAGE_SIZE, updateTelegramModelMenuMessage, } from "./menu-model.ts";
@@ -49,14 +49,13 @@ export interface TelegramMenuCallbackRuntimeDeps<TContext, TModel extends MenuMo
     updateSettingsMenuMessage?: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
     answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
     isIdle: (ctx: TContext) => boolean;
-    hasActiveTelegramTurn: () => boolean;
     hasAbortHandler: () => boolean;
     hasActiveToolExecutions: () => boolean;
     persistScopedModelPatterns?: (patterns: string[], ctx: TContext) => Promise<void>;
     setModel: (model: TModel) => Promise<boolean>;
     setCurrentModel: (model: TModel, ctx: TContext) => void;
-    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>, ctx: TContext) => void;
-    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, ctx: TContext) => Promise<boolean> | boolean;
+    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>, ctx: TContext, continuationTurn: TelegramModelSwitchContinuationSource) => void;
+    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, ctx: TContext, continuationTurn: TelegramModelSwitchContinuationSource) => Promise<boolean> | boolean;
     sectionRegistry?: TelegramSectionRegistry;
     editInteractiveMessage?: (chatId: number, messageId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramReplyMarkup) => Promise<void>;
     sendInteractiveMessage?: (chatId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramReplyMarkup, options?: {
@@ -133,14 +132,13 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<TContext, TModel extends
     updateSettingsMenuMessage?: (state: TelegramModelMenuState<TModel>, ctx: TContext) => Promise<void>;
     answerCallbackQuery: (callbackQueryId: string, text?: string) => Promise<void>;
     isIdle: (ctx: TContext) => boolean;
-    hasActiveTelegramTurn: () => boolean;
     hasAbortHandler: () => boolean;
     getActiveToolExecutions: () => number;
     persistScopedModelPatterns?: (patterns: string[], ctx: TContext) => Promise<void>;
     setModel: (model: TModel) => Promise<boolean>;
     setCurrentModel: (model: TModel, ctx: TContext) => void;
-    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>, ctx: TContext) => void;
-    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, ctx: TContext) => Promise<boolean> | boolean;
+    stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>, ctx: TContext, continuationTurn: TelegramModelSwitchContinuationSource) => void;
+    restartInterruptedTelegramTurn: (selection: ScopedTelegramModel<TModel>, ctx: TContext, continuationTurn: TelegramModelSwitchContinuationSource) => Promise<boolean> | boolean;
     sectionRegistry?: TelegramSectionRegistry;
     editInteractiveMessage?: (chatId: number, messageId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramReplyMarkup) => Promise<void>;
     sendInteractiveMessage?: (chatId: number, text: string, mode: "markdown" | "html" | "plain", replyMarkup: TelegramReplyMarkup, options?: {

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

@@ -99,7 +99,6 @@ export function createTelegramMenuCallbackHandlerForContext(deps) {
         updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
         answerCallbackQuery: deps.answerCallbackQuery,
         isIdle: deps.isIdle,
-        hasActiveTelegramTurn: deps.hasActiveTelegramTurn,
         hasAbortHandler: deps.hasAbortHandler,
         hasActiveToolExecutions: () => deps.getActiveToolExecutions() > 0,
         persistScopedModelPatterns: deps.persistScopedModelPatterns,
@@ -228,7 +227,7 @@ export async function handleTelegramMenuCallbackRuntime(query, ctx, deps) {
                     activeModel: deps.getActiveModel(ctx),
                     currentThinkingLevel: deps.getThinkingLevel(),
                     isIdle: deps.isIdle(ctx),
-                    canRestartBusyRun: deps.hasActiveTelegramTurn() && deps.hasAbortHandler(),
+                    canRestartBusyRun: deps.hasAbortHandler(),
                     hasActiveToolExecutions: deps.hasActiveToolExecutions(),
                 }, {
                     updateModelMenuMessage: () => deps.updateModelMenuMessage(state, ctx),
@@ -243,10 +242,10 @@ export async function handleTelegramMenuCallbackRuntime(query, ctx, deps) {
                         deps.setThinkingLevel(level);
                         deps.updateStatus(ctx);
                     },
-                    stagePendingModelSwitch: (selection) => {
-                        deps.stagePendingModelSwitch(selection, ctx);
+                    stagePendingModelSwitch: (selection, continuationTurn) => {
+                        deps.stagePendingModelSwitch(selection, ctx, continuationTurn);
                     },
-                    restartInterruptedTelegramTurn: (selection) => deps.restartInterruptedTelegramTurn(selection, ctx),
+                    restartInterruptedTelegramTurn: (selection, continuationTurn) => deps.restartInterruptedTelegramTurn(selection, ctx, continuationTurn),
                 });
             }
             catch (error) {

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

@@ -52,14 +52,13 @@ export interface PendingModelSwitchStore<TSelection> {
 }
 export interface TelegramInFlightModelSwitchState {
     isIdle: boolean;
-    hasActiveTelegramTurn: boolean;
     hasAbortHandler: boolean;
 }
 export declare function createPendingModelSwitchStore<TSelection>(): PendingModelSwitchStore<TSelection>;
-export declare function canRestartTelegramTurnForModelSwitch(state: TelegramInFlightModelSwitchState): boolean;
+export declare function canRestartAgentRunForTelegramModelSwitch(state: TelegramInFlightModelSwitchState): boolean;
 export declare function shouldTriggerPendingTelegramModelSwitchAbort(state: {
     hasPendingModelSwitch: boolean;
-    hasActiveTelegramTurn: boolean;
+    hasContinuationTurn: boolean;
     hasAbortHandler: boolean;
     activeToolExecutions: number;
 }): boolean;
@@ -70,8 +69,9 @@ export declare function restartTelegramModelSwitchContinuation<TTurn, TSelection
     queueContinuation: (turn: TTurn, selection: TSelection) => void;
 }): boolean;
 export declare function buildTelegramModelSwitchContinuationText<TModel extends MenuModel>(telegramPrefix: string, model: TModel, thinkingLevel?: ScopedTelegramModel<TModel>["thinkingLevel"]): string;
+export type TelegramModelSwitchContinuationSource = Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
 export declare function buildTelegramModelSwitchContinuationTurn<TModel extends MenuModel>(options: {
-    turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
+    turn: TelegramModelSwitchContinuationSource;
     selection: ScopedTelegramModel<TModel>;
     telegramPrefix?: string;
     queueOrder: number;
@@ -82,22 +82,22 @@ export declare function createTelegramModelSwitchContinuationTurnBuilder<TModel
     allocateItemOrder: () => number;
     allocateControlOrder: () => number;
 }): (options: {
-    turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
+    turn: TelegramModelSwitchContinuationSource;
     selection: ScopedTelegramModel<TModel>;
 }) => PendingTelegramTurn;
 export declare function createTelegramModelSwitchContinuationQueue<TContext, TSelection extends ScopedTelegramModel>(deps: {
     createContinuationTurn: (options: {
-        turn: Pick<PendingTelegramTurn, "chatId" | "replyToMessageId" | "target">;
+        turn: TelegramModelSwitchContinuationSource;
         selection: TSelection;
     }) => PendingTelegramTurn;
     appendQueuedItem: (item: PendingTelegramTurn, ctx: TContext) => void;
-}): (turn: PendingTelegramTurn, selection: TSelection, ctx: TContext) => void;
+}): (turn: TelegramModelSwitchContinuationSource, selection: TSelection, ctx: TContext) => void;
 export declare function createTelegramModelSwitchContinuationQueueRuntime<TContext, TSelection extends ScopedTelegramModel>(deps: {
     telegramPrefix?: string;
     allocateItemOrder: () => number;
     allocateControlOrder: () => number;
     appendQueuedItem: (item: PendingTelegramTurn, ctx: TContext) => void;
-}): (turn: PendingTelegramTurn, selection: TSelection, ctx: TContext) => void;
+}): (turn: TelegramModelSwitchContinuationSource, selection: TSelection, ctx: TContext) => void;
 export interface TelegramModelSwitchControllerDeps<TContext, TSelection> {
     isIdle: (ctx: TContext) => boolean;
     getPendingModelSwitch: () => TSelection | undefined;
@@ -106,16 +106,16 @@ export interface TelegramModelSwitchControllerDeps<TContext, TSelection> {
     getAbortHandler: () => (() => void) | undefined;
     hasAbortHandler: () => boolean;
     getActiveToolExecutions: () => number;
-    queueContinuation: (turn: PendingTelegramTurn, selection: TSelection, ctx: TContext) => void;
+    queueContinuation: (turn: TelegramModelSwitchContinuationSource, selection: TSelection, ctx: TContext) => void;
     updateStatus: (ctx: TContext) => void;
 }
 export interface TelegramModelSwitchController<TContext, TSelection> {
     canOfferInFlightSwitch: (ctx: TContext) => boolean;
-    stagePendingSwitch: (selection: TSelection, ctx: TContext) => void;
+    stagePendingSwitch: (selection: TSelection, ctx: TContext, continuationTurn?: TelegramModelSwitchContinuationSource) => void;
     clearPendingSwitch: () => void;
-    queueContinuation: (turn: PendingTelegramTurn, selection: TSelection, ctx: TContext) => void;
+    queueContinuation: (turn: TelegramModelSwitchContinuationSource, selection: TSelection, ctx: TContext) => void;
     triggerPendingAbort: (ctx: TContext) => boolean;
-    restartInterruptedTurn: (selection: TSelection, ctx: TContext) => boolean;
+    restartInterruptedTurn: (selection: TSelection, ctx: TContext, continuationTurn?: TelegramModelSwitchContinuationSource) => boolean;
 }
 export interface TelegramModelSwitchControllerRuntimeDeps<TContext, TSelection extends ScopedTelegramModel> extends Omit<TelegramModelSwitchControllerDeps<TContext, TSelection>, "queueContinuation"> {
     telegramPrefix?: string;

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

@@ -261,12 +261,12 @@ export function createPendingModelSwitchStore() {
         has: () => selection !== undefined,
     };
 }
-export function canRestartTelegramTurnForModelSwitch(state) {
-    return !state.isIdle && state.hasActiveTelegramTurn && state.hasAbortHandler;
+export function canRestartAgentRunForTelegramModelSwitch(state) {
+    return !state.isIdle && state.hasAbortHandler;
 }
 export function shouldTriggerPendingTelegramModelSwitchAbort(state) {
     return (state.hasPendingModelSwitch &&
-        state.hasActiveTelegramTurn &&
+        state.hasContinuationTurn &&
         state.hasAbortHandler &&
         state.activeToolExecutions === 0);
 }
@@ -297,7 +297,7 @@ export function buildTelegramModelSwitchContinuationText(telegramPrefix, model,
     const thinkingSuffix = thinkingLevel
         ? ` Keep the selected thinking level (${thinkingLevel}) if it still applies.`
         : "";
-    return `${telegramPrefix} Continue the interrupted previous Telegram request using the newly selected model (${modelLabel}). Resume from the last unfinished step instead of restarting from scratch unless necessary.${thinkingSuffix}`;
+    return `${telegramPrefix} Continue the interrupted previous request using the newly selected model (${modelLabel}). Resume from the last unfinished step instead of restarting from scratch unless necessary.${thinkingSuffix}`;
 }
 export function buildTelegramModelSwitchContinuationTurn(options) {
     const modelLabel = `${options.selection.model.provider}/${options.selection.model.id}`;
@@ -318,7 +318,7 @@ export function buildTelegramModelSwitchContinuationTurn(options) {
                 text: buildTelegramModelSwitchContinuationText(options.telegramPrefix ?? TELEGRAM_PREFIX, options.selection.model, options.selection.thinkingLevel),
             },
         ],
-        historyText: `Continue interrupted Telegram request on ${modelLabel}`,
+        historyText: `Continue interrupted request on ${modelLabel}`,
         statusSummary: `↻ ${statusLabel || "continue"}`,
     };
 }
@@ -364,46 +364,60 @@ export function createTelegramModelSwitchControllerRuntime(deps) {
     });
 }
 export function createTelegramModelSwitchController(deps) {
+    let pendingContinuationTurn;
+    const triggerPendingAbort = (ctx) => {
+        const turn = pendingContinuationTurn ?? deps.getActiveTurn();
+        if (!shouldTriggerPendingTelegramModelSwitchAbort({
+            hasPendingModelSwitch: !!deps.getPendingModelSwitch(),
+            hasContinuationTurn: !!turn,
+            hasAbortHandler: deps.hasAbortHandler(),
+            activeToolExecutions: deps.getActiveToolExecutions(),
+        })) {
+            return false;
+        }
+        const selection = deps.getPendingModelSwitch();
+        const abort = deps.getAbortHandler();
+        if (!selection || !turn || !abort)
+            return false;
+        pendingContinuationTurn = undefined;
+        deps.setPendingModelSwitch(undefined);
+        deps.queueContinuation(turn, selection, ctx);
+        abort();
+        return true;
+    };
     return {
-        canOfferInFlightSwitch: (ctx) => canRestartTelegramTurnForModelSwitch({
+        canOfferInFlightSwitch: (ctx) => canRestartAgentRunForTelegramModelSwitch({
             isIdle: deps.isIdle(ctx),
-            hasActiveTelegramTurn: !!deps.getActiveTurn(),
             hasAbortHandler: deps.hasAbortHandler(),
         }),
-        stagePendingSwitch: (selection, ctx) => {
+        stagePendingSwitch: (selection, ctx, continuationTurn) => {
+            pendingContinuationTurn = deps.getActiveTurn() ?? continuationTurn;
             deps.setPendingModelSwitch(selection);
-            deps.updateStatus(ctx);
+            try {
+                deps.updateStatus(ctx);
+            }
+            finally {
+                triggerPendingAbort(ctx);
+            }
         },
         clearPendingSwitch: () => {
+            pendingContinuationTurn = undefined;
             deps.setPendingModelSwitch(undefined);
         },
         queueContinuation: deps.queueContinuation,
-        triggerPendingAbort: (ctx) => {
-            if (!shouldTriggerPendingTelegramModelSwitchAbort({
-                hasPendingModelSwitch: !!deps.getPendingModelSwitch(),
-                hasActiveTelegramTurn: !!deps.getActiveTurn(),
-                hasAbortHandler: deps.hasAbortHandler(),
-                activeToolExecutions: deps.getActiveToolExecutions(),
-            })) {
-                return false;
-            }
-            const selection = deps.getPendingModelSwitch();
-            const turn = deps.getActiveTurn();
-            const abort = deps.getAbortHandler();
-            if (!selection || !turn || !abort)
-                return false;
-            deps.setPendingModelSwitch(undefined);
-            deps.queueContinuation(turn, selection, ctx);
-            abort();
-            return true;
+        triggerPendingAbort,
+        restartInterruptedTurn: (selection, ctx, continuationTurn) => {
+            const restarted = restartTelegramModelSwitchContinuation({
+                activeTurn: deps.getActiveTurn() ?? continuationTurn,
+                abort: deps.getAbortHandler(),
+                selection,
+                queueContinuation: (turn, nextSelection) => {
+                    deps.queueContinuation(turn, nextSelection, ctx);
+                },
+            });
+            if (restarted)
+                pendingContinuationTurn = undefined;
+            return restarted;
         },
-        restartInterruptedTurn: (selection, ctx) => restartTelegramModelSwitchContinuation({
-            activeTurn: deps.getActiveTurn(),
-            abort: deps.getAbortHandler(),
-            selection,
-            queueContinuation: (turn, nextSelection) => {
-                deps.queueContinuation(turn, nextSelection, ctx);
-            },
-        }),
     };
 }

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

@@ -353,7 +353,6 @@ export interface TelegramAgentStartHookRuntimeDeps<TTurn extends PendingTelegram
 }
 export type TelegramAgentStartHookEvent = unknown;
 export interface TelegramToolExecutionRuntimeDeps {
-    hasActiveTurn: () => boolean;
     getActiveToolExecutions: () => number;
     setActiveToolExecutions: (count: number) => void;
 }
@@ -372,7 +371,6 @@ export declare function buildTelegramAgentStartPlan<TContext = unknown>(options:
 export declare function handleTelegramAgentStartRuntime<TTurn extends PendingTelegramTurn, TContext = unknown>(deps: TelegramAgentStartRuntimeDeps<TTurn, TContext>): void;
 export declare function createTelegramAgentStartHook<TTurn extends PendingTelegramTurn, TContext = unknown>(deps: TelegramAgentStartHookRuntimeDeps<TTurn, TContext>): (_event: TelegramAgentStartHookEvent, ctx: TContext) => Promise<void>;
 export declare function getNextTelegramToolExecutionCount(options: {
-    hasActiveTurn: boolean;
     currentCount: number;
     event: "start" | "end";
 }): number;

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

@@ -741,8 +741,6 @@ export function createTelegramAgentStartHook(deps) {
     };
 }
 export function getNextTelegramToolExecutionCount(options) {
-    if (!options.hasActiveTurn)
-        return options.currentCount;
     if (options.event === "start") {
         return options.currentCount + 1;
     }
@@ -750,20 +748,16 @@ export function getNextTelegramToolExecutionCount(options) {
 }
 export function handleTelegramToolExecutionStartRuntime(deps) {
     deps.setActiveToolExecutions(getNextTelegramToolExecutionCount({
-        hasActiveTurn: deps.hasActiveTurn(),
         currentCount: deps.getActiveToolExecutions(),
         event: "start",
     }));
 }
 export function handleTelegramToolExecutionEndRuntime(deps) {
-    const hasActiveTurn = deps.hasActiveTurn();
     deps.setActiveToolExecutions(getNextTelegramToolExecutionCount({
-        hasActiveTurn,
         currentCount: deps.getActiveToolExecutions(),
         event: "end",
     }));
-    if (hasActiveTurn)
-        deps.triggerPendingModelSwitchAbort();
+    deps.triggerPendingModelSwitchAbort();
 }
 export function createTelegramAgentLifecycleHooks(deps) {
     const onAgentStart = createTelegramAgentStartHook(deps);
@@ -806,7 +800,6 @@ export function createTelegramToolExecutionHooks(deps) {
         },
         onToolExecutionEnd: (_event, ctx) => {
             handleTelegramToolExecutionEndRuntime({
-                hasActiveTurn: deps.hasActiveTurn,
                 getActiveToolExecutions: deps.getActiveToolExecutions,
                 setActiveToolExecutions: deps.setActiveToolExecutions,
                 triggerPendingModelSwitchAbort: () => {

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

@@ -535,7 +535,6 @@ export function createTelegramInboundRouteRuntime(deps) {
         updateSettingsMenuMessage: deps.updateSettingsMenuMessage,
         answerCallbackQuery: deps.answerCallbackQuery,
         isIdle: deps.isIdle,
-        hasActiveTelegramTurn: deps.activeTurnRuntime.has,
         hasAbortHandler: deps.bridgeRuntime.abort.hasHandler,
         getActiveToolExecutions: deps.bridgeRuntime.lifecycle.getActiveToolExecutions,
         persistScopedModelPatterns: deps.persistScopedModelPatterns,

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

@@ -98,7 +98,6 @@ export interface TelegramTypingLoopDeps {
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
     }) => Promise<unknown>;
-    sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
     shouldContinue?: () => boolean;
     onStopped?: () => void;
 }
@@ -111,7 +110,6 @@ export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntime
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
     }) => Promise<unknown>;
-    sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
     updateStatus: (ctx: TContext, error?: string) => void;
     isContextActive?: (ctx: TContext) => boolean;
     isTransportAvailable?: () => boolean;
@@ -120,7 +118,7 @@ export interface TelegramTypingLoopStarterDeps<TContext> extends TelegramRuntime
 }
 export declare function createTelegramTypingLoopStarter<TContext>(deps: TelegramTypingLoopStarterDeps<TContext>): (ctx: TContext, chatId?: number, options?: {
     target?: TelegramTypingLoopTarget;
-}) => void;
+}) => boolean;
 export declare function startTelegramTypingLoop(state: TelegramBridgeRuntimeState, deps: TelegramTypingLoopDeps): boolean;
 export declare function stopTelegramTypingLoop(state: TelegramBridgeRuntimeState): boolean;
 export declare function waitForTelegramTypingLoopIdle(state: TelegramBridgeRuntimeState, timeoutMs?: number): Promise<void>;
@@ -141,7 +139,7 @@ export interface TelegramPromptDispatchLifecycleDeps<TContext> extends TelegramR
     typing: Pick<TelegramRuntimeTypingPort, "stop">;
     startTypingLoop: (ctx: TContext, chatId?: number, options?: {
         target?: TelegramTypingLoopTarget;
-    }) => void;
+    }) => boolean | void;
     updateStatus: (ctx: TContext, error?: string) => void;
 }
 export interface TelegramPromptDispatchRuntimeDeps<TContext> extends TelegramRuntimeEventRecorderPort {
@@ -151,7 +149,6 @@ export interface TelegramPromptDispatchRuntimeDeps<TContext> extends TelegramRun
     sendTypingAction: (chatId: number, options?: {
         message_thread_id?: number;
     }) => Promise<unknown>;
-    sendAggregateTypingAction?: (chatId: number) => Promise<unknown>;
     updateStatus: (ctx: TContext, error?: string) => void;
     isContextActive?: (ctx: TContext) => boolean;
     isTransportAvailable?: () => boolean;
@@ -161,7 +158,7 @@ export interface TelegramPromptDispatchRuntimeDeps<TContext> extends TelegramRun
 export interface TelegramPromptDispatchRuntime<TContext> {
     startTypingLoop: (ctx: TContext, chatId?: number, options?: {
         target?: TelegramTypingLoopTarget;
-    }) => void;
+    }) => boolean | void;
     onPromptDispatchStart: (ctx: TContext, chatId?: number) => void;
     onPromptDispatchFailure: (ctx: TContext, message: string) => void;
 }