@llblab/pi-kit 0.36.2 → 0.37.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.37.0: Bundled Package Updates (2026-10-25)
+
+- `Exact pins`: `@llblab/pi-telegram` 0.57.11 → 0.58.1.
+- `Packaging`: Synchronizes the lockfile, bundle aliases and README inventory. Package membership and resource order remain unchanged; packed validation does not certify extension safety or installed-client behavior.
+
+## 0.36.3: Bundled Package Updates (2026-10-24)
+
+- `Exact pins`: `@llblab/pi-telegram` 0.57.7 → 0.57.11.
+- `Packaging`: Synchronizes the lockfile, bundle aliases and README inventory. Package membership and resource order remain unchanged; packed validation does not certify extension safety or installed-client behavior.
+
 ## 0.36.2: Bundled Package Updates (2026-10-23)
 
 - `Exact pins`: `@llblab/pi-claude-usage` 0.2.2 → 0.2.3; `@llblab/pi-codex-usage` 0.13.1 → 0.13.2; `@llblab/pi-telegram` 0.57.3 → 0.57.7.

package/README.md

@@ -18,7 +18,7 @@ Package links lead to the owning repositories for usage, documentation, issues,
 | [`@llblab/pi-codex-usage`](https://github.com/llblab/pi-codex-usage) | `0.13.2` | OpenAI/legacy Codex subscription quota and Business credit status, with persistent priority Fast toggle mirrored in Telegram |
 | [`@llblab/pi-grow-loop`](https://github.com/llblab/pi-grow-loop) | `0.9.0` | Visible continuation scheduling and bounded worker Skills through compiled, manifest-owned resources |
 | [`@llblab/pi-state-flow`](https://github.com/llblab/pi-state-flow) | `0.26.5` | Scoped context/memory compiler with step-independent current memory, stable Passive/Active modes and visible blocked-state status |
-| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.57.7` | Telegram companion with per-prompt Steer, queued controls, Reroute/Restore, recoverable connections, previews, follower Threads, files, and voice |
+| [`@llblab/pi-telegram`](https://github.com/llblab/pi-telegram) | `0.58.1` | Telegram companion with per-prompt Steer, queued controls, Reroute/Restore, recoverable connections, previews, follower Threads, files, and voice |
 | [`@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.
@@ -27,7 +27,7 @@ Versions are exact by design. An upstream release does not change an installed k
 
 Requires **Pi 1.0.0+** and **Node.js 22.19.0+**. State Flow requires its canonical checkpoint/tail storage format and does not convert unsupported stores in place. Preserve existing stores and consult the [owning package's storage guidance](https://github.com/llblab/pi-state-flow/blob/v0.26.5/docs/usage.md#moving-a-store-and-supported-formats) before changing installations.
 
-From npm:
+From NPM:
 
 ```bash
 pi install npm:@llblab/pi-kit

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

@@ -109,7 +109,7 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 - In Threaded Mode, All is service/input-only. New output, previews, typing and routing UI require a concrete Thread; neither implicit fallback nor explicit aggregate delivery may write to All. Unavailable routing authority retains input without an All notice or silent settlement. Classic DM and explicit channel/business destinations remain separate; historical All output is not auto-cleaned.
 - 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 the captured generation's preceding preview work, never later drafts blocked by that publication, and must not issue pre/post-final draft-clear calls that create transient Telegram draft UI. Reset/invalidation detaches predecessor dependencies; late settlements cannot mutate replacement state. 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. 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, never a Thread-existence or message-delivery probe: 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.
+- 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. One Thread's pending action must not suppress another Thread's activity. Typing is best-effort presence only, never a Thread-existence or message-delivery probe: 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.
 - Profiles hold only bot identity and the paired owner; Settings-menu preferences live in shared top-level config. Thread display (`threads.displayMode`) defaults to the 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 action labels use `emoji + space + text`; emoji-free action text is only a reasoned no-semantic-marker fallback. State/value controls follow the [button control hierarchy](./docs/ui-style.md#button-control-hierarchy), not the action-label grammar. 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.
 
@@ -134,7 +134,7 @@ The detailed map is canonical in [`docs/architecture.md`](./docs/architecture.md
 - Command templates remain compact and shell-free. Use string leaves or ordered `template` arrays; shell operators are not an execution contract. Examples use portable executable placeholders, never machine-local paths.
 - `telegram_attach` is the canonical file path and `telegram_message` the direct Markdown text/buttons path. Both require current direct or registered-follower authority and must not replace the normal active-turn reply.
 - Inbound handlers transform text/media before queueing; outbound handlers precede programmatic/provider fallbacks. Public contracts and ordering live in `docs/inbound.md`, `docs/outbound.md`, and `docs/public-api.md`.
-- Pi integration uses public hooks and APIs. Telegram `/new` is scheduled against the exact durable update, dispatched only after that update is removed from the journal, and then routed through the single `/telegram-internal` Pi gateway via `pi.sendUserMessage(..., { expandPromptTemplates: true })`; only a runtime-armed typed action may execute, manual invocation reports that the command cannot be run manually, and the handler receives the real `ExtensionCommandContext` before calling `ctx.newSession()`. Before replacement, CAS-publish one exact expiring handoff in the profile target snapshot. `workspace-thread` successors re-key the matching Workspace binding; `classic-chat` successors preserve Profile/CWD/session/chat continuity without creating a binding or invoking topic APIs. Both atomically claim the intent before one terminal result, and the old `withSession` path never publishes the same success. A registered follower cannot persist leader-owned state: its Workspace Thread intent is published and claimed by the leader over capability-gated exact-generation bus RPC after leader-side binding validation, and records its source runtime instance so only that follower lineage may re-key or claim it. Never replace the session while inbound authority is unsettled, store stale command contexts, accept an expired or mismatched handoff, inject terminal input, spawn a shadow Pi process, or mutate session files.
+- Pi integration uses public hooks and APIs. Telegram `/new` is scheduled against the exact durable update, dispatched only after that update is removed from the journal, and then routed through the `/telegram-connect --internal new <token>` Pi gateway via `pi.sendUserMessage(..., { expandPromptTemplates: true })`; the internal branch never enters profile activation or connection/recovery, only a runtime-armed one-use typed action may execute, manual invocation reports that the action cannot be run manually, and the handler receives the real `ExtensionCommandContext` before calling `ctx.newSession()`. Before replacement, CAS-publish one exact expiring handoff in the profile target snapshot. `workspace-thread` successors re-key the matching Workspace binding; `classic-chat` successors preserve Profile/CWD/session/chat continuity without creating a binding or invoking topic APIs. Both atomically claim the intent before one terminal result, and the old `withSession` path never publishes the same success. A registered follower cannot persist leader-owned state: its Workspace Thread intent is published and claimed by the leader over capability-gated exact-generation bus RPC after leader-side binding validation, and records its source runtime instance so only that follower lineage may re-key or claim it. Never replace the session while inbound authority is unsettled, store stale command contexts, accept an expired or mismatched handoff, inject terminal input, spawn a shadow Pi process, or mutate session files.
 
 ## 7. Engineering Conventions
 
@@ -145,7 +145,7 @@ The detailed map is canonical in [`docs/architecture.md`](./docs/architecture.md
 - Treat every meaningful `lib/extension.ts` edit as a composition-pressure check, but keep one-off live adapter wiring there when extraction would only hide cross-domain state.
 - Follow [`docs/ui-style.md`](./docs/ui-style.md) for interface copy, emoji, buttons, menus, and dialogs. Update the registry before assigning a new UI emoji meaning. Standalone notices use one fully bold emoji-led sentence with a terminal period; menu or chooser headings use the same hierarchy with a terminal colon. Material names may add nested italic emphasis without breaking the outer bold span. Callback toasts are fleeting plain text with no emoji and no terminal sentence period (question/exclamation marks and ellipses remain), written in that final form at their call site; no delivery boundary rewrites punctuation, and navigation taps answer silently. In-chat notices and explicit raw API payloads keep their punctuation.
 - Markdown lists never contain blank lines between adjacent items; list items are not paragraphs. Use blank lines only between paragraphs or independently separated blocks. Markdown tables use compact source formatting with `---` separator cells and one surrounding space per cell. Preserve vendored references unchanged.
-- Treat Windows filesystem, named-pipe, lock, heartbeat, and atomic-rename reports as high-signal evidence; reduce them to regressions or explicit platform caveats.
+- Treat Windows filesystem, named-pipe, lock, heartbeat, and atomic-rename reports as high-signal evidence; reduce them to regressions or explicit platform caveats. Process fixtures must distinguish bounded startup from post-readiness natural exit: arm the exit guard only after the declared checkpoint, retain a separate total cap, and ensure extra startup allowance cannot hide retained post-readiness handles.
 - Route significant runtime failures through the redacted recent-event recorder. Keep the compact TUI status at generic `error`; details belong in diagnostics.
 
 ## 8. Work Protocol

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

@@ -2,6 +2,11 @@
 
 _This file owns unresolved project work only. Completed behavior belongs in `CHANGELOG.md`; durable contracts belong in `AGENTS.md` and `/docs`._
 
+## 0.58.1 publication checkpoint
+
+- [ ] Publish the independent Thread chat-action fix through the protected dev-to-main path, requiring fresh Ubuntu, Windows and both macOS shard checks at the exact candidate head and candidate/merged-tree equality. Keep the immutable Connect-only minor unchanged and verify its publication before issuing the hotfix tag.
+- [ ] Verify the hotfix GitHub Release and public npm latest, exact tag/gitHead identity, canonical notes, packed runtime/skills and provenance before closing this checkpoint. No live session reload or Telegram probes; controlled transport tests do not prove live client presence.
+
 ## Disposable Thread live acceptance
 
 - [ ] After separate operator authorization, use disposable Telegram tabs to check leader Settings review/Back, one confirmed cleanup of an inactive slotless binding, preservation of its replacement letter holder, and visible outcome/recovery copy. Native filesystem and injected-transport tests do not prove live Telegram/client or native Windows acceptance. Never use production history as the disposable fixture.
@@ -17,7 +22,28 @@ The prompt-cache report remains open for the reporter's offered live Anthropic c
 
 Evidence (2026-10-23 07:11–07:16): a `/start` sent in a former leader tab moved into a follower's journal as a raw original. After that follower's Thread was re-created by the restore probe, every execution attempt failed with `Telegram bus API call is not allowed for this follower` and retried every 60 s indefinitely, because the reply targeted a Thread the follower no longer owned. Terminal settlement alone is unsafe: the same rejection can be a benign race during a live-rebind pre-dispatch.
 
-- [ ] Live acceptance: a forwarded command whose follower Thread was re-created is answered in the current Thread (disposable tabs only).
+### Post-refusal reply-only recovery — deferred contract gate
+
+Remaining scope is recovery after a reply is refused or recipient authority changes during publication, not initial destination selection. The latter is specified under the [reply ownership boundary](./docs/multi-instance-bus.md#reply-recovery-ownership-boundary); its native regression covers a stale source address, not the historical refusal itself or live Telegram restoration.
+
+A target-scoped reply refusal cannot prove that a command made no prior effects. Keep the handler-replay containment while preparing a replacement: unresolved inputs must remain in ordinary durable retry state, not be silently completed or retargeted as whole commands. Ordinary journal execution remains at-least-once, not globally exactly-once.
+
+- [ ] Obtain explicit approval for a post-refusal recipient-delivery contract, then implement recipient-scoped reply-only recovery under the [reply ownership boundary](./docs/multi-instance-bus.md#reply-recovery-ownership-boundary), outside the containment hotfix. No ordinary recipient-scoped send grant is composed today: the local execution fence and queue-owner identity are insufficient, and receipt/admission namespaces cannot substitute for the registered recipient profile key. Ordinary sends return only a message ID, so the menu/delivery owner must participate in any destination change. Reuse selected-menu delivery only with its exact retained live-rebind/source grant; a raw journaled command cannot borrow it. Capture and recheck recipient/profile/session/registration authority at both ends, with no widening of the ordinary proxy.
+- [ ] Prove the reply-only path with the real follower API caller and worker: one replacement send before any reply chunk is acknowledged, consistent callback/message ownership and destination across every chunk, no stale reply anchor, no recovery for deletion/editing/unknown or lost ACKs, and no second send after authority changes. A command effect before a refused reply must execute once within that admission attempt; original journal evidence stays unchanged and diagnostics cannot change a successful outcome. Run typecheck and the full suite at the stable boundary. If these proofs cannot be supplied, retain the input without handler re-entry.
+- [ ] Live acceptance after the reply-only recovery checkpoint: a forwarded command whose follower Thread was re-created is answered in the current Thread (disposable tabs only).
+
+### Remaining routing investigation
+
 - [ ] Find why the temporary tab's selected `/start` stayed unresolved until expiry, and why that Restore moved custody without applying the rebind.
 - [ ] Route an input that arrives in a tab bound to nothing through a fresh temporary routing tab (the All flow) instead of publishing the chooser in the orphan, deleting the orphan with it once nothing unspent remains. Needs its own durable-metadata design.
 - [ ] Live acceptance on disposable tabs only: Cancel on an orphan tab deletes it; a second unspent input keeps it until the last Cancel; a plain `std::map` option button is delivered as an ordinary prompt.
+
+## Passive-child cold-import follow-up
+
+The 0.57.8 tag validation failed `Child process sharing the agent dir does not poll while parent owns Telegram lock` even when that file ran alone: `Child process did not exit. stdout= stderr=` at its existing child deadline. The other seven process tests and the identical pre-merge tree passed. That historical failure has no child-stage trace, so cold import, startup and a retained runtime handle remain competing explanations. Bounded diagnostic sampling is exhausted; passing traces showed imports up to 4.37 seconds against the five-second non-Windows child budget and natural exit within 8–14 ms after the event-loop checkpoint. These traces do not identify the original cause. A later main-validation recurrence stopped after `eval` and `import-start`, with parent-clock `elapsedMs=5009` and no import-complete checkpoint. That trace locates this recurrence before import completion, not in natural exit or a retained post-checkpoint handle; the slow dependency/startup cause remains unknown. The independent tag-owned Release validation passed the same committed tree, which does not erase the failed main check. The initial hotfix candidate then showed the same pre-import-completion state on Ubuntu at `elapsedMs=5026`; the recurrence is not macOS-only. Slow dependency/startup cost remains unexplained, separate from the fixture's corrected startup/exit observation contract.
+- [ ] Validate the corrected phase-owned passive-child fixture in fresh complete platform CI before publication: bounded total startup, a strict post-readiness exit guard, unchanged no-poll/natural-exit assertions and no forced shutdown or retry. Controlled delayed-start/retained-work regressions and local native passes are not platform proof. For any genuine recurrence, preserve deadline and stage evidence before correcting runtime imports or budgets. Do not spend unchanged-head diagnostic samples or claim runner contention or the historical cause is proven.
+
+## Windows Workspace-gate fixture timeout
+
+`Leader assembly serializes follower provisioning through its shared Workspace gate` once exceeded its generic one-second bus-response deadline. It sends `follower.register` directly, outside the changed API caller; production registration has a separate budget. The later native standalone witness acknowledged at about 90 ms, and the full suite passed, but the original failure has no gate/persistence trace. A synthetic delayed-write probe verifies diagnostic capture, not the native cause.
+- [ ] Use the next genuinely failing native trace to distinguish gate wait, persistence and acknowledgement delay before correcting this fixture or runtime. Retain its bounded stage evidence and standalone/full-suite execution; do not spend unchanged-head reruns or infer a cause from passing checks. Any deadline-policy correction must be justified against the registration owner's contract, not a guessed larger timeout.

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

@@ -4,6 +4,37 @@
 
 ## Unreleased
 
+## 0.58.1: Independent Thread Typing
+
+- `Typing`: A pending activity request in one Thread no longer silently suppresses another Thread's typing. Exact chat/Thread/action calls still coalesce with their own minimum interval, while real Telegram 429 cooldowns remain shared across the chat, including late failures after a faster peer completes. Authority checks, one-attempt typing and bounded gate storage remain intact.
+- `Process validation`: Passive-child checks distinguish cold startup from natural exit: a 15-second total cap retains the existing Windows bound, while a separate five-second guard starts after the event-loop checkpoint on every platform. Regressions reject both a missing checkpoint and retained post-checkpoint work; no polling assertions, natural-exit requirement or job budgets are weakened.
+
+## 0.58.0: Unified Connect Gateway
+
+- `Pi commands`: Removes the standalone `/telegram-internal` gateway. Runtime-armed session replacement now dispatches `/telegram-connect --internal new <token>` after exact durable update completion. Internal calls bypass profile activation and connection/recovery; malformed, unarmed and replayed calls fail closed. `internal` remains a valid profile name.
+
+## 0.57.11: Follower Reply Target
+
+- `Follower command replies`: Status/model/settings and text replies from an admitted follower command select its acknowledged Thread before publication, not the old input Thread. A changed Thread drops the reply anchor; delivery, menu state and ownership use one destination. The journaled original and explicit selected-menu grants stay intact; no refused-send recovery, handler replay or proxy widening is added.
+
+## 0.57.10: Follower Request Identity
+
+- `Follower request identity`: Follower API arguments use one JSON-wire snapshot before registration waits. Later caller mutation no longer changes the issued method/body or relabels a refused target and slow-call method. Ordinary and multipart calls retain wire JSON semantics and authority fences; refusal evidence still grants no resend or whole-command replay.
+- `Windows CI diagnostics`: The Workspace-gate registration fixture records bounded gate and persistence stage timings, including them in failure context without paths or credentials. It also runs in the standalone Windows lifecycle probe before the full concurrent suite. Existing assertions, response deadline and job budgets are unchanged; instrumentation does not claim to solve the observed timeout.
+
+## 0.57.9: Reply Safety and CI Recovery
+
+- `Recipient safety`: Ships the containment prepared for unpublished 0.57.8: a refused follower reply no longer immediately reruns its whole command handler and repeats earlier effects. The original input stays unchanged in durable retry state, without silent completion. Automatic reply relocation remains withdrawn; stale-Thread commands may still retry and ordinary execution remains at-least-once.
+- `Follower refusals`: Structured bus acknowledgements identify requests blocked before Telegram API delegation, without granting resend authority. Legacy error text, mismatched methods and lost acknowledgements cannot prove non-execution. Reply chunks keep their captured destination and ownership; refused chunks acquire no message ownership.
+- `CI sharding`: macOS distributes its serialized test files across two deterministic jobs to avoid the measured whole-job overrun. A checked inventory includes every file exactly once, with real-process tests isolated and the local Pi CLI on PATH. Assertions, test deadlines and the 30-minute job budget are unchanged; publication requires every platform and shard to pass.
+- `Process diagnostics`: Child-exit checks report bounded lifecycle timings and active resource types without logging fixture credentials or paths or adding referenced timers. Import, startup and natural-exit stages can now distinguish future failures. The original macOS child timeout remains unexplained; passing traces do not establish its cause.
+
+## 0.57.8: Reply Recovery Safety
+
+- `Recipient safety`: A refused follower reply no longer immediately re-runs the whole command handler, which could repeat changes made before the failed send. The original input stays unchanged in durable retry state, without silent completion. Automatic reply relocation is withdrawn pending transport-level safety proof; a stale-Thread command may still retry and ordinary execution remains at-least-once.
+- `Follower refusals`: Structured bus acknowledgements distinguish requests blocked before Telegram API delegation from errors returned after execution. Legacy error text, mismatched methods and lost acknowledgements cannot certify non-execution or authorize a resend. Reply chunks retain their captured destination and ownership; refused chunks acquire no message ownership.
+- `CI`: macOS runs real-process shutdown tests separately and the remaining test files one at a time, keeping the local Pi CLI on PATH. Assertions and deadlines are unchanged. This reduces observed runner-contention failures without claiming the process-exit flake is eliminated.
+
 ## 0.57.7: Routing Cleanup and Recipient Recovery
 
 - `Recipient recovery`: A forwarded input journaled for a follower whose Thread was re-created no longer retries forever against the old Thread. After the leader refuses that reply, the input re-runs once against the follower's current Thread; a second refusal or any other failure keeps the durable retry state, and nothing is dropped.

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

@@ -201,6 +201,7 @@ export declare function createTelegramLiveTargetWorkObserver<TContext>(deps: {
 }, ctx: TContext) => TelegramBusLiveRebindWorkState;
 interface TelegramCommandsAndToolsBindingDeps {
     pi: Pi.ExtensionAPI;
+    handleInternalAction: Commands.TelegramSessionActionRuntime["handleInternalAction"];
     agentDir: string;
     configStore: Config.TelegramConfigStore;
     persistConfig: (config?: Config.TelegramConfig) => Promise<void>;
@@ -241,7 +242,7 @@ interface TelegramCommandsAndToolsBindingDeps {
     connectionIntent: NonNullable<Commands.TelegramBridgeCommandRegistrationDeps["connectionIntent"]>;
     recordRuntimeEvent: TelegramRuntimeEventRecorder;
 }
-export declare function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, isContextCurrent, getSessionGeneration, connectionIntent, }: TelegramCommandsAndToolsBindingDeps): void;
+export declare function registerTelegramCommandsAndTools({ pi, handleInternalAction, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, isContextCurrent, getSessionGeneration, connectionIntent, }: TelegramCommandsAndToolsBindingDeps): void;
 interface TelegramLifecycleBindingDeps {
     pi: Pi.ExtensionAPI;
     publicationRuntime: TelegramBridgePublicationRuntime;

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

@@ -497,7 +497,7 @@ export function createTelegramLiveTargetWorkObserver(deps) {
         };
     };
 }
-export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, isContextCurrent, getSessionGeneration, connectionIntent, }) {
+export function registerTelegramCommandsAndTools({ pi, handleInternalAction, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, isContextCurrent, getSessionGeneration, connectionIntent, }) {
     GenerativeApps.registerTelegramBindTool(pi, {
         agentDir,
         getActiveProfileName: configStore.getActiveProfileName,
@@ -551,6 +551,7 @@ export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, pe
         }, { deliverAs: "nextTurn" });
     };
     Commands.registerTelegramBridgeCommands(pi, {
+        handleInternalAction,
         promptForConfig: async (ctx, profileName) => {
             const nextProfileName = profileName ?? undefined;
             if (profileName && !Config.isValidTelegramProfileName(profileName)) {

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

@@ -955,6 +955,11 @@ export function createTelegramBusFollowerApiCaller(deps) {
         const assertion = localOptions?.assertAuthority;
         const assertCurrent = () => assertTelegramApiCallAuthority(assertion, false);
         assertCurrent();
+        // Match IPC's JSON semantics once, before awaits; send and refusal metadata share this identity.
+        const requestArgs = JSON.parse(JSON.stringify(args));
+        const apiMethod = (method === "call" || method === "callMultipart") && typeof requestArgs[0] === "string"
+            ? requestArgs[0] : method;
+        timing.apiMethod = apiMethod;
         const registration = await resolveTelegramBusFollowerRegistration(deps, timeoutMs);
         timing.registeredAtMs = getNowMs();
         assertCurrent();
@@ -968,17 +973,13 @@ export function createTelegramBusFollowerApiCaller(deps) {
                 instanceId: deps.instanceId,
                 registrationGeneration: registration.generation,
                 method,
-                args,
+                args: requestArgs,
                 sentAtMs: getNowMs(),
             }, assertion ? assertCurrent : undefined);
         }
         catch (error) {
             if (error instanceof TelegramBusLocalAuthorityError)
                 throw new TelegramApiAuthorityError(error.requestIssued);
-            const apiMethod = (method === "call" || method === "callMultipart") &&
-                typeof args[0] === "string"
-                ? args[0]
-                : method;
             if (!isTelegramApiMethodRetrySafe(apiMethod)) {
                 throw new TelegramApiCommitUnknownError(apiMethod, error);
             }
@@ -1002,15 +1003,19 @@ export function createTelegramBusFollowerApiCaller(deps) {
             response.error?.code === "commit-unknown") {
             throw new TelegramApiCommitUnknownError(response.error.method ?? method, new Error(message ?? "Telegram bus API call result is ambiguous."));
         }
-        if (message === TELEGRAM_BUS_FOLLOWER_API_NOT_ALLOWED_MESSAGE) {
-            const body = (method === "call" || method === "callMultipart") && isRecord(args[1])
-                ? args[1]
+        const refusedMethod = response?.kind === "bus.ack" && !response.ok &&
+            response.error?.code === "follower-api-not-allowed" &&
+            response.error.method === apiMethod
+            ? apiMethod : undefined;
+        if (refusedMethod || message === TELEGRAM_BUS_FOLLOWER_API_NOT_ALLOWED_MESSAGE) {
+            const body = (method === "call" || method === "callMultipart") && isRecord(requestArgs[1])
+                ? requestArgs[1]
                 : undefined;
             const chatId = Number(body?.chat_id);
             const threadId = Number(body?.message_thread_id);
-            throw new TelegramApiFollowerNotAllowedError(message, Number.isSafeInteger(chatId) && Number.isSafeInteger(threadId)
+            throw new TelegramApiFollowerNotAllowedError(message ?? TELEGRAM_BUS_FOLLOWER_API_NOT_ALLOWED_MESSAGE, Number.isSafeInteger(chatId) && Number.isSafeInteger(threadId)
                 ? { chatId, threadId }
-                : undefined);
+                : undefined, refusedMethod);
         }
         throw new Error(message ?? "Telegram bus API call failed.");
     };
@@ -1028,10 +1033,7 @@ export function createTelegramBusFollowerApiCaller(deps) {
         finally {
             const elapsedMs = getNowMs() - startedAtMs;
             if (elapsedMs >= slowCallMs) {
-                const apiMethod = (method === "call" || method === "callMultipart") &&
-                    typeof args[0] === "string"
-                    ? args[0]
-                    : method;
+                const apiMethod = timing.apiMethod ?? method;
                 try {
                     deps.recordRuntimeEvent?.("bus", `Telegram bus follower API call was slow (${elapsedMs}ms).`, {
                         phase: "follower-api-slow",

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

@@ -2770,7 +2770,14 @@ async function handleFollowerApiCall(envelope, deps) {
             method: envelope.method,
             args: envelope.args,
         })) {
-        return rejectTelegramBusRequest(envelope.requestId, TELEGRAM_BUS_FOLLOWER_API_NOT_ALLOWED_MESSAGE);
+        const apiMethod = getFollowerApiMethodAndBody(envelope).apiMethod;
+        return {
+            ...rejectTelegramBusRequest(envelope.requestId, TELEGRAM_BUS_FOLLOWER_API_NOT_ALLOWED_MESSAGE),
+            // Only this pre-dispatch authorizer refusal certifies that the API method was not called.
+            ...(/^[A-Za-z][A-Za-z0-9]{0,63}$/.test(apiMethod)
+                ? { error: { code: "follower-api-not-allowed", method: apiMethod } }
+                : {}),
+        };
     }
     if (!deps.callApi) {
         return rejectTelegramBusRequest(envelope.requestId, "Telegram bus leader does not expose API calling.");

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

@@ -548,7 +548,7 @@ export type TelegramBusEnvelope = ({
     result?: unknown;
     protocol?: TelegramBusProtocolIdentity;
     error?: {
-        code: "commit-unknown" | "request-id-collision" | "ledger-overloaded" | "incompatible-protocol" | "stale-target" | "workspace-binding-unavailable";
+        code: "commit-unknown" | "request-id-collision" | "ledger-overloaded" | "incompatible-protocol" | "stale-target" | "follower-api-not-allowed" | "workspace-binding-unavailable";
         method?: string;
         chatId?: number;
         threadId?: number;

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

@@ -2657,9 +2657,15 @@ function parseAckEnvelope(value, requestId) {
             code === "ledger-overloaded" ||
             code === "incompatible-protocol" ||
             code === "stale-target" ||
+            code === "follower-api-not-allowed" ||
             code === "workspace-binding-unavailable") {
             const chatId = value.error.chatId;
             const threadId = value.error.threadId;
+            if (code === "follower-api-not-allowed" &&
+                (value.ok || Object.hasOwn(value, "result") ||
+                    typeof value.error.method !== "string" ||
+                    !/^[A-Za-z][A-Za-z0-9]{0,63}$/.test(value.error.method)))
+                return undefined;
             if (code === "stale-target" &&
                 (!Number.isSafeInteger(chatId) || !Number.isSafeInteger(threadId))) {
                 return undefined;

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

@@ -11,6 +11,7 @@ import type { TelegramPromptTemplateCommand } from "./prompt-templates.ts";
 import { createTelegramControlItemBuilder, type PendingTelegramControlItem, type TelegramControlQueueController, type TelegramControlQueueControllerDeps, type TelegramQueueAdmissionReceipt } from "./queue.ts";
 import { type TelegramBridgeStatusLineOptions } from "./status.ts";
 import { type TelegramApiCallOptions } from "./telegram-api.ts";
+import type { TelegramTarget } from "./target.ts";
 import type { TelegramSessionReplacementIntent } from "./threads.ts";
 import { type TelegramDeferredSourceEvidence, type TelegramLiveSourceCompletionReadiness, type TelegramQueueAdmissionReceiptLike } from "./updates.ts";
 export type TelegramHeldCommandName = "status" | "start" | "help" | "abort" | "stop" | "next" | "continue";
@@ -165,6 +166,7 @@ export interface TelegramBridgeCommandStartPollingResult {
     owner?: string;
 }
 export interface TelegramBridgeCommandRegistrationDeps {
+    handleInternalAction?: TelegramSessionActionRuntime["handleInternalAction"];
     promptForConfig: (ctx: ExtensionCommandContext, profileName?: string) => Promise<void>;
     getStatusLines: (options?: TelegramBridgeStatusLineOptions) => string[];
     reloadConfig: () => Promise<void>;
@@ -383,11 +385,13 @@ export interface TelegramCommandTargetRuntimeDeps<TContext> {
     enqueueControlItem: (target: TelegramCommandMessageTarget, ctx: TContext, controlType: TelegramControlCommandType, statusSummary: string, execute: (ctx: TContext) => Promise<void>, admissionReceipts?: TelegramQueueAdmissionReceipt[], onQueued?: (item: PendingTelegramControlItem<TContext>) => void) => void;
     getAdmissionScope?: () => string | undefined;
     getAdmissionJournalBinding?: () => string | undefined;
+    /** Ordinary reply destination selected before publication, not resend authority. */
+    getReplyTarget?: (message: TelegramCommandRuntimeMessage) => TelegramTarget | undefined;
     onControlQueued?: (message: TelegramCommandRuntimeMessage, receipt: TelegramQueueAdmissionReceipt) => void;
-    showStatus: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
-    openModelMenu: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
-    openSettingsMenu?: (chatId: number, replyToMessageId: number, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
-    sendTextReply: (chatId: number, replyToMessageId: number, text: string, options?: {
+    showStatus: (chatId: number, replyToMessageId: number | undefined, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
+    openModelMenu: (chatId: number, replyToMessageId: number | undefined, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
+    openSettingsMenu?: (chatId: number, replyToMessageId: number | undefined, ctx: TContext, threadId?: number, options?: Pick<TelegramApiCallOptions, "assertAuthority">) => Promise<void>;
+    sendTextReply: (chatId: number, replyToMessageId: number | undefined, text: string, options?: {
         parseMode?: "HTML";
         target?: {
             chatId: number;
@@ -658,11 +662,10 @@ export declare function createTelegramCommandHandler<TMessage extends TelegramCo
     prepareSelectedMenuCommand(command: ParsedTelegramCommand, messages: readonly TMessage[], ctx: TContext, admission: TelegramSelectedCommandAdmission): (() => Promise<boolean>) | undefined;
 };
 export declare function createTelegramCommandOrPromptDispatcher<TMessage, TContext>(deps: TelegramCommandOrPromptDispatcherDeps<TMessage, TContext>): (messages: TMessage[], ctx: TContext) => Promise<void>;
-export declare const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
-export declare const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "Internal Telegram command cannot be run manually";
-export declare const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram command cannot be run manually.";
+export declare const TELEGRAM_CONNECT_COMMAND_NAME = "telegram-connect";
+export declare const TELEGRAM_INTERNAL_COMMAND_FLAG = "--internal";
+export declare const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram action cannot be run manually.";
 export interface TelegramSessionActionRuntimeDeps {
-    registerCommand: Pi.ExtensionAPI["registerCommand"];
     sendUserMessage: Pi.ExtensionAPI["sendUserMessage"];
     notifyResult: (target: {
         chatId: number;
@@ -694,7 +697,6 @@ export interface TelegramSessionReplacementSettlementDeps {
 }
 export declare function settleTelegramSessionReplacement(deps: TelegramSessionReplacementSettlementDeps): Promise<"none" | "settled" | "expired" | "failed" | "stale">;
 export interface TelegramSessionActionAssemblyDeps {
-    registerCommand: Pi.ExtensionAPI["registerCommand"];
     sendUserMessage: Pi.ExtensionAPI["sendUserMessage"];
     store: {
         load: () => Promise<void>;
@@ -750,7 +752,7 @@ export declare function createTelegramSessionActionAssembly(deps: TelegramSessio
     };
 };
 export interface TelegramSessionActionRuntime {
-    register: () => void;
+    handleInternalAction: (args: string, ctx: Pi.ExtensionCommandContext) => Promise<void>;
     scheduleAfterUpdate: (updateId: number, target: {
         chatId: number;
         threadId?: number;

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

@@ -405,6 +405,7 @@ function formatTelegramTakeoverPrompt(ctx, owner) {
     return `${action}\n\n${from} ${source}\n${to} ${ctx.cwd}`;
 }
 export function registerTelegramBridgeCommands(pi, deps) {
+    const handleInternalAction = deps.handleInternalAction;
     pi.registerCommand("telegram-setup", {
         description: "<profile> — Configure Telegram bot token",
         handler: async (args, ctx) => {
@@ -418,9 +419,19 @@ export function registerTelegramBridgeCommands(pi, deps) {
             ctx.ui.notify(deps.getStatusLines({ verbose }).join("\n"), "info");
         },
     });
-    pi.registerCommand("telegram-connect", {
+    pi.registerCommand(TELEGRAM_CONNECT_COMMAND_NAME, {
         description: "<profile> — Start Telegram bridge",
         handler: async (args, ctx) => {
+            const words = args.trim().split(/\s+/);
+            // Service dispatch never inherits profile activation or explicit-connect recovery authority.
+            if (words.some(word => word.toLowerCase().startsWith(TELEGRAM_INTERNAL_COMMAND_FLAG))) {
+                if (words[0] !== TELEGRAM_INTERNAL_COMMAND_FLAG || !handleInternalAction) {
+                    ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
+                    return;
+                }
+                await handleInternalAction(words.slice(1).join(" "), ctx);
+                return;
+            }
             const sessionGeneration = deps.getSessionGeneration?.();
             let intentId;
             // Pi context getters throw after replacement; check plain intent/generation first.
@@ -629,6 +640,7 @@ export function createTelegramCommandTargetQueueRuntime(deps) {
             createControlItem,
             enqueueControlItem: controlQueueController.enqueue,
         }),
+        getReplyTarget: deps.getReplyTarget,
         getAdmissionScope: deps.getAdmissionScope,
         getAdmissionJournalBinding: deps.getAdmissionJournalBinding,
         onControlQueued: deps.onControlQueued,
@@ -639,6 +651,22 @@ export function createTelegramCommandTargetQueueRuntime(deps) {
     });
 }
 export function createTelegramCommandTargetRuntime(deps) {
+    const getReplyTarget = (message, options) => {
+        const source = getTelegramCommandMessageTarget(message);
+        const recipient = options?.assertAuthority
+            ? undefined
+            : deps.getReplyTarget?.(message);
+        if (!recipient)
+            return source;
+        if (recipient.chatId !== source.chatId)
+            throw new Error("Telegram command reply cannot change its recipient chat.");
+        if (source.threadId !== undefined && recipient.threadId === undefined)
+            throw new Error("Telegram command cannot move a Thread reply to All.");
+        return {
+            ...recipient,
+            replyToMessageId: recipient.threadId === source.threadId ? source.replyToMessageId : undefined,
+        };
+    };
     return {
         enqueueControlItem: (message, ctx, controlType, statusSummary, execute) => {
             const sourceUpdateId = message.pi_telegram_source_update_id;
@@ -659,15 +687,15 @@ export function createTelegramCommandTargetRuntime(deps) {
             deps.enqueueControlItem(getTelegramCommandMessageTarget(message), ctx, controlType, statusSummary, execute, receipt ? [receipt] : undefined, receipt ? () => deps.onControlQueued?.(message, receipt) : undefined);
         },
         showStatus: (message, ctx, options) => {
-            const target = getTelegramCommandMessageTarget(message);
+            const target = getReplyTarget(message, options);
             return deps.showStatus(target.chatId, target.replyToMessageId, ctx, target.threadId, options);
         },
         openModelMenu: (message, ctx, options) => {
-            const target = getTelegramCommandMessageTarget(message);
+            const target = getReplyTarget(message, options);
             return deps.openModelMenu(target.chatId, target.replyToMessageId, ctx, target.threadId, options);
         },
         openSettingsMenu: async (message, ctx, options) => {
-            const target = getTelegramCommandMessageTarget(message);
+            const target = getReplyTarget(message, options);
             if (!deps.openSettingsMenu) {
                 await deps.sendTextReply(target.chatId, target.replyToMessageId, formatTelegramInformationHeading("🚫", "Settings menu is unavailable."), { target, parseMode: "HTML" });
                 return;
@@ -675,7 +703,7 @@ export function createTelegramCommandTargetRuntime(deps) {
             await deps.openSettingsMenu(target.chatId, target.replyToMessageId, ctx, target.threadId, options);
         },
         sendTextReply: async (message, text, options) => {
-            const target = getTelegramCommandMessageTarget(message);
+            const target = getReplyTarget(message, options);
             const assertAuthority = options?.assertAuthority, send = deps.sendTextReply;
             const capturedOptions = { ...options, target };
             assertAuthority?.();
@@ -1061,6 +1089,7 @@ export function createTelegramCommandHandlerTargetRuntime(deps) {
         }),
         appendControlItem: deps.appendControlItem,
         dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
+        getReplyTarget: deps.getReplyTarget,
         getAdmissionScope: deps.getAdmissionScope,
         getAdmissionJournalBinding: deps.getAdmissionJournalBinding,
         onControlQueued: deps.onControlQueued,
@@ -2397,9 +2426,9 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
         },
     }, commandArgs);
 }
-export const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
-export const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "Internal Telegram command cannot be run manually";
-export const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram command cannot be run manually.";
+export const TELEGRAM_CONNECT_COMMAND_NAME = "telegram-connect";
+export const TELEGRAM_INTERNAL_COMMAND_FLAG = "--internal";
+export const TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE = "This internal Telegram action cannot be run manually.";
 function delayTelegramSessionAction(delayMs) {
     return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
@@ -2469,7 +2498,6 @@ export function createTelegramSessionActionAssembly(deps) {
         report(new Error("Telegram new-session result delivery failed."));
     };
     const action = createTelegramSessionActionRuntime({
-        registerCommand: deps.registerCommand,
         sendUserMessage: deps.sendUserMessage,
         notifyResult(target, result) {
             return sendTerminalResult(target, result);
@@ -2567,7 +2595,6 @@ export function createTelegramSessionActionRuntime(deps) {
     let pendingUpdateId;
     let pendingTarget;
     let pendingAction;
-    let registered = false;
     const reportFailure = (error) => {
         try {
             deps.recordRuntimeEvent?.("new-session", error);
@@ -2577,35 +2604,29 @@ export function createTelegramSessionActionRuntime(deps) {
         }
     };
     return {
-        register() {
-            if (registered)
+        async handleInternalAction(args, ctx) {
+            const action = pendingAction;
+            const [operation, token, ...extra] = args.trim().split(/\s+/);
+            if (!action || operation !== "new" ||
+                token !== action.token || extra.length !== 0) {
+                ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
                 return;
-            registered = true;
-            deps.registerCommand(TELEGRAM_INTERNAL_COMMAND_NAME, {
-                description: TELEGRAM_INTERNAL_COMMAND_DESCRIPTION,
-                handler: async (args, ctx) => {
-                    const action = pendingAction;
-                    if (!action || args.trim() !== action.token) {
-                        ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
-                        return;
+            }
+            pendingAction = undefined;
+            switch (action.kind) {
+                case "replace-session":
+                    try {
+                        await deps.prepareReplacement?.(ctx, action.updateId, action.target);
+                        const result = await ctx.newSession();
+                        if (result.cancelled)
+                            await deps.notifyResult(action.target, "cancelled");
                     }
-                    pendingAction = undefined;
-                    switch (action.kind) {
-                        case "replace-session":
-                            try {
-                                await deps.prepareReplacement?.(ctx, action.updateId, action.target);
-                                const result = await ctx.newSession();
-                                if (result.cancelled)
-                                    await deps.notifyResult(action.target, "cancelled");
-                            }
-                            catch (error) {
-                                reportFailure(error);
-                                await deps.notifyResult(action.target, "failure");
-                            }
-                            return;
+                    catch (error) {
+                        reportFailure(error);
+                        await deps.notifyResult(action.target, "failure");
                     }
-                },
-            });
+                    return;
+            }
         },
         scheduleAfterUpdate(updateId, target) {
             if (pendingUpdateId !== undefined || pendingAction !== undefined)
@@ -2625,9 +2646,7 @@ export function createTelegramSessionActionRuntime(deps) {
             const token = randomUUID();
             pendingAction = { kind: "replace-session", token, updateId, target };
             void Promise.resolve()
-                .then(() => deps.sendUserMessage(`/${TELEGRAM_INTERNAL_COMMAND_NAME} ${token}`, {
-                expandPromptTemplates: true,
-            }))
+                .then(() => deps.sendUserMessage(`/${TELEGRAM_CONNECT_COMMAND_NAME} ${TELEGRAM_INTERNAL_COMMAND_FLAG} new ${token}`, { expandPromptTemplates: true }))
                 .catch((error) => {
                 pendingAction = undefined;
                 reportFailure(error);