@llblab/pi-kit 0.22.0 → 0.22.2

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.22.2 - 2026-09-24
+
+- `Follower Registration Recovery`: Advances the exact Telegram pin to `0.51.3`. Followers whose retained target record contains a stale Workspace slot now reconcile to the authenticated canonical claim before binding commit, durably repairing their record without disturbing an unrelated binding that owns the old letter or making unnecessary Bot API calls.
+- `Filterable Packaged Skills`: Installed npm/git packages now leave Telegram Skill discovery to the manifest so Pi resource filters are honored. Raw TypeScript checkouts under Pi's extensions directory retain adjacent source-Skill discovery without creating a duplicate packaged discovery path.
+- `Package Cohort`: Keeps every other bundled package at its current exact version. Package membership, resource paths, load order, Pi minimum, and bundled Skill inventory remain unchanged.
+
+## 0.22.1 - 2026-09-24
+
+- `In-Flight Model Switching`: Advances the exact Telegram pin to `0.51.2`. Telegram model selection can stop, switch, and continue any interruptible run in the current Pi session, including local/TUI work, while preserving the authorized chat, Thread, and reply target and deferring abort until active tools settle.
+- `Typing Continuity`: Native presence refreshes only the assigned Thread, coalesces concurrent chat actions, shares Telegram cooldown across Thread keys, and preserves an existing agent typing loop through compaction. Best-effort typing failures no longer replace healthy leader/follower status with an error.
+- `Package Cohort`: Keeps every other bundled package at its current exact version. Package membership, resource paths, load order, Pi minimum, and bundled Skill ownership remain unchanged.
+
 ## 0.22.0 - 2026-09-23
 
 - `Named npm Extensions`: Advances the exact Clean Room pin to `0.2.0`. `/clean-room <package-name>` now loads installed npm Pi extensions by name, including scoped packages, while preserving explicit resource isolation and project-local precedence.

package/README.md

@@ -15,7 +15,7 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.10.0` | Compact Codex/Spark subscription-limit and Business credit-usage status |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.8.1` | Visible continuation scheduling and bounded worker Skills |
 | [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.18.1` | Incremental scoped context/memory compiler with independent scope revisions, canonical file persistence, bounded and diagnosable Git backup replication, native working context within each run, and targeted historical reads |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.51.1` | Telegram companion with stable follower heartbeats, exact queue-transition notices, pressure-safe Workspace rotation, adaptive Thread continuity, files, voice, controls, and bundled Telegram interaction Skills |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.51.3` | Telegram companion with self-healing follower registration, filterable packaged Skills, in-flight model switching, continuous exact-Thread typing, pressure-safe Workspace rotation, files, voice, and controls |
 | [`@llblab/skills`](https://github.com/llblab/skills) | `1.15.0` | Portable workflows for engineering, review, design, context maintenance, and other focused tasks |
 
 Versions are exact by design. An upstream release does not change an installed kit until this repository explicitly advances the dependency and publishes a new kit version. Runtime defects and package-specific feature requests belong in the linked repository; package selection and kit installation issues belong here.

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

@@ -47,6 +47,7 @@ Keep each fact in one authoritative layer:
 - `/skills/generated-control-surface`: Optional state-derived, late-bound interface over truthful domain evidence, capabilities, workflows, and choices; it remains renderer-neutral, independent from the bridge skill, and owns no parallel state.
 - `/skills/generative-apps`: Agent operating contract for compiling stable repeated Telegram interaction into deterministic standalone applications or bounded view/controller adapters whose buttons bypass model inference.
 - `/skills/show-me`: Portable visual-explanation protocol with Telegram-aware phone-width Markdown and self-contained browser artifact guidance; it owns explanation shape and evidence honesty, not bridge transport.
+- `Skill discovery`: Compiled npm/git packages expose bundled Skills only through `pi.skills`, preserving Pi package filters. A raw TypeScript extension checkout may contribute the source Skill root through `resources_discover`; compiled runtime and source runtime must never both own discovery.
 - `/.agents/skills/telegram-bot`: Bot API lookup guidance and vendored `api.md`; keep the reference intact.
 - `/.agents/skills/domain-dag`: Repository architecture guidance and validator.
 
@@ -82,7 +83,7 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 - Admission is journal-first: validate and persist the complete `getUpdates` response before one monotonic offset commit, then signal an independent worker without awaiting semantic execution. Missing cursor with a non-empty journal, malformed/foreign authority, or capacity exhaustion fails closed. “Durable” means process-crash recovery after atomic rename, not unflushed host/kernel/filesystem/device/power-loss survival.
 - Storage cutovers must reconcile actual consumer locations before correcting path adapters. Never normalize a relative historical reference into new authority or treat equal reference strings / empty canonical storage as source completeness. Exact-path preflight is lexical only; physical identity, historical coverage, writer closure and migration remain separate proofs.
 - Workspace mutations acquire cross-process admission before their shared process-local gate and hold it through asynchronous API work and durable settlement. Topic lifecycle, complete unbound/reroute target handling, manual disconnect, and session-restart cleanup use profile-wide scope; either retained retirement-fence phase rejects them before state access. Cleanup scope spans intent publication, target mutation, persistence, and transport release. Detached reconciliation that mutates Thread state must reacquire fresh profile admission through the same gate; it cannot inherit a caller lease that ended before its timer runs. A live operation ID has one process-local caller: concurrent reuse is rejected before lease acquisition, while retry after the caller exits may resume exact durable authority.
-- Workspace retirement is capacity-pressure-only. Elapsed time and heartbeat silence never trigger deletion; only complete `A`–`Z` exhaustion may propose the oldest continuously proven inactive, fully unprotected binding. Exact deletion, durable retirement, and fence completion precede slot reuse. Authorized demand-driven rotation retries one failed fresh allocation after retirement; restore-only follower startup never evicts. Release ordinary registration/provisioning leases before acquiring the destructive fence, retain the shared mutation gate across retirement, and validate the exact permit immediately before one non-retried deletion. Persist an exact method/target-matched rejection before withdrawing its intent; release that fence only after durable withdrawal, retaining the binding. A later attempt requires fresh operation authority. Protection reads must never repair, quarantine, or reset journals. Non-destructive owner detachment must atomically retain one exact Workspace binding and its letter while removing only its uniquely matched owner record and stamping first inactivity; it never manufactures Thread-deletion evidence or clears accepted work. Retained prune observations are bounded, non-routing and registration/profile/epoch/runtime-fenced. One unfinished preservation operation retains its admission identity across fresh-PID-proof retries; it can never become deletion authority. Leader quit requires completed delivery/polling/worker teardown under the captured session generation, profile and epoch; reload/new/resume/fork never establish inactivity. Unknown deletion outcomes retain their fence; only confirmed durable completion permits reuse.
+- Workspace retirement is capacity-pressure-only. Elapsed time and heartbeat silence never trigger deletion; only complete `A`–`Z` exhaustion may propose the oldest continuously proven inactive, fully unprotected binding. Exact deletion, durable retirement, and fence completion precede slot reuse. Authorized demand-driven rotation retries one failed fresh allocation after retirement; restore-only follower startup never evicts. Release ordinary registration/provisioning leases before acquiring the destructive fence, retain the shared mutation gate across retirement, and validate the exact permit immediately before one non-retried deletion. Persist an exact method/target-matched rejection before withdrawing its intent; release that fence only after durable withdrawal, retaining the binding. A later attempt requires fresh operation authority. Protection reads must never repair, quarantine, or reset journals. Non-destructive owner detachment must atomically retain one exact Workspace binding and its letter while removing only its uniquely matched owner record and stamping first inactivity; it never manufactures Thread-deletion evidence or clears accepted work. During authenticated follower registration, the exact Workspace claim owns the letter: a mismatched retained target record is repaired to that claim before binding commit, while any unrelated binding that owns the stale letter remains untouched. Retained prune observations are bounded, non-routing and registration/profile/epoch/runtime-fenced. One unfinished preservation operation retains its admission identity across fresh-PID-proof retries; it can never become deletion authority. Leader quit requires completed delivery/polling/worker teardown under the captured session generation, profile and epoch; reload/new/resume/fork never establish inactivity. Unknown deletion outcomes retain their fence; only confirmed durable completion permits reuse.
 - Foreign forwarding settles as `accepted`, `retryable`, or `terminal-rejected`. Only an authenticated acknowledgement carrying the expected `deliveryId` and `sourceUpdateId` releases leader journal authority. Negative, missing, stale, mismatched, or capacity-failed settlement remains durable; callback error answers are side effects only.
 - A forwarding delivery id is stable across registration replacement and derives from envelope kind, source `update_id`, and stable recipient binding. Runtime instance and registration generation remain separate attempt fences. Persisted message ownership carries the stable binding so replay can rebind only to its current authenticated registration.
 - A queued receipt persists its acquiring runtime instance, OS pid/process-birth identity, session generation, acquisition id, and acquisition time. Only exact authority may settle or discard it. Cached presence is not current execution proof: prepared custody must revalidate the exact queued owner/group without recovery and refuse offers or uncertain reads. Completion requires an exact removal acknowledgement, never merely `!ready`; a retained acknowledgement permits local cleanup only, not replay. Same-process session replacement may reconstruct the claim and the original process may settle after transport ownership moves; a foreign process may neither replay nor settle it through generic removal or a copied acquisition id.
@@ -96,10 +97,11 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 
 - Queue lane/kind admission is explicit. Dispatch waits for active-turn, pending-dispatch, control, compaction, `ctx.isIdle()`, and Pi pending-message guards; a dispatched prompt stays queued until `agent_start` consumes it. The terminal `+N` suffix is a yellow count of executable prompts still waiting, excludes the dispatched head immediately, and never counts current agent work from any source. Each prompt is one object with one active lane and no reserved return slot. Normal and Priority are separate FIFO lanes: crossing lanes removes it from the source and appends it at the destination tail, while Keep/Skip and same-category emoji changes preserve lane position. Complete reaction sets independently derive Priority from recognized positive emoji and Skip from recognized negative emoji; both may coexist, suppressed turns retain durable receipts while waiting, and Skip settles them only when the prompt reaches dispatch before dropping it without inference. Suppressed turns remain visible at a struck-through physical ordinal without contributing to executable queue counters, while graceful session shutdown discards all remaining queue authority before clearing memory.
 - `/stop`, `/abort`, `/next`, and `/continue` respectively reset+abort, abort while preserving queue, force the next turn, and enqueue a control-lane continuation. Abort-history folding applies only to Telegram-owned active turns. A busy `/next` marks only its exact active Telegram turn: terminal abort settlement attempts one explicit abort notice before the exact selected queued prompt receives its dispatch notice. Notice failure is diagnostic and cannot block dispatch; a later `/abort` or `/stop` cancels both pending transition notices before taking ownership. Target command adapters must forward these transition ports. A successful dispatch notice keeps the queued prompt's one reply-header claim across agent start, so later messages in that turn never repeat it.
+- A model selection from an authorized Telegram target may stop and continue any interruptible active agent run in that same Pi session, including local/TUI work. Queue the synthetic control-lane continuation before aborting; when no Telegram prompt owns the run, bind continuation and reply ownership to the exact model-menu chat/Thread/message. Delay abort until every active tool execution settles, and clear both selection and fallback target on cancellation, agent start, settlement, or session replacement.
 - Telegram extension side effects must not hold Pi's core lifecycle hostage after semantic completion. Preserve ordering in extension-owned background work, record failures, and fence target/profile/transport/session authority.
 - Complete assistant/guest model answers use Telegram-native Rich Markdown. Harness-owned menus, status, diagnostics, thinking, and tool evidence remain explicit HTML/plain or their documented native surface. Before Telegram preview or final delivery, strip every assistant-authored HTML comment regardless of Markdown position while keeping action activation top-level-only; a comment-only result sends no text message. Preserve literal code outside comments and structurally safe chunking; never split invalid markup.
 - `preview` owns streaming lifecycle only, not assistant rendering. Finalization waits for active preview flushes and must not issue pre/post-final draft-clear calls that create transient Telegram draft UI. Turns that already answer as one atomic reply (voice replies, Guest Mode queries) never stream previews.
-- Native `sendChatAction(typing)` is the automatic activity signal for unsettled agent and compaction work while Telegram transport is authorized. Extension-owned blocking UI prompts pause it and completion resumes it while either work owner remains active. Do not invent extra in-chat work indicators or emit activity for startup/connect/reload/recovery alone.
+- Native `sendChatAction(typing)` is the automatic activity signal for unsettled agent and compaction work while Telegram transport is authorized. Extension-owned blocking UI prompts pause it and completion resumes it while either work owner remains active. Compaction may stop only a typing loop it actually started; it must preserve a pre-existing agent-owned loop. Refresh only the assigned Thread on a conservative three-second cadence; do not mirror typing to aggregate `All` and multiply shared-chat flood pressure. Typing is best-effort presence only: a failed exact-target action remains a structured diagnostic and must not replace a healthy connected/leader/follower status with `error`. Do not invent extra in-chat work indicators or emit activity for startup/connect/reload/recovery alone.
 - Public activity handlers and connected companion delivery are asynchronous, target-bound, generation-fenced surfaces. Connected companion projection has no independent opt-out: disconnect or authority loss is its boundary. Token deltas, hidden reasoning, unknown sources, and stale authority never enter public projection.
 - Thread display defaults to the profile-scoped Letters strategy, with Names, Directory Snake, and Directory Title as the other automatic choices; Names projects the generated dictionary name for the slot. Unsupported retained display keys resolve to Letters without rewriting persisted configuration. A durable manual Thread display name retained on its Workspace binding overrides any automatic projection until exact reset; keep generated/recovery identity separate from manual and acknowledged display fields. After leader startup, automatic display contraction waits one follower-staleness window so election and follower re-registration cannot briefly remove and restore an acknowledged same-cwd suffix; stop/start generation cancels stale reconciliation. UI labels, emoji semantics, navigation, settings controls, callback namespaces, voice behavior, command templates, and assistant markup follow the linked `/docs` contracts. Generated human-readable prompt-button labels use `emoji + space + text`; emoji-free text is only a reasoned no-semantic-marker fallback. Non-spatial generated controls default to top-level vertical cells, with nested rows reserved for unmistakably compact peers. Do not restate other evolving UI details here.
 

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

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

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

@@ -4,6 +4,17 @@
 
 ## Unreleased
 
+## 0.51.3: Follower recovery and filterable Skills
+
+- `Follower slot reconciliation`: Re-registration now treats the exact Workspace claim as canonical when a retained follower record carries a different slot. It repairs the record before binding commit, preserves the unrelated binding that owns the stale letter, and makes repeated registration idempotent instead of returning `Telegram Workspace binding claim changed.` forever.
+- `Filterable packaged Skills`: Compiled npm/git installations now leave bundled Skill discovery to the `pi.skills` manifest, so Pi package filters can select or disable individual Skills. A raw TypeScript checkout under Pi's `extensions` directory still contributes its source Skill root through `resources_discover`, preserving local-repository development without double-owning installed resources.
+
+## 0.51.2: Model switching and typing continuity
+
+- `In-flight model switching`: Telegram model selection can again stop, switch, and continue any interruptible agent run in the current Pi session, including local/TUI work without an active Telegram prompt. The exact model-menu chat/Thread/message supplies fallback continuation ownership, active tools defer abort until settlement, and cancellation/session boundaries clear both selection and target state instead of returning a false busy response.
+- `Typing continuity`: Native presence now refreshes only the assigned Thread every three seconds instead of duplicating each action into aggregate `All`. The leader admits at most one concurrent action per chat and shares Telegram 429 cooldown across that chat's Thread keys. Compaction preserves a pre-existing agent typing loop instead of claiming and stopping it, addressing both multi-instance flicker and lifecycle gaps.
+- `Typing status truthfulness`: Failed `sendChatAction(typing)` calls remain bounded structured diagnostics but no longer replace a healthy connected/leader/follower status with `error`. Optional presence failures therefore cannot misreport transport health after the actual turn and delivery continue successfully.
+
 ## 0.51.1: Queue transitions and follower heartbeat stability
 
 - `/next lifecycle notices`: Target command composition now forwards request, exact-turn marker, and cancellation ports. Busy `/next` orders abort then selected-prompt dispatch notices; failures cannot block dispatch, and `/abort`/`/stop` cancel stale notices. A successful dispatch notice keeps first-reply ownership through agent start, so later answer messages do not repeat the queued-prompt reply. Rapid ordinary messages remain distinct turns.

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

@@ -26,6 +26,8 @@ From git:
 pi install git:github.com/llblab/pi-telegram
 ```
 
+Installed npm/git packages expose bundled Skills through their `pi.skills` manifest, so Pi package filters can select individual Skills. A raw TypeScript checkout placed directly under Pi's `extensions` directory instead contributes its adjacent source Skills at runtime; the two discovery paths are mutually exclusive.
+
 The extension requires Pi `0.84.4` or newer, matching the package's peer dependencies. Its Activity API uses the public `agent_settled` lifecycle event to keep retries/continuations under one activity identity and release that identity only after the run fully settles.
 
 Pi is the primary and only officially supported host. Narrow host-neutral adapters preserve ordered prompt blocks and normalize synchronous or asynchronous legacy/generic settings services for Pi-compatible hosts, but this is best-effort compatibility rather than an OMP support guarantee. Alternate-host shims must still reproduce required Pi lifecycle semantics—especially `agent_settled`—and their maintainers own ongoing validation.
@@ -123,7 +125,7 @@ Enable the optional capabilities the bridge needs in the [@BotFather](https://t.
 | Queue control | Inspect waiting turns, keep or skip stale work, promote important prompts, continue, abort, stop, or force the next queued item. | Long Pi tasks keep running while new mobile prompts stay visible and controllable instead of interrupting or disappearing. |
 | Operator menu | Use `/start` for status, prompt templates, model, thinking, settings, queue, extension sections, and diagnostics. | The bot is an operator panel, not a command cheat sheet. |
 | Prompt templates | Run Pi prompt templates as Telegram-safe commands such as `/fix_tests`. | Reusable local workflows become phone-accessible without exposing arbitrary terminal commands. |
-| Model and thinking | Switch model or thinking level from Telegram through safe continuation flows. | Mobile control can adjust execution strategy without tearing down the current session. |
+| Model and thinking | Switch model or thinking level from Telegram through safe continuation flows, including an active local/TUI agent run. | Mobile control can stop, switch, and resume in the same session context instead of returning a false busy dead end. |
 | Compaction | Confirm `/compact`, show native active status during compaction, and preserve Telegram-owned turn semantics. | Context maintenance is visible and safe from the phone. |
 | Draft previews | Show Telegram's native `…typing` indicator whenever the connected instance is doing agent work, or enable Rich Draft previews for streamed answer text. | Local prompts, Telegram turns, and autonomous continuations remain visibly active while draft visibility stays independent from final rendering. |
 | Activity | Keep the default `verbose` technical surface, show only `thinking`, show only `tools`, or select `quiet` for answer-only delivery. Every instance reloads this shared file-backed choice before a new agent run; thinking accumulates for two seconds and then updates at most every two seconds in a headerless expandable quote, while each tool uses one iconless closed root row containing nested evidence details. | Persistent collapsed technical activity minimizes chat height and stays bounded, redacted, target-fenced, free of URL previews, and visually separate from semantic assistant answers. |

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

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

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

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

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

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

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

@@ -722,12 +722,30 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
                 : recoverableTarget && !pendingTargetRecovery
                     ? await recoverRequestedTarget()
                     : await provisionTarget();
+            const alignResultWithWorkspaceSlot = () => {
+                if (!workspaceIdentity ||
+                    result.record.slot === workspaceIdentity.slot)
+                    return;
+                deps.recordRuntimeEvent("bus", "Telegram follower record slot reconciled to its Workspace claim", {
+                    phase: "follower-register-slot-reconcile",
+                    instanceId: registration.instanceId,
+                    chatId: result.target.chatId,
+                    threadId: result.target.threadId,
+                    previousSlot: result.record.slot,
+                    slot: workspaceIdentity.slot,
+                });
+                result = {
+                    ...result,
+                    record: { ...result.record, slot: workspaceIdentity.slot },
+                };
+            };
+            alignResultWithWorkspaceSlot();
             const crossSessionReuse = !!reconnectRecord &&
                 reconnectRecord.instanceId !== registration.instanceId;
             if (reconnectRecord && !crossSessionReuse) {
                 const nowMs = getNowMs();
                 const refreshedRecord = deps.topicTargetStore.upsert({
-                    ...reconnectRecord,
+                    ...result.record,
                     instanceId: registration.instanceId,
                     updatedAtMs: nowMs,
                     lastSyncObservedAtMs: nowMs,
@@ -804,7 +822,7 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
                     else if (crossSessionReuse && reconnectRecord) {
                         const nowMs = getNowMs();
                         const transferredRecord = deps.topicTargetStore.upsert({
-                            ...reconnectRecord,
+                            ...result.record,
                             profileKey: followerProfileKey,
                             owner: followerOwner.kind === "manual-follower"
                                 ? followerOwner
@@ -861,6 +879,7 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
                 }
             }
             if (workspaceIdentity) {
+                alignResultWithWorkspaceSlot();
                 const workspaceCommit = Threads.commitTelegramWorkspaceProvisionBinding({
                     store: deps.topicTargetStore,
                     instanceId: registration.instanceId,
@@ -872,7 +891,7 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
                         ...(result.record.threadName
                             ? { threadName: result.record.threadName }
                             : {}),
-                        ...(result.record.slot ? { slot: result.record.slot } : {}),
+                        slot: workspaceIdentity.slot,
                         journalBindingKeys: [followerProfileKey],
                         journalBindingsComplete: true,
                         updatedAtMs: getNowMs(),

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

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

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

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

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

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

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

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

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

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

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

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

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

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