@llblab/pi-kit 0.21.2 → 0.22.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.22.1 - 2026-09-24
+
+- `In-Flight Model Switching`: Advances the exact Telegram pin to `0.51.2`. Telegram model selection can stop, switch, and continue any interruptible run in the current Pi session, including local/TUI work, while preserving the authorized chat, Thread, and reply target and deferring abort until active tools settle.
+- `Typing Continuity`: Native presence refreshes only the assigned Thread, coalesces concurrent chat actions, shares Telegram cooldown across Thread keys, and preserves an existing agent typing loop through compaction. Best-effort typing failures no longer replace healthy leader/follower status with an error.
+- `Package Cohort`: Keeps every other bundled package at its current exact version. Package membership, resource paths, load order, Pi minimum, and bundled Skill ownership remain unchanged.
+
+## 0.22.0 - 2026-09-23
+
+- `Named npm Extensions`: Advances the exact Clean Room pin to `0.2.0`. `/clean-room <package-name>` now loads installed npm Pi extensions by name, including scoped packages, while preserving explicit resource isolation and project-local precedence.
+- `Model Selection`: Starting an empty clean room from a model registered by an excluded extension no longer fails. When built-in models remain in scope, the child receives only valid entries instead of warnings for stale or excluded-provider patterns; other model providers remain selectable through `/model` when loaded explicitly.
+- `Package Cohort`: Keeps every other bundled package at its current exact version. Package membership, entrypoint order, Skill ownership, and the Pi minimum remain unchanged.
+
 ## 0.21.2 - 2026-09-23
 
 - `Backup Push Reliability`: Advances the exact State Flow pin to `0.18.1`. Backup replication permits one in-flight push per repository; overlapping attempts are skipped until a later accepted turn, while session shutdown waits for the active process to close. Canonical state acceptance remains independent of Git replication.

package/README.md

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

package/node_modules/@llblab/pi-clean-room/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.2.0: Named npm extensions and isolated model selection
+
+- Launch installed npm extensions by package name, including scoped packages, without exposing their other resources to the clean room.
+- Start clean rooms from extension-backed parent models without failing on excluded providers; when a built-in model scope remains, pass only its valid entries to avoid child startup warnings from stale patterns.
+
 ## 0.1.1: Isolation and terminal recovery fixes
 
 - Keep unselected append-system context excluded when selected global prompt files are missing.

package/node_modules/@llblab/pi-clean-room/README.md

@@ -6,7 +6,7 @@ Launch a fresh, isolated Pi TUI with only the extensions you explicitly select.
 
 ## Installation
 
-Requirements: Pi `0.84.4–0.84.x` and Node.js `22.19.0` or newer.
+Requirements: Pi `0.84.4` or newer and Node.js `22.19.0` or newer.
 
 Install from npm:
 
@@ -32,6 +32,7 @@ Install or load this extension, then run:
 /clean-room skills agents system append-system
 /clean-room skills pi-extension-name pi-actors
 /clean-room skills/brain-storm
+/clean-room pi-awesome-extension
 ```
 
 Arguments may be extension names or resource switches:
@@ -42,9 +43,9 @@ Arguments may be extension names or resource switches:
 - `system` — use `~/.pi/agent/SYSTEM.md`
 - `append-system` — include `~/.pi/agent/APPEND_SYSTEM.md`
 
-Extension names are resolved from the global or project-local extensions directory. Absolute and working-directory-relative extension paths are also accepted. Project-local names take precedence over global names. Source-file names resolve consistently across `.ts`, `.js`, `.mts`, `.mjs`, `.cts`, and `.cjs`.
+Extension names are resolved from project-local extensions first, then global extensions, then locally installed npm Pi packages (project-local before global). For example, `/clean-room pi-awesome-extension` loads that package's declared extension entries without loading its other resources. Absolute and working-directory-relative extension paths are also accepted. Source-file names resolve consistently across `.ts`, `.js`, `.mts`, `.mjs`, `.cts`, and `.cjs`.
 
-The nested Pi starts in the current working directory with the current model and thinking level. All optional resources are disabled unless named explicitly. Pi's built-in system prompt and built-in tools remain available. Missing selected global prompt files contribute no content; unselected prompt files remain excluded.
+The nested Pi starts in the current working directory with the current thinking level. It retains the current model unless that model's provider was registered by a parent extension, which may not be loaded in the clean room; in that case Pi selects an available model. Model-cycling scope is inherited from the parent's resolved available models, excluding providers registered by parent-only extensions. When the filtered scope is nonempty, invalid or excluded-provider patterns are not forwarded to the child. `/model` shows all models available in the child; use it to choose a provider loaded by a named extension even when that provider is not in the inherited scope. Built-in model providers remain available without extensions. All optional resources are disabled unless named explicitly. Pi's built-in system prompt and built-in tools remain available. Missing selected global prompt files contribute no content; unselected prompt files remain excluded.
 
 Exit the nested TUI normally with `Ctrl+D` to return to the parent session. Launch failures and signal termination are reported after restoring the parent TUI.
 

package/node_modules/@llblab/pi-clean-room/index.ts

@@ -12,6 +12,40 @@ import {
 const EMPTY_COMPONENT = { render: () => [], invalidate: () => {} };
 const EXTENSION_SUFFIXES = [".ts", ".js", ".mts", ".mjs", ".cts", ".cjs"];
 
+function npmPackageRoots(cwd: string, agentDir: string): string[] {
+	return [join(cwd, CONFIG_DIR_NAME, "npm", "node_modules"), join(agentDir, "npm", "node_modules")];
+}
+
+function installedExtensionPackage(name: string, root: string): string | undefined {
+	if (!/^(?:@[a-z0-9._-]+\/)?[a-z0-9._-]+$/.test(name) || name === "." || name === "..") return undefined;
+	const path = join(root, name);
+	try {
+		const manifest = JSON.parse(readFileSync(join(path, "package.json"), "utf8"));
+		if (manifest.name !== name) return undefined;
+		if (Array.isArray(manifest.pi?.extensions) && manifest.pi.extensions.length > 0) return path;
+		if (!manifest.pi && existsSync(join(path, "extensions"))) return path;
+	} catch {
+		// Missing or invalid npm package manifest.
+	}
+	return undefined;
+}
+
+function discoverInstalledExtensionNames(cwd: string, agentDir: string): string[] {
+	const names = new Set<string>();
+	for (const root of npmPackageRoots(cwd, agentDir)) {
+		if (!existsSync(root)) continue;
+		for (const entry of readdirSync(root, { withFileTypes: true })) {
+			if (entry.name.startsWith("@") && entry.isDirectory()) {
+				for (const child of readdirSync(join(root, entry.name), { withFileTypes: true })) {
+					const name = `${entry.name}/${child.name}`;
+					if (child.isDirectory() && installedExtensionPackage(name, root)) names.add(name);
+				}
+			} else if (entry.isDirectory() && installedExtensionPackage(entry.name, root)) names.add(entry.name);
+		}
+	}
+	return [...names];
+}
+
 export function discoverExtensionNames(cwd: string, agentDir = getAgentDir()): string[] {
 	const roots = [join(agentDir, "extensions"), join(cwd, CONFIG_DIR_NAME, "extensions")];
 	const names = new Set<string>();
@@ -23,6 +57,7 @@ export function discoverExtensionNames(cwd: string, agentDir = getAgentDir()): s
 			if (entry.isFile() && suffix) names.add(entry.name.slice(0, -suffix.length));
 		}
 	}
+	for (const name of discoverInstalledExtensionNames(cwd, agentDir)) names.add(name);
 	return [...names].sort();
 }
 
@@ -36,6 +71,10 @@ export function resolveExtension(source: string, cwd: string, agentDir = getAgen
 			if (existsSync(candidate)) return candidate;
 		}
 	}
+	for (const root of npmPackageRoots(cwd, agentDir)) {
+		const path = installedExtensionPackage(source, root);
+		if (path) return path;
+	}
 	return undefined;
 }
 
@@ -96,7 +135,12 @@ function launchCleanRoom(
 	resources: ReadonlySet<ResourceArgument>,
 	skills: string[],
 ) {
-	const args = buildCleanRoomArgs(extensionPaths, ctx.model, ctx.thinkingLevel, resources, getAgentDir(), skills);
+	// Providers registered by parent extensions may not exist in the isolated child.
+	const extensionProviders = new Set(ctx.modelRegistry.getRegisteredProviderIds());
+	const model = ctx.model && !extensionProviders.has(ctx.model.provider) ? ctx.model : undefined;
+	const scopedModels = ctx.scopedModels?.filter(({ model }) => !extensionProviders.has(model.provider));
+	const args = buildCleanRoomArgs(extensionPaths, model, ctx.thinkingLevel, resources, getAgentDir(), skills);
+	if (scopedModels?.length) args.push("--models", scopedModels.map(({ model }) => `${model.provider}/${model.id}`).join(","));
 	const cliEntry = process.argv[1];
 	const command = cliEntry && existsSync(cliEntry) ? process.execPath : "pi";
 	const commandArgs = cliEntry && existsSync(cliEntry) ? [cliEntry, ...args] : args;

package/node_modules/@llblab/pi-clean-room/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-clean-room",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "private": false,
   "description": "Launch an isolated Pi TUI with only explicitly selected extensions",
   "keywords": [

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

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

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

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

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

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

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

@@ -123,7 +123,7 @@ Enable the optional capabilities the bridge needs in the [@BotFather](https://t.
 | Queue control | Inspect waiting turns, keep or skip stale work, promote important prompts, continue, abort, stop, or force the next queued item. | Long Pi tasks keep running while new mobile prompts stay visible and controllable instead of interrupting or disappearing. |
 | Operator menu | Use `/start` for status, prompt templates, model, thinking, settings, queue, extension sections, and diagnostics. | The bot is an operator panel, not a command cheat sheet. |
 | Prompt templates | Run Pi prompt templates as Telegram-safe commands such as `/fix_tests`. | Reusable local workflows become phone-accessible without exposing arbitrary terminal commands. |
-| Model and thinking | Switch model or thinking level from Telegram through safe continuation flows. | Mobile control can adjust execution strategy without tearing down the current session. |
+| Model and thinking | Switch model or thinking level from Telegram through safe continuation flows, including an active local/TUI agent run. | Mobile control can stop, switch, and resume in the same session context instead of returning a false busy dead end. |
 | Compaction | Confirm `/compact`, show native active status during compaction, and preserve Telegram-owned turn semantics. | Context maintenance is visible and safe from the phone. |
 | Draft previews | Show Telegram's native `…typing` indicator whenever the connected instance is doing agent work, or enable Rich Draft previews for streamed answer text. | Local prompts, Telegram turns, and autonomous continuations remain visibly active while draft visibility stays independent from final rendering. |
 | Activity | Keep the default `verbose` technical surface, show only `thinking`, show only `tools`, or select `quiet` for answer-only delivery. Every instance reloads this shared file-backed choice before a new agent run; thinking accumulates for two seconds and then updates at most every two seconds in a headerless expandable quote, while each tool uses one iconless closed root row containing nested evidence details. | Persistent collapsed technical activity minimizes chat height and stays bounded, redacted, target-fenced, free of URL previews, and visually separate from semantic assistant answers. |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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