@llblab/pi-kit 0.21.2 → 0.22.1

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;
 }

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

@@ -3,7 +3,7 @@
  * Zones: pi agent runtime state, telegram session, shared coordination
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
-const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 2500;
+const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 3_000;
 const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 export function createTelegramBridgeRuntimeState() {
     return {
@@ -177,9 +177,9 @@ export function createTelegramTypingLoopStarter(deps) {
                 Object.is(deps.getTransportAuthority(), transportAuthority)
             : deps.isTransportAvailable?.() !== false;
         if (!hasTransport())
-            return;
+            return false;
         let active = true;
-        deps.typing.start({
+        return deps.typing.start({
             chatId: chatId ?? deps.getDefaultChatId(),
             target: options?.target,
             intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
@@ -202,13 +202,6 @@ export function createTelegramTypingLoopStarter(deps) {
                         deps.typing.stop();
                         return;
                     }
-                    const message = error instanceof Error ? error.message : String(error);
-                    updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
-                        error: message,
-                        category: "typing",
-                        phase: "status-update",
-                        recordRuntimeEvent: deps.recordRuntimeEvent,
-                    });
                     try {
                         deps.recordRuntimeEvent?.("typing", error, {
                             chatId: targetChatId,
@@ -219,45 +212,6 @@ export function createTelegramTypingLoopStarter(deps) {
                     }
                 }
             },
-            sendAggregateTypingAction: deps.sendAggregateTypingAction
-                ? async (targetChatId) => {
-                    if (!active)
-                        return;
-                    if (!hasTransport()) {
-                        deps.typing.stop();
-                        return;
-                    }
-                    try {
-                        await deps.sendAggregateTypingAction?.(targetChatId);
-                    }
-                    catch (error) {
-                        if (deps.isContextActive?.(ctx) === false)
-                            return;
-                        if (!active)
-                            return;
-                        if (!hasTransport()) {
-                            deps.typing.stop();
-                            return;
-                        }
-                        const message = error instanceof Error ? error.message : String(error);
-                        updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
-                            error: message,
-                            category: "typing",
-                            phase: "status-update",
-                            recordRuntimeEvent: deps.recordRuntimeEvent,
-                        });
-                        try {
-                            deps.recordRuntimeEvent?.("typing", error, {
-                                chatId: targetChatId,
-                                aggregate: true,
-                            });
-                        }
-                        catch {
-                            // Typing diagnostics cannot escape the in-flight action owner.
-                        }
-                    }
-                }
-                : undefined,
             shouldContinue: hasTransport,
             onStopped: () => {
                 active = false;
@@ -296,12 +250,7 @@ export function startTelegramTypingLoop(state, deps) {
         const targetChatId = activeDeps.chatId;
         const threadParams = getTelegramTypingLoopThreadParams(activeDeps.target);
         const typing = Promise.resolve()
-            .then(async () => {
-            await activeDeps.sendTypingAction(targetChatId, threadParams);
-            if (threadParams?.message_thread_id !== undefined) {
-                await activeDeps.sendAggregateTypingAction?.(targetChatId);
-            }
-        })
+            .then(() => activeDeps.sendTypingAction(targetChatId, threadParams))
             .then(() => undefined)
             .catch(() => undefined);
         state.typingInFlight = typing;

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

@@ -900,7 +900,8 @@ export function createTelegramBridgeApiRuntime(deps) {
     const chatActionMinIntervalMs = Math.max(0, deps.chatActionMinIntervalMs ?? 2_000);
     const chatActionMaxGates = Math.max(1, deps.chatActionMaxGates ?? 256);
     const chatActionGates = new Map();
-    const getChatActionKey = (method, body) => {
+    const chatActionChatGates = new Map();
+    const getChatActionKeys = (method, body) => {
         if (method !== "sendChatAction")
             return undefined;
         const chatId = body.chat_id;
@@ -909,32 +910,52 @@ export function createTelegramBridgeApiRuntime(deps) {
             typeof action !== "string") {
             return undefined;
         }
+        const chat = String(chatId);
         const threadId = body.message_thread_id;
-        return `${String(chatId)}:${typeof threadId === "number" || typeof threadId === "string"
-            ? String(threadId)
-            : "all"}:${action}`;
+        return {
+            action: `${chat}:${typeof threadId === "number" || typeof threadId === "string"
+                ? String(threadId)
+                : "all"}:${action}`,
+            chat,
+        };
     };
     const callRecorded = async (method, body, options) => {
         const recoverError = deps.captureRequestErrorHandler?.(body);
-        const chatActionKey = getChatActionKey(method, body);
-        if (chatActionKey) {
+        const chatActionKeys = getChatActionKeys(method, body);
+        if (chatActionKeys) {
             const nowMs = now();
             for (const [key, candidate] of chatActionGates) {
                 if (!candidate.inFlight && nowMs >= candidate.notBeforeMs) {
                     chatActionGates.delete(key);
                 }
             }
-            let gate = chatActionGates.get(chatActionKey);
+            for (const [key, candidate] of chatActionChatGates) {
+                if (!candidate.inFlight && nowMs >= candidate.notBeforeMs) {
+                    chatActionChatGates.delete(key);
+                }
+            }
+            let gate = chatActionGates.get(chatActionKeys.action);
             if (!gate) {
                 if (chatActionGates.size >= chatActionMaxGates)
                     return true;
                 gate = { notBeforeMs: 0 };
-                chatActionGates.set(chatActionKey, gate);
+                chatActionGates.set(chatActionKeys.action, gate);
+            }
+            let chatGate = chatActionChatGates.get(chatActionKeys.chat);
+            if (!chatGate) {
+                if (chatActionChatGates.size >= chatActionMaxGates) {
+                    return true;
+                }
+                chatGate = { notBeforeMs: 0 };
+                chatActionChatGates.set(chatActionKeys.chat, chatGate);
             }
             if (gate.inFlight)
                 return (await gate.inFlight);
-            if (now() < gate.notBeforeMs)
+            if (chatGate.inFlight)
                 return true;
+            if (nowMs < gate.notBeforeMs || nowMs < chatGate.notBeforeMs) {
+                return true;
+            }
             let request;
             request = Promise.resolve()
                 .then(() => deps.client.call(method, body, {
@@ -949,7 +970,9 @@ export function createTelegramBridgeApiRuntime(deps) {
                 await recoverRequestError(recoverError, error);
                 if (error instanceof TelegramApiHttpError && error.status === 429) {
                     const retryAfterMs = Math.max(chatActionMinIntervalMs, (error.retryAfterSeconds ?? 0) * 1_000);
-                    gate.notBeforeMs = now() + retryAfterMs;
+                    const notBeforeMs = now() + retryAfterMs;
+                    gate.notBeforeMs = notBeforeMs;
+                    chatGate.notBeforeMs = Math.max(chatGate.notBeforeMs, notBeforeMs);
                     deps.recordRuntimeEvent("api", error, withTelegramTransportDiagnostics(error, {
                         method,
                         rateLimited: true,
@@ -963,8 +986,11 @@ export function createTelegramBridgeApiRuntime(deps) {
                 .finally(() => {
                 if (gate.inFlight === request)
                     gate.inFlight = undefined;
+                if (chatGate.inFlight === request)
+                    chatGate.inFlight = undefined;
             });
             gate.inFlight = request;
+            chatGate.inFlight = request;
             return request;
         }
         try {

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

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

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

@@ -526,7 +526,7 @@ Queued controls:
 
 - `/continue` creates a priority Telegram-owned `continue` prompt.
 - Prompt-template commands expand Telegram-safe Pi template aliases before entering the prompt queue.
-- Model-switch continuation uses the control lane when an in-flight Telegram-owned run must be stopped and resumed.
+- Model-switch continuation uses the control lane when any interruptible in-flight agent run in the current Pi session must be stopped and resumed. A Telegram-owned run retains its prompt target; otherwise the exact model-menu chat/Thread/message supplies continuation and reply ownership.
 
 Queue and menu mutations are reachable through Telegram updates handled by the current polling owner. After ownership moves, the old instance keeps processing its accepted local queue, but it no longer receives new menu callbacks or control updates for remote mutation. UI label, navigation, tab, toggle, card, and dialog rules are defined in [UI Style](./ui-style.md). Callback prefix ownership is defined in [Callback Namespaces](./callback-namespaces.md).
 
@@ -539,10 +539,10 @@ Native typing during compaction follows connected-instance activity rather than
 - Confirmed manual `/compact` starts a native `typing` keepalive in the command target and stops it on completion/failure.
 - Automatic/session compaction with an active Telegram turn reuses that turn's target.
 - Automatic/session compaction without an active Telegram turn uses the connected instance's assigned target; an unconnected instance sends nothing.
-- Thread-targeted typing is sent to the concrete thread and mirrored to `All` as the aggregate activity surface; completion, native failure, timeout, and shutdown stop the keyed loop.
+- Thread-targeted typing is sent only to the concrete thread. Aggregate `All` mirroring is intentionally omitted because duplicating every keepalive multiplies shared-chat flood pressure. Compaction completion, failure, or timeout stops only a loop actually started by the compaction observer; a pre-existing agent-owned loop remains active. Authority loss and shutdown still stop the keyed loop.
 - Pi `ui_prompt_start` pauses typing while an extension-owned local prompt waits for the operator; `ui_prompt_end` emits the matching Activity boundary and resumes typing whenever agent or compaction work remains unsettled.
 
-At every connected instance `agent_start`, the lifecycle binding starts Telegram's native `…typing` indicator in that instance's assigned target, whether the run came from Telegram, the local TUI, or an autonomous continuation such as Grow Loop. Terminal `Active` remains Telegram-turn-specific; the native indicator answers the separate question of whether the instance is doing agent work. Each loop keeps one action in flight, while the leader API runtime coalesces identical chat/thread/action calls across local and follower traffic for two seconds; expired gates prune opportunistically and at most 256 currently active keys are retained. A Telegram 429 response opens the exact action's shared `retry_after` suppression window without scheduling delayed retries or projecting expected activity throttling as a terminal status error. Assistant message start/update hooks still re-arm it during Telegram-owned turns so transient provider/model errors do not leave a continuing run without activity feedback, and agent/session completion stops it.
+At every connected instance `agent_start`, the lifecycle binding starts Telegram's native `…typing` indicator in that instance's assigned target, whether the run came from Telegram, the local TUI, or an autonomous continuation such as Grow Loop. Terminal `Active` remains Telegram-turn-specific; the native indicator answers the separate question of whether the instance is doing agent work. Each loop refreshes its exact target every three seconds and keeps one action in flight. The leader API runtime coalesces identical chat/thread/action calls for two seconds, permits at most one concurrent chat action per chat, and shares a Telegram 429 `retry_after` fence across every Thread key in that chat; expired gates prune opportunistically and each gate family retains at most 256 active keys. Suppression never schedules a delayed retry. A failed typing action remains a structured diagnostic but cannot project `error` onto an otherwise healthy connected/leader/follower status. Assistant message start/update hooks still re-arm typing during Telegram-owned turns so transient provider/model errors do not leave a continuing run without activity feedback, and agent/session completion stops it.
 
 ### Rendering And Delivery
 
@@ -625,14 +625,14 @@ Telegram prompt guidance is context- and authority-aware. The package and source
 
 ## In-Flight Model Switching
 
-When `/model` is used during an active Telegram-owned run, the bridge can emulate Pi's interactive stop/switch/continue workflow:
+When `/model` is used during an interruptible active agent run in the current Pi session, the bridge emulates Pi's interactive stop/switch/continue workflow:
 
 1. Apply the selected model immediately.
-2. Queue or stage a synthetic Telegram continuation turn.
-3. Abort the active Telegram turn immediately, or wait for the current tool to finish before aborting.
-4. Dispatch the continuation after abort completion.
+2. Queue or stage a synthetic Telegram continuation turn before aborting.
+3. Abort immediately, or wait for every active tool execution to finish before aborting.
+4. Dispatch the continuation in the same session context under the selected model.
 
-This is limited to Telegram-owned runs. If Pi is busy with non-Telegram work, the bridge refuses the switch instead of hijacking unrelated activity.
+A Telegram-originated run retains its active prompt target and reply anchor. For local/TUI or autonomous work without an active Telegram turn, the exact authorized model-menu chat, Thread, and message become the continuation target and reply anchor. Merely busy non-agent lifecycle work remains ineligible because no active agent abort handler exists. Pending selection and fallback-target state clear together on cancellation, new agent start, settlement, or session replacement.
 
 ## Shutdown And Timer Lifecycle
 

package/node_modules/@llblab/pi-telegram/docs/multi-instance-bus.md

@@ -336,7 +336,7 @@ In Telegram private-chat Threaded Mode:
 - Prompts typed in a thread route to the owning instance.
 - Replies, previews, files, voice, and buttons stay in that thread.
 - Queue controls and reactions affect only that instance target.
-- Telegram's native `…typing` indicator for real agent work is sent to that instance thread and mirrored to `All`; `All` is the aggregate surface and should show activity when any bound instance is running a Telegram turn, local prompt, or autonomous continuation. Terminal `Active` remains Telegram-turn-specific. Startup/connect/reload/recovery must not send activity by themselves.
+- Telegram's native `…typing` indicator for real agent work is refreshed only in that instance's exact Thread. Aggregate `All` mirroring is intentionally omitted because it duplicates every keepalive against the shared chat and amplifies Telegram flood control. Telegram turns, local prompts, and autonomous continuations all use the exact instance target. Terminal `Active` remains Telegram-turn-specific. Startup/connect/reload/recovery must not send activity by themselves.
 - Generic heartbeat pruning remains silent and preserves the thread as a restart hint. With cleanup enabled, a later exact-PID death confirmation may delete it without posting an `Instance offline` notice. With cleanup disabled, a fenced owner-detachment commit records inactivity but retains the Thread and its Workspace slot for restoration or fully guarded capacity rotation. Confirmed deletion removes live routing authority but retains the Workspace binding's friendly name and uppercase ordering slot; a later authenticated reopen probes the old target, replaces it only on exact stale/deleted evidence, and carries that name and slot onto the new Thread.
 - If the same binding identity returns, authenticated registration can reclaim the thread after the required visibility proof.
 
@@ -406,7 +406,7 @@ Threaded Mode should make follower threads behave like normal Telegram instance
 | Replies/finals                   | Final replies land in the same thread                                                                                                                                                                                                                 | Follower finals go through leader transport into follower thread                                                                                                                                                                                                | Outbound calls carry target and inject `message_thread_id`                                                                                                                                                                                          | Reply delivery and bus API tests                                                                                          |
 | Previews/Rich Drafts             | Draft previews use the active thread target                                                                                                                                                                                                           | Follower previews use the same native draft lifecycle through the leader                                                                                                                                                                                        | Preview transport preserves target and draft id                                                                                                                                                                                                     | Preview thread-target tests                                                                                               |
 | Attachments/voice                | Files and voice upload in the instance thread                                                                                                                                                                                                         | Follower uploads route through leader multipart transport                                                                                                                                                                                                       | Multipart calls are target-scoped and follower-authorized                                                                                                                                                                                           | Bus allowlist and outbound delivery tests                                                                                 |
-| Native activity status           | `sendChatAction(typing)` renders Telegram's native `…typing` indicator in the assigned thread and mirrors aggregate `All` for every agent run, including local and autonomous work; terminal identity remains `connected`, with active work included in the green Queue count | Followers route one thread action and one aggregate action through leader transport for any agent run while retaining their stable terminal `follower` identity and green activity count                                                                                       | Agent lifecycle targets the active Telegram turn when present and otherwise the instance binding; one keyed loop avoids duplicate aggregate sends/rate-limit pressure                                                                               | Agent-start binding, typing-loop, target-routing, and terminal-status regressions                                         |
+| Native activity status           | `sendChatAction(typing)` refreshes Telegram's native `…typing` indicator only in the assigned Thread for every agent run, including local and autonomous work; aggregate `All` is not mirrored, terminal identity remains `connected`, and active work stays included in the green Queue count | Followers route the exact Thread action through leader transport while retaining their stable terminal `follower` identity and green activity count; the leader admits one concurrent action per chat and shares Telegram 429 cooldown across that chat's Thread keys                                                                                       | Agent lifecycle targets the active Telegram turn when present and otherwise the instance binding; one keyed loop avoids duplicate aggregate sends/rate-limit pressure                                                                               | Agent-start binding, typing-loop, target-routing, and terminal-status regressions                                         |
 | Leader election / promotion      | Current leader keeps its thread across reload                                                                                                                                                                                                         | A promoted follower keeps its existing thread, slot, and name when elected and after later reload                                                                                                                                                               | Promotion converts the current follower binding into the leader profile before forced lock acquisition, so leader startup reuses it instead of provisioning a new thread                                                                            | Follower heartbeat recovery passes binding snapshot into promotion; own-topic provisioner reuses promoted bindings        |
 | `/start` command/menu bootstrap  | Registers visible bot commands and opens the menu                                                                                                                                                                                                     | Follower `/start` can refresh the bot command menu through the leader and open its local menu without warnings                                                                                                                                                  | Bot command registration is a validated global Bot API call allowed through trusted follower bus transport                                                                                                                                          | Bus allowlist regression for `setMyCommands`                                                                              |
 | Follower reconnect               | Existing leader binding is reused only when still usable                                                                                                                                                                                              | Same-process `/new` or `/reload` suspends the old follower socket/context and automatically re-registers the new session to the exact prior target; explicit reconnect to a genuinely closed/stale Telegram tab still recreates a visible thread before success | A short-lived handoff carries the assigned target across session replacement, and the leader transfers that binding to the new runtime instance id by stable manual-follower identity; stale Bot API errors remain the proof for fresh provisioning | Session handoff/refresh, leader binding-transfer, persisted leader-reload reuse, and stale-target replacement regressions |

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

@@ -1203,10 +1203,13 @@ export function registerTelegramLifecycleRuntimeHooks({
     if (uiPromptActive || !canSendAgentActivity(ctx)) 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: Pi.ExtensionContext): void => {
     if (uiPromptActive) return;

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

@@ -82,13 +82,6 @@ function rejectTelegramDirectOwnership(method: string): Promise<never> {
   );
 }
 
-export function createTelegramAggregateTypingActionSender(
-  runtime: Pick<TelegramBridgeApiRuntime, "call">,
-): (chatId: number) => Promise<unknown> {
-  return (chatId) =>
-    runtime.call("sendChatAction", { chat_id: chatId, action: "typing" });
-}
-
 export function createTelegramBusAwareApiRuntime(
   deps: TelegramBusAwareApiRuntimeDeps,
 ): TelegramBridgeApiRuntime {

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

@@ -667,8 +667,6 @@ export default function (pi: Pi.ExtensionAPI) {
     typing,
     getDefaultChatId: proactivePushChatIdGetter,
     sendTypingAction,
-    sendAggregateTypingAction:
-      BusApi.createTelegramAggregateTypingActionSender(telegramApiRuntime),
     updateStatus,
     isContextActive: telegramSessionContextStore.isCurrent,
     getTransportAuthority() {
@@ -1628,7 +1626,7 @@ export default function (pi: Pi.ExtensionAPI) {
         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/lib/menu-model.ts

@@ -13,6 +13,7 @@ import {
   resolveScopedModelPatterns,
   type ScopedTelegramModel,
   sortScopedModels,
+  type TelegramModelSwitchContinuationSource,
   type ThinkingLevel,
 } from "./model.ts";
 
@@ -157,9 +158,13 @@ export type TelegramModelMenuCallbackDeps<
   setModel: (model: TModel) => Promise<boolean>;
   setCurrentModel: (model: TModel) => void;
   setThinkingLevel: (level: ThinkingLevel) => void;
-  stagePendingModelSwitch: (selection: ScopedTelegramModel<TModel>) => void;
+  stagePendingModelSwitch: (
+    selection: ScopedTelegramModel<TModel>,
+    continuationTurn: TelegramModelSwitchContinuationSource,
+  ) => void;
   restartInterruptedTelegramTurn: (
     selection: ScopedTelegramModel<TModel>,
+    continuationTurn: TelegramModelSwitchContinuationSource,
   ) => Promise<boolean> | boolean;
 };
 
@@ -961,14 +966,28 @@ export async function handleTelegramModelMenuCallbackAction<
   if (plan.selection.thinkingLevel) {
     deps.setThinkingLevel(plan.selection.thinkingLevel);
   }
-  await deps.updateModelMenuMessage();
+  const continuationTurn: TelegramModelSwitchContinuationSource = {
+    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,
@@ -976,6 +995,8 @@ export async function handleTelegramModelMenuCallbackAction<
       );
       return true;
     }
+  } else {
+    await deps.updateModelMenuMessage();
   }
   await deps.answerCallbackQuery(callbackQueryId, plan.callbackText);
   return true;