@llblab/pi-kit 0.22.0 → 0.22.2

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

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

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

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

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

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

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

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

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

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

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

@@ -1,8 +1,8 @@
 /**
  * Bundled Telegram skill discovery
  * Zones: pi agent, telegram guidance
- * Owns source-checkout and installed-package skill path contribution
+ * Owns source-checkout skill contribution; installed packages use their manifest
  */
 import type { ExtensionAPI } from "./pi.ts";
 export declare const TELEGRAM_SKILLS_PATH: string;
-export declare function registerTelegramSkillDiscovery(pi: Pick<ExtensionAPI, "on">): void;
+export declare function registerTelegramSkillDiscovery(pi: Pick<ExtensionAPI, "on">, modulePath?: string): boolean;

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

@@ -1,12 +1,19 @@
 /**
  * Bundled Telegram skill discovery
  * Zones: pi agent, telegram guidance
- * Owns source-checkout and installed-package skill path contribution
+ * Owns source-checkout skill contribution; installed packages use their manifest
  */
+import { extname } from "node:path";
 import { fileURLToPath } from "node:url";
+const TELEGRAM_SKILLS_MODULE_PATH = fileURLToPath(import.meta.url);
 export const TELEGRAM_SKILLS_PATH = fileURLToPath(new URL("../skills", import.meta.url));
-export function registerTelegramSkillDiscovery(pi) {
+export function registerTelegramSkillDiscovery(pi, modulePath = TELEGRAM_SKILLS_MODULE_PATH) {
+    // A raw source extension has no package manifest owner. Compiled npm/git
+    // packages do, so contributing again would bypass their resource filters.
+    if (extname(modulePath) !== ".ts")
+        return false;
     pi.on("resources_discover", () => ({
         skillPaths: [TELEGRAM_SKILLS_PATH],
     }));
+    return true;
 }

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

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

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

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

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

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

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

@@ -151,7 +151,7 @@ A registered instance exposes:
 
 ## Approved Next Contract: Directory Names And Reclaimable Slots
 
-Status: approved design with a locally tested pure selection policy in `lib/workspace-slots.ts` and profile-isolated display preference persistence/default resolution in `lib/config.ts`. Workspace claims now reserve global letters before provisioning and preserve legacy binding keys. An exact claim assigns the first free letter to a missing-slot binding or the selected member of a duplicate-slot set, but persistence waits for successful target recovery; unresolved duplicates block unrelated fresh allocation. Sticky suffix metadata and acknowledged `displayTitle` persist in Workspace bindings. `lib/thread-display.ts` provides the three-mode projection plus serialized title reconciliation wired into leader startup and follower registration. Heartbeat ACKs carry acknowledged display titles to followers and the current-thread/TUI projection uses them without changing restoration identity. Settings now exposes Letters (default), Names, and Directories; follower changes use the capability-gated leader-owned setting path. Live bot chooser/notice labels and cross-instance agent-target resolution use acknowledged titles without granting routing authority. The Thread store now persists the first proven `inactiveSinceMs` transition with exact confirmed target absence or fenced non-destructive detachment of a confirmed-dead follower or quiescent quitting leader whose tab is preserved; successful active provisioning clears it. Pressure selection, intents, mocked execution, and recovery are implemented. A 2/2 same-model independent post-fix quorum cleared the admission-composition blocker at 0.96 confidence per reviewer, and the operator has since authorized demand-driven rotation. Fresh allocation now invokes the existing retirement lifecycle under full capacity; `BACKLOG.md` owns remaining disposable-client acceptance.
+Status: approved design with a locally tested pure selection policy in `lib/workspace-slots.ts` and profile-isolated display preference persistence/default resolution in `lib/config.ts`. Workspace claims now reserve global letters before provisioning and preserve legacy binding keys. An exact claim assigns the first free letter to a missing-slot binding or the selected member of a duplicate-slot set, but persistence waits for successful target recovery; unresolved duplicates block unrelated fresh allocation. If authenticated follower re-registration finds that its retained target record carries another letter, the exact claim is canonical: registration repairs that record before binding commit and leaves the unrelated binding that owns the stale letter intact. Sticky suffix metadata and acknowledged `displayTitle` persist in Workspace bindings. `lib/thread-display.ts` provides the three-mode projection plus serialized title reconciliation wired into leader startup and follower registration. Heartbeat ACKs carry acknowledged display titles to followers and the current-thread/TUI projection uses them without changing restoration identity. Settings now exposes Letters (default), Names, and Directories; follower changes use the capability-gated leader-owned setting path. Live bot chooser/notice labels and cross-instance agent-target resolution use acknowledged titles without granting routing authority. The Thread store now persists the first proven `inactiveSinceMs` transition with exact confirmed target absence or fenced non-destructive detachment of a confirmed-dead follower or quiescent quitting leader whose tab is preserved; successful active provisioning clears it. Pressure selection, intents, mocked execution, and recovery are implemented. A 2/2 same-model independent post-fix quorum cleared the admission-composition blocker at 0.96 confidence per reviewer, and the operator has since authorized demand-driven rotation. Fresh allocation now invokes the existing retirement lifecycle under full capacity; `BACKLOG.md` owns remaining disposable-client acceptance.
 
 The pure policy distinguishes a free letter, a proposed pressure-reclamation victim, and protected/invalid capacity. Its caller must supply a validated profile-wide snapshot, reservations, proven inactivity start, and explicit protection classification; duplicate legacy letters block selection. The policy performs no filesystem or Telegram operations and does not establish liveness or deletion authority. It proposes a victim only when every profile-wide letter is occupied or reserved; elapsed time alone never triggers retirement.
 
@@ -336,7 +336,7 @@ In Telegram private-chat Threaded Mode:
 - Prompts typed in a thread route to the owning instance.
 - Replies, previews, files, voice, and buttons stay in that thread.
 - Queue controls and reactions affect only that instance target.
-- Telegram's native `…typing` indicator for real agent work is sent to that instance thread and mirrored to `All`; `All` is the aggregate surface and should show activity when any bound instance is running a Telegram turn, local prompt, or autonomous continuation. Terminal `Active` remains Telegram-turn-specific. Startup/connect/reload/recovery must not send activity by themselves.
+- Telegram's native `…typing` indicator for real agent work is refreshed only in that instance's exact Thread. Aggregate `All` mirroring is intentionally omitted because it duplicates every keepalive against the shared chat and amplifies Telegram flood control. Telegram turns, local prompts, and autonomous continuations all use the exact instance target. Terminal `Active` remains Telegram-turn-specific. Startup/connect/reload/recovery must not send activity by themselves.
 - Generic heartbeat pruning remains silent and preserves the thread as a restart hint. With cleanup enabled, a later exact-PID death confirmation may delete it without posting an `Instance offline` notice. With cleanup disabled, a fenced owner-detachment commit records inactivity but retains the Thread and its Workspace slot for restoration or fully guarded capacity rotation. Confirmed deletion removes live routing authority but retains the Workspace binding's friendly name and uppercase ordering slot; a later authenticated reopen probes the old target, replaces it only on exact stale/deleted evidence, and carries that name and slot onto the new Thread.
 - If the same binding identity returns, authenticated registration can reclaim the thread after the required visibility proof.
 
@@ -406,7 +406,7 @@ Threaded Mode should make follower threads behave like normal Telegram instance
 | Replies/finals                   | Final replies land in the same thread                                                                                                                                                                                                                 | Follower finals go through leader transport into follower thread                                                                                                                                                                                                | Outbound calls carry target and inject `message_thread_id`                                                                                                                                                                                          | Reply delivery and bus API tests                                                                                          |
 | Previews/Rich Drafts             | Draft previews use the active thread target                                                                                                                                                                                                           | Follower previews use the same native draft lifecycle through the leader                                                                                                                                                                                        | Preview transport preserves target and draft id                                                                                                                                                                                                     | Preview thread-target tests                                                                                               |
 | Attachments/voice                | Files and voice upload in the instance thread                                                                                                                                                                                                         | Follower uploads route through leader multipart transport                                                                                                                                                                                                       | Multipart calls are target-scoped and follower-authorized                                                                                                                                                                                           | Bus allowlist and outbound delivery tests                                                                                 |
-| Native activity status           | `sendChatAction(typing)` renders Telegram's native `…typing` indicator in the assigned thread and mirrors aggregate `All` for every agent run, including local and autonomous work; terminal identity remains `connected`, with active work included in the green Queue count | Followers route one thread action and one aggregate action through leader transport for any agent run while retaining their stable terminal `follower` identity and green activity count                                                                                       | Agent lifecycle targets the active Telegram turn when present and otherwise the instance binding; one keyed loop avoids duplicate aggregate sends/rate-limit pressure                                                                               | Agent-start binding, typing-loop, target-routing, and terminal-status regressions                                         |
+| Native activity status           | `sendChatAction(typing)` refreshes Telegram's native `…typing` indicator only in the assigned Thread for every agent run, including local and autonomous work; aggregate `All` is not mirrored, terminal identity remains `connected`, and active work stays included in the green Queue count | Followers route the exact Thread action through leader transport while retaining their stable terminal `follower` identity and green activity count; the leader admits one concurrent action per chat and shares Telegram 429 cooldown across that chat's Thread keys                                                                                       | Agent lifecycle targets the active Telegram turn when present and otherwise the instance binding; one keyed loop avoids duplicate aggregate sends/rate-limit pressure                                                                               | Agent-start binding, typing-loop, target-routing, and terminal-status regressions                                         |
 | Leader election / promotion      | Current leader keeps its thread across reload                                                                                                                                                                                                         | A promoted follower keeps its existing thread, slot, and name when elected and after later reload                                                                                                                                                               | Promotion converts the current follower binding into the leader profile before forced lock acquisition, so leader startup reuses it instead of provisioning a new thread                                                                            | Follower heartbeat recovery passes binding snapshot into promotion; own-topic provisioner reuses promoted bindings        |
 | `/start` command/menu bootstrap  | Registers visible bot commands and opens the menu                                                                                                                                                                                                     | Follower `/start` can refresh the bot command menu through the leader and open its local menu without warnings                                                                                                                                                  | Bot command registration is a validated global Bot API call allowed through trusted follower bus transport                                                                                                                                          | Bus allowlist regression for `setMyCommands`                                                                              |
 | Follower reconnect               | Existing leader binding is reused only when still usable                                                                                                                                                                                              | Same-process `/new` or `/reload` suspends the old follower socket/context and automatically re-registers the new session to the exact prior target; explicit reconnect to a genuinely closed/stale Telegram tab still recreates a visible thread before success | A short-lived handoff carries the assigned target across session replacement, and the leader transfers that binding to the new runtime instance id by stable manual-follower identity; stale Bot API errors remain the proof for fresh provisioning | Session handoff/refresh, leader binding-transfer, persisted leader-reload reuse, and stale-target replacement regressions |

package/node_modules/@llblab/pi-telegram/docs/public-api.md

@@ -71,7 +71,7 @@ Every assistant-authored HTML comment is transport-private on Telegram: previews
 - `telegram_channel_post(action, operation_id, markdown?)` edits or deletes one exact `published` record returned by `telegram_channel_posts`. Edit requires Markdown and delete forbids it. A media-post edit replaces the caption through `editMessageCaption`, while a text post uses `editMessageText`; both render Markdown formatting, including spoilers, as Telegram HTML. The direct leader fences the tool call as outcome-unknown before the mutation call, so ambiguous failures are never replayed automatically.
 - `telegram_channel_posts(chat_id?, limit?)` lists newest bounded records from the active profile's agent-owned post journal. It returns publication, edit/delete outcome-unknown, confirmed, and deleted local records only, including retained media kind/file name/size/SHA-256 identity; it never reads or claims completeness for Telegram channel history. This explicit successful listing is the only tool response that exposes retained authored Markdown; channel tool failures use fixed redacted messages, while pre-issuance media/caption validation errors stay actionable.
 - `telegram_message(text, chat_id?, media?, channel?, thread_id?, thread?)` sends a direct Telegram Markdown message when this Pi instance owns `/telegram-connect` or is registered with the multi-instance bus. A public `@username`, or an exact negative numeric channel ID with `channel: true`, is passed as `chat_id` without a local registry; channel delivery requires the direct leader, and Telegram enforces whether the bot has channel posting permission. Channel delivery accepts `media` as one local `.jpg`/`.jpeg`/`.png`/`.webp` photo or `.mp4` video (photo ≤ 10 MiB, video ≤ 50 MiB), uploaded through multipart `sendPhoto`/`sendVideo` with `text` as its HTML caption (≤ 1024 visible characters); unsupported media types and albums are rejected before issuance, and the durable channel-post journal binds media identity and caption so duplicate or lost-acknowledgement retries never re-upload. `thread` accepts a live numeric Thread id or its current acknowledged display title; name matching is case-insensitive and fails closed when absent or ambiguous, while delivery captures the numeric target. During an active Telegram turn, omitted targeting and an explicit target equal to that turn are rejected so the ordinary final-reply path remains the sole current-target response; an explicit different chat/thread target remains allowed. Outside active turns, paired/default local/TUI delivery remains unchanged. Top-level `telegram_button` comments inside `text` are parsed with the same planner used for normal replies and attached to that message; buttons are never standalone Telegram messages.
-- The bundled `telegram-bridge` Skill owns action syntax, target routing, Threaded Mode, formatting, Generative App operation, and profile-specific debugging guidance. The bundled `show-me` Skill owns portable evidence-honest explanations and adapts them to phone-width Markdown or self-contained HTML artifacts when Telegram is the active surface. The regular prompt routes applicable turns to these and the other bundled Skills. `telegram_attach`, `telegram_bind`, and `telegram_message` remain registered but are model-active only while this instance owns direct transport or holds a live follower registration; disconnect/loss suppresses their schemas and prompt metadata, and recovery restores only the operator's previously active pi-telegram subset.
+- The bundled `telegram-bridge` Skill owns action syntax, target routing, Threaded Mode, formatting, Generative App operation, and profile-specific debugging guidance. The bundled `show-me` Skill owns portable evidence-honest explanations and adapts them to phone-width Markdown or self-contained HTML artifacts when Telegram is the active surface. The regular prompt routes applicable turns to these and the other bundled Skills. Compiled npm/git installations expose them through the package `pi.skills` manifest so Pi resource filters remain authoritative; a raw TypeScript checkout under Pi's `extensions` directory contributes its source Skill root at runtime instead. `telegram_attach`, `telegram_bind`, and `telegram_message` remain registered but are model-active only while this instance owns direct transport or holds a live follower registration; disconnect/loss suppresses their schemas and prompt metadata, and recovery restores only the operator's previously active pi-telegram subset.
 - `telegram_voice` hidden comments request Telegram-native voice delivery through `{text}`, `{text|lang}`, `{text|lang|rate}`, or a JSON object. JSON is the fallback for multiline content, named fields, or escaping; equivalent `text` or `value` supplies the spoken payload, with explicit `text` taking precedence.
 - `telegram_button` hidden comments create footer buttons; standalone column-zero triple-backtick `telegram_button` blocks create button rows between paragraphs in Native Rich Markdown. Both accept the same singleton or mixed JSON/CML matrix and share prompt/app routing; fenced blocks also accept adjacent top-level JSON/CML objects without an outer array or commas as vertical singleton rows. Native rows allow at most eight buttons and must fit one Rich Message chunk; invalid or incomplete blocks register nothing. Drafts hide action fences. HTML compatibility projects fenced controls into the footer. In-body clicks acknowledge without recoloring the Rich body; selected-style highlighting remains footer-only. One marker accepts a JSON object, adaptive JSON/CML matrix, or positional [Compact Matrix Literal](./compact-matrix-literal.md). Named JSON objects and positional cells may coexist in one matrix or row; separators are optional and one trailing comma is tolerated at matrix, row, and JSON-object boundaries. Top-level cells become full-width rows, while nested rows group one or more buttons horizontally without an artificial parser-width cap. CML uses `{value}`, `{label|prompt}`, prompt-only `{|prompt}`, or the corresponding three-atom form with `selected_style`; an omitted label uses the existing prompt-as-label fallback, and the optional third atom requires a non-empty prompt and accepts only `primary`, `success`, or `danger`. A fourth atom accepts `1` or `true` (disabled), and `0` or `false` (enabled), with exact lowercase spelling; an omitted fourth position stays enabled, and the third atom may be empty in this form (`{|Next||1}`). JSON uses boolean `disabled`. Disabled cells need no prompt or selected style: `{Next|||1}` is label-only and `{|||1}` is blank (JSON `{"label":"Next","disabled":true}` and `{"disabled":true}`). The Telegram renderer supplies a non-breaking space only when the label is empty. Disabled cells stay visible but carry `disabled: {}` instead of callback data and register no prompt or bound action; invalid disabled values reject the candidate matrix. It trims atom boundaries and supports only the minimal escapes `\|`, `\}`, and `\\`. Prefer one matrix comment for multiple buttons. Use JSON `label` plus `prompt`, or `value` when both strings are identical. Action markers are colon-free; colon-prefixed payloads are rejected. Use top-level column-zero action wrappers, outside quotes, lists, or enclosing code examples. Ordinary code fences and larger outer fences preserve literal examples; bare JSON/CML in prose never activates.
 

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

@@ -1203,10 +1203,13 @@ export function registerTelegramLifecycleRuntimeHooks({
     if (uiPromptActive || !canSendAgentActivity(ctx)) return false;
     const turn = activeTurnRuntime.get();
     const target = turn?.target ?? proactivePushTargetGetter();
-    promptDispatchRuntime.startTypingLoop(ctx, turn?.chatId ?? target?.chatId, {
-      target,
-    });
-    return true;
+    return (
+      promptDispatchRuntime.startTypingLoop(
+        ctx,
+        turn?.chatId ?? target?.chatId,
+        { target },
+      ) !== false
+    );
   };
   const startActiveTurnTypingLoop = (ctx: Pi.ExtensionContext): void => {
     if (uiPromptActive) return;

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

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

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

@@ -1210,13 +1210,36 @@ export function createTelegramBusFollowerTargetProvisioner(
         : recoverableTarget && !pendingTargetRecovery
           ? await recoverRequestedTarget()
           : await provisionTarget();
+      const alignResultWithWorkspaceSlot = (): void => {
+        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,
@@ -1300,7 +1323,7 @@ export function createTelegramBusFollowerTargetProvisioner(
           } else if (crossSessionReuse && reconnectRecord) {
             const nowMs = getNowMs();
             const transferredRecord = deps.topicTargetStore.upsert({
-              ...reconnectRecord,
+              ...result.record,
               profileKey: followerProfileKey,
               owner:
                 followerOwner.kind === "manual-follower"
@@ -1361,6 +1384,7 @@ export function createTelegramBusFollowerTargetProvisioner(
         }
       }
       if (workspaceIdentity) {
+        alignResultWithWorkspaceSlot();
         const workspaceCommit =
           Threads.commitTelegramWorkspaceProvisionBinding({
             store: deps.topicTargetStore,
@@ -1373,7 +1397,7 @@ export function createTelegramBusFollowerTargetProvisioner(
               ...(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/lib/extension.ts

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