@llblab/pi-telegram 0.51.0 → 0.51.2

package/AGENTS.md

@@ -74,7 +74,7 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 - Threaded Mode has exactly one live leader per bot profile. Followers are real operator-started Pi processes and must authenticate/register over local IPC; Telegram never spawns hidden Pi processes. A live but unreachable owner does not authorize split-brain polling.
 - Local IPC is a trust boundary, not merely a private socket. Unknown, stale, mismatched-generation, or unauthorized requests must not inject prompts, callbacks, API sends, artifacts, liveness, or bindings. Follower registration identity may prepare a binding, but inbound generation authority is published only after successful preparation for the same generation and current context; pending or failed startup cannot append into a retained old journal. Readiness also binds the active Pi context and supplied session generation. Session refresh awaits binding preparation without re-registering; reusing a context object cannot carry readiness across a session-generation change. Registration requests capture session authority before asynchronous startup and fence every publication/finalization against the current attempt. Stop or supersession invalidates that attempt; obsolete cleanup cannot erase a newer registration or a refreshed context.
 - Protocol compatibility is independent from package version. Registration negotiates protocol version, runtime build, and canonical capabilities before target provisioning or live publication. `durable-follower-admission-v1` gates source forwarding; `queue-handoff-v1` independently gates semantic queue transfer for every participant and is advertised only with exact source/recipient journal-binding composition. `follower.register` and capability-gated restore-only `follower.restoreWorkspace` are bootstrap requests; other requests require exact live-registry generation authority, and `bus.ack` is response-only. `thread-display-mode-v1` gates follower display-setting requests; the leader owns their serialized profile preference and title application.
-- Long-lived timers, pollers, watchers, receivers, heartbeats, background delivery, and deferred dispatch are session-bound. Replacement stops stale activity and makes late work inert; teardown must recheck the captured session generation even when context identity is reused. Same-process handoff may preserve exact profile/target identity but never stale Pi context or cross-profile authority. Participating source observations must hold a reference for the actual read, including pending-mutation/count queries against a stopped worker's retained source; a scoped observation never restores receipt readiness or execution authority. A donor cancellation resumed after remote handoff awaits must also hold a source reference; only the existing exact journal CAS may cancel, never undo accepted recipient custody. Stable source keys do not certify captured callable lifetimes: snapshot prepared worker capabilities at construction and replace them on source-handle renewal without replaying unsettled input. Aborting a durable update generation does not release that `update_id`: replacement replay waits for its actual handler settlement, and effectful handlers use the shared execution fence immediately before commit and after awaited delegation. Admission also rechecks that fence after the default handler returns, before its outcome can settle custody; a stopped handler's ordinary return is not completion authority. Internal clones explicitly carry the hidden fence; reroute forwarding, thread-store mutation, cleanup, and Bot API boundaries retain the originating generation.
+- Long-lived timers, pollers, watchers, receivers, heartbeats, background delivery, and deferred dispatch are session-bound. Replacement stops stale activity and makes late work inert; teardown must recheck the captured session generation even when context identity is reused. Same-process handoff may preserve exact profile/target identity but never stale Pi context or cross-profile authority. Follower heartbeat response deadlines align with the eight-second leader stale-liveness window rather than the generic one-second local-RPC default; an ordinary multi-second Pi/TUI event-loop stall is not registration loss. Participating source observations must hold a reference for the actual read, including pending-mutation/count queries against a stopped worker's retained source; a scoped observation never restores receipt readiness or execution authority. A donor cancellation resumed after remote handoff awaits must also hold a source reference; only the existing exact journal CAS may cancel, never undo accepted recipient custody. Stable source keys do not certify captured callable lifetimes: snapshot prepared worker capabilities at construction and replace them on source-handle renewal without replaying unsettled input. Aborting a durable update generation does not release that `update_id`: replacement replay waits for its actual handler settlement, and effectful handlers use the shared execution fence immediately before commit and after awaited delegation. Admission also rechecks that fence after the default handler returns, before its outcome can settle custody; a stopped handler's ordinary return is not completion authority. Internal clones explicitly carry the hidden fence; reroute forwarding, thread-store mutation, cleanup, and Bot API boundaries retain the originating generation.
 - Runtime state is event-driven reconciliation of local assumptions against Telegram signals, not a complete bot read-model and not permission to query Telegram on every action. Destructive thread cleanup goes through `thread-reconciler` with current proof and leader fencing. Fresh Workspace Thread creation derives its initial Bot API title from the active display mode before issuance; the stable generated `threadName` remains separate from the acknowledged `displayTitle`.
 
 ### 4.3 Durable Admission And Settlement
@@ -95,11 +95,12 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 ### 4.4 Queue, Delivery, And User Surfaces
 
 - 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.
+- `/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/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/CHANGELOG.md

@@ -4,6 +4,17 @@
 
 ## 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.
+- `Follower heartbeat stability`: Follower heartbeats now use a dedicated eight-second response deadline aligned with leader stale-liveness policy instead of the generic one-second local-RPC default. Ordinary multi-second TUI/event-loop stalls therefore retain registration and stable `follower` status rather than destroying the socket, producing leader EPIPE noise, and entering repeated reconnect cycles.
+
 ## 0.51.0: Safe Workspace rotation and follower readiness
 
 - `Workspace slot rotation`: Fresh allocation reclaims the oldest proven inactive slot only at full A–Z pressure. Exact grouped receipts may be journal-CAS discarded only after complete source inspection proves every process-birth owner dead. Live/unknown owners, partial groups, handoffs and unrelated work stay protected. Fresh protection precedes Thread/history deletion and slot reuse. Pi sessions/files/memory/journals remain; restore-only never evicts; ambiguous deletion never replays.

package/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/dist/lib/bindings.d.ts

@@ -34,6 +34,7 @@ export interface TelegramQueueBindingRuntime<TContext> {
     mutation: Queue.TelegramQueueMutationController<TContext>;
     dispatchNext: (ctx: TContext) => void;
     requestNextDispatchAnnouncement: () => void;
+    cancelNextDispatchAnnouncement: () => void;
     watchdog: Queue.TelegramQueueDispatchWatchdogRuntime<TContext>;
 }
 export declare function createTelegramQueueBindingRuntime<TContext>(deps: {
@@ -58,6 +59,7 @@ export declare function createTelegramQueueBindingRuntime<TContext>(deps: {
     updateStatus: (ctx: TContext, error?: string) => void;
     sendTextReply: Queue.TelegramQueueDispatchRuntimeDeps<TContext>["sendTextReply"];
     sendUserMessage: Queue.TelegramQueueDispatchRuntimeDeps<TContext>["sendUserMessage"];
+    reconcileNextDispatchAnnouncementReplyOwnership?: (item: Queue.PendingTelegramTurn) => void;
     recordRuntimeEvent?: TelegramRuntimeEventRecorder;
 }): TelegramQueueBindingRuntime<TContext>;
 export interface TelegramGenerativeAppLiveSurfaceBinding {

package/dist/lib/bindings.js

@@ -79,6 +79,7 @@ export function createTelegramQueueBindingRuntime(deps) {
         },
         updateStatus: deps.updateStatus,
         sendTextReply: deps.sendTextReply,
+        reconcileNextDispatchAnnouncementReplyOwnership: deps.reconcileNextDispatchAnnouncementReplyOwnership,
         recordRuntimeEvent: deps.recordRuntimeEvent,
         ...deps.promptDispatch,
         sendUserMessage: deps.sendUserMessage,
@@ -87,6 +88,7 @@ export function createTelegramQueueBindingRuntime(deps) {
         mutation,
         dispatchNext: dispatch.dispatchNext,
         requestNextDispatchAnnouncement: dispatch.requestNextDispatchAnnouncement,
+        cancelNextDispatchAnnouncement: dispatch.cancelNextDispatchAnnouncement,
         watchdog: Queue.createTelegramQueueDispatchWatchdogRuntime({
             hasQueuedItems: deps.store.hasQueuedItems,
             dispatchNextQueuedTelegramTurn: dispatch.dispatchNext,
@@ -674,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/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/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/dist/lib/bus-follower.d.ts

@@ -8,7 +8,7 @@
 import * as Sync from "./sync.ts";
 import * as Threads from "./threads.ts";
 import { type TelegramUpdateJournalStoreOptions } from "./journal.ts";
-import type { TelegramLockEntry, TelegramLockState } from "./locks.ts";
+import { type TelegramLockEntry, type TelegramLockState } from "./locks.ts";
 import type { TelegramQueueHandoffPayload, TelegramQueueHandoffStageResult } from "./queue.ts";
 import type { TelegramTarget } from "./target.ts";
 import { type TelegramBusAgentMessage, type TelegramBusAgentTargetSelector, type TelegramBusEnvelope, type TelegramBusForwardOwnership, type TelegramBusProtocolIdentity, type TelegramBusSocketPathSource } from "./bus.ts";
@@ -18,6 +18,7 @@ export declare const TELEGRAM_BUS_FOLLOWER_PROMOTION_GRACE_MS = 2500;
 export declare const TELEGRAM_FOLLOWER_SESSION_HANDOFF_TTL_MS = 30000;
 export declare const TELEGRAM_BUS_FOLLOWER_CLIENT_TIMEOUT_MS = 30000;
 export declare const TELEGRAM_BUS_FOLLOWER_REGISTRATION_WAIT_MS = 30000;
+export declare const TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS = 8000;
 export declare const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS: number;
 export declare const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_DELAY_MS: number;
 export interface TelegramFollowerSessionHandoff {
@@ -170,6 +171,7 @@ export interface TelegramBusFollowerRegistrationRuntimeDeps<TContext extends {
     registrationRetryAttempts?: number;
     registrationRetryDelayMs?: number;
     heartbeatMs?: number;
+    heartbeatTimeoutMs?: number;
     recordRuntimeEvent?: (category: string, error: unknown, details?: Record<string, unknown>) => void;
     onHeartbeatFailure?: (error: unknown, ctx: TContext) => Promise<void> | void;
     onRegistered?: (ctx: TContext) => Promise<void> | void;

package/dist/lib/bus-follower.js

@@ -9,6 +9,7 @@ import { basename } from "node:path";
 import * as Sync from "./sync.js";
 import * as Threads from "./threads.js";
 import { parseTelegramUpdateJournalQueueOwner } from "./journal.js";
+import { TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS, } from "./locks.js";
 import { isTelegramApiMethodRetrySafe, TelegramApiCommitUnknownError, TelegramApiStaleTargetError, } from "./telegram-api.js";
 import { createTelegramBusFollowerDeliveryIdentity, createTelegramBusFollowerTargetController, createTelegramBusForeignOwnedUpdateForwarder, createTelegramBusLocalServer, createTelegramBusRequestIdFactory, createUnauthorizedBusAck, getTelegramBusProtocolCompatibility, getTelegramBusSocketPath, hasTelegramBusCapability, isTelegramBusEnvelopeAuthorized, resolveTelegramBusSocketPath, sendTelegramBusLocalEnvelope, TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME, TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE, TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT, } from "./bus.js";
 import { getTelegramBusTransportRetryPolicy, TELEGRAM_BUS_REGISTRATION_RETRY, } from "./bus-transport.js";
@@ -17,6 +18,7 @@ export const TELEGRAM_BUS_FOLLOWER_PROMOTION_GRACE_MS = 2_500;
 export const TELEGRAM_FOLLOWER_SESSION_HANDOFF_TTL_MS = 30_000;
 export const TELEGRAM_BUS_FOLLOWER_CLIENT_TIMEOUT_MS = 30_000;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_WAIT_MS = 30_000;
+export const TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS = TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS = TELEGRAM_BUS_REGISTRATION_RETRY.attempts;
 export const TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_DELAY_MS = TELEGRAM_BUS_REGISTRATION_RETRY.delayMs;
 const TELEGRAM_FOLLOWER_SESSION_HANDOFF_KEY = "__piTelegramFollowerSessionHandoff";
@@ -920,6 +922,9 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
     const getNowMs = deps.getNowMs ?? Date.now;
     const getPid = deps.getPid ?? (() => process.pid);
     const heartbeatMs = deps.heartbeatMs ?? 1000;
+    const heartbeatTimeoutMs = deps.heartbeatTimeoutMs ??
+        deps.timeoutMs ??
+        TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS;
     const registrationTimeoutMs = deps.registrationTimeoutMs ?? deps.timeoutMs ?? 30000;
     const registrationRetryAttempts = deps.registrationRetryAttempts ??
         TELEGRAM_BUS_FOLLOWER_REGISTRATION_RETRY_ATTEMPTS;
@@ -979,7 +984,7 @@ export function createTelegramBusFollowerRegistrationRuntime(deps) {
         try {
             const response = await sendTelegramBusLocalEnvelope({
                 socketPath: leaderSocketPath,
-                timeoutMs: deps.timeoutMs,
+                timeoutMs: heartbeatTimeoutMs,
                 retry: getTelegramBusTransportRetryPolicy({
                     endpoint: leaderSocketPath,
                     operation: "operation",

package/dist/lib/commands.d.ts

@@ -210,6 +210,7 @@ export interface TelegramCommandActionDeps<TMessage, TContext> {
 export interface TelegramStopCommandDeps {
     hasAbortHandler: () => boolean;
     clearPendingModelSwitch: () => void;
+    cancelNextTransitionAnnouncements?: () => void;
     clearQueuedTelegramItems: () => number;
     setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
     abortCurrentTurn: () => void;
@@ -392,6 +393,8 @@ export interface TelegramCommandRuntimeDeps<TMessage extends TelegramCommandRunt
     isContextActive?: (ctx: TContext) => boolean;
     dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
     requestNextDispatchAnnouncement?: () => void;
+    markActiveTurnNextAbortAnnouncement?: () => boolean;
+    cancelNextTransitionAnnouncements?: () => void;
     requestDeferredDispatchNextQueuedTelegramTurn?: (dispatch: (ctx: TContext) => void) => void;
     startTypingLoop?: (ctx: TContext, chatId?: number, options?: {
         target?: {
@@ -504,6 +507,7 @@ export declare function handleTelegramAbortCommand(deps: {
     hasAbortHandler: () => boolean;
     hasActiveTelegramTurn: () => boolean;
     clearPendingModelSwitch: () => void;
+    cancelNextTransitionAnnouncements?: () => void;
     abortCurrentTurn: () => void;
     setFoldQueuedPromptsIntoHistory: (fold: boolean) => void;
     updateStatus: () => void;
@@ -519,6 +523,7 @@ export declare function handleTelegramNextCommand(deps: {
     abortCurrentTurn: () => void;
     dispatchNextQueuedTurn: () => void;
     requestNextDispatchAnnouncement?: () => void;
+    markActiveTurnNextAbortAnnouncement?: () => boolean;
     clearFoldForDispatch: () => void;
     updateStatus: () => void;
     sendTextReply: (text: string, options?: {

package/dist/lib/commands.js

@@ -631,6 +631,7 @@ function formatTelegramQueuedTurnCount(count) {
 }
 export async function handleTelegramStopCommand(deps) {
     deps.clearPendingModelSwitch();
+    deps.cancelNextTransitionAnnouncements?.();
     const clearedCount = deps.clearQueuedTelegramItems();
     deps.setFoldQueuedPromptsIntoHistory(false);
     if (!deps.hasAbortHandler()) {
@@ -651,6 +652,7 @@ export async function handleTelegramStopCommand(deps) {
 }
 export async function handleTelegramAbortCommand(deps) {
     deps.clearPendingModelSwitch();
+    deps.cancelNextTransitionAnnouncements?.();
     if (!deps.hasAbortHandler()) {
         await deps.sendTextReply(formatTelegramInformationHeading("💤", "No active turn."), { parseMode: "HTML" });
         return;
@@ -669,6 +671,7 @@ export async function handleTelegramNextCommand(deps) {
     if (!deps.isIdle() && deps.hasAbortHandler()) {
         deps.clearFoldForDispatch();
         deps.requestNextDispatchAnnouncement?.();
+        deps.markActiveTurnNextAbortAnnouncement?.();
         deps.abortCurrentTurn();
         deps.updateStatus();
         return;
@@ -934,6 +937,9 @@ export function createTelegramCommandHandlerTargetRuntime(deps) {
         updateStatus: deps.updateStatus,
         isContextActive: deps.isContextActive,
         dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+        requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+        markActiveTurnNextAbortAnnouncement: deps.markActiveTurnNextAbortAnnouncement,
+        cancelNextTransitionAnnouncements: deps.cancelNextTransitionAnnouncements,
         startTypingLoop: deps.startTypingLoop,
         stopTypingLoop: deps.stopTypingLoop,
         enqueueContinueTurn: deps.enqueueContinueTurn,
@@ -1039,6 +1045,7 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
             await handleTelegramStopCommand({
                 hasAbortHandler: deps.hasAbortHandler,
                 clearPendingModelSwitch: deps.clearPendingModelSwitch,
+                cancelNextTransitionAnnouncements: deps.cancelNextTransitionAnnouncements,
                 clearQueuedTelegramItems: () => deps.clearQueuedTelegramItems(commandCtx),
                 setFoldQueuedPromptsIntoHistory: deps.setFoldQueuedPromptsIntoHistory,
                 abortCurrentTurn: deps.abortCurrentTurn,
@@ -1085,6 +1092,7 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
                 hasAbortHandler: deps.hasAbortHandler,
                 hasActiveTelegramTurn: deps.hasActiveTelegramTurn,
                 clearPendingModelSwitch: deps.clearPendingModelSwitch,
+                cancelNextTransitionAnnouncements: deps.cancelNextTransitionAnnouncements,
                 abortCurrentTurn: deps.abortCurrentTurn,
                 setFoldQueuedPromptsIntoHistory: deps.setFoldQueuedPromptsIntoHistory,
                 updateStatus: updateStatusFor(commandCtx),
@@ -1100,6 +1108,7 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
                 abortCurrentTurn: deps.abortCurrentTurn,
                 dispatchNextQueuedTurn: () => deps.dispatchNextQueuedTelegramTurn(commandCtx),
                 requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+                markActiveTurnNextAbortAnnouncement: deps.markActiveTurnNextAbortAnnouncement,
                 clearFoldForDispatch: () => deps.setFoldQueuedPromptsIntoHistory(false),
                 updateStatus: updateStatusFor(commandCtx),
                 sendTextReply: sendReplyFor(nextMessage),

package/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() {
@@ -642,7 +641,7 @@ export default function (pi) {
             editMessageText: editTelegramMessageText,
         },
     });
-    const { mutation: queueMutationRuntime, dispatchNext: dispatchNextQueuedTelegramTurn, requestNextDispatchAnnouncement, watchdog: queueDispatchWatchdogRuntime, } = Bindings.createTelegramQueueBindingRuntime({
+    const { mutation: queueMutationRuntime, dispatchNext: dispatchNextQueuedTelegramTurn, requestNextDispatchAnnouncement, cancelNextDispatchAnnouncement, watchdog: queueDispatchWatchdogRuntime, } = Bindings.createTelegramQueueBindingRuntime({
         store: telegramQueueStore,
         queue,
         lifecycle,
@@ -656,6 +655,9 @@ export default function (pi) {
         updateStatus,
         sendTextReply,
         sendUserMessage,
+        reconcileNextDispatchAnnouncementReplyOwnership(item) {
+            Replies.preserveTransportReplyDedupOnNextReset(item.chatId, item.replyToMessageId, item.target);
+        },
         recordRuntimeEvent,
     });
     const { finalizeMarkdownPreview, preparePreviewDelivery } = Outbound.createTelegramOutboundTextPreviewRuntime({
@@ -887,6 +889,7 @@ export default function (pi) {
         isContextActive: telegramSessionContextStore.isCurrent,
         dispatchNextQueuedTelegramTurn,
         requestNextDispatchAnnouncement,
+        cancelNextDispatchAnnouncement,
         requestDeferredDispatchNextQueuedTelegramTurn: deferredQueueDispatchRuntime.request,
         hasDeferredDispatchContext: deferredQueueDispatchRuntime.isBound,
         startTypingLoop: promptDispatchRuntime.startTypingLoop,
@@ -1349,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/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/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/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/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/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;