@llblab/pi-kit 0.36.3 → 0.37.1

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to `@llblab/pi-kit` are documented here.
 
+## 0.37.1: Bundled Package Updates (2026-10-26)
+
+- `Exact pins`: `@llblab/pi-telegram` 0.58.1 → 0.58.3.
+- `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.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.

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.11` | 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.3` | 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

@@ -107,9 +107,9 @@ Use the relevant local skill before non-trivial work in its domain. Keep skill o
 - A model selection from an authorized Telegram target may stop and continue any interruptible active agent run in that same Pi session, including local/TUI work. Queue the synthetic control-lane continuation before aborting; when no Telegram prompt owns the run, bind continuation and reply ownership to the exact model-menu chat/Thread/message. Delay abort until every active tool execution settles, and clear both selection and fallback target on cancellation, agent start, settlement, or session replacement.
 - Telegram extension side effects must not hold Pi's core lifecycle hostage after semantic completion. Preserve ordering in extension-owned background work, record failures, and fence target/profile/transport/session authority.
 - 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.
+- 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 and recognize complete action comments by their delimiters and payload, independent of surrounding Markdown; 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,21 +2,19 @@
 
 _This file owns unresolved project work only. Completed behavior belongs in `CHANGELOG.md`; durable contracts belong in `AGENTS.md` and `/docs`._
 
-## 0.57.11 publication checkpoint
-
-- [ ] Validate and publish only the pre-publication follower reply-target fix through the protected dev-to-main release path. Require fresh Ubuntu, Windows and both macOS shard checks before merge, exact candidate/merged-tree equality, one immutable version tag and the repository-owned release workflow.
-- [ ] Confirm the published GitHub Release and public npm version, tag/gitHead identity, release notes and packed runtime/skills before closing this checkpoint. Keep post-refusal recovery and disposable-tab live acceptance open; do not reload the running session.
-
 ## 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.
 - [ ] On separately authorized disposable routing tabs, verify pending-choice protection, Cancel after the view becomes unavailable, expiry notice in the owned leader Thread and no duplicate deletion after an unknown outcome. Local native journal/API-decoder fixtures are not live client acceptance.
 
-## Prompt-cache live confirmation
+## Typing authority during Telegram turns
+
+Live report on package 0.58.2 and Pi 1.4.0: every Telegram turn logged `sendChatAction: Telegram API call authority is unavailable` in a connected, long-lived session. The reporter's leader/follower role and refusal stage are not yet known. Prompt-cache acceptance is complete; this is a separate typing-indicator investigation.
 
-The prompt-cache report remains open for the reporter's offered live Anthropic capture after the published fix. Native request/transcript checks do not replace cache-hit or signed-thinking measurements.
+The native expired-loop diagnostic case is corrected: real typing loop/starter, direct API runtime and API client regressions cover mocked HTTP 200 after stop/same-target replacement, with unchanged session generation and transport epoch. A process-local ended-loop observation suppresses only the corresponding typed authority diagnostic; the request still rejects, active-owner refusals remain visible, and no callback crosses IPC. Real-client regressions retain the original HTTP/network failure when authority expires during error handling; a native follower caller rejects a delayed ACK after its local owner ends, without replay. Direct/follower and Classic/Threaded paths remain distinct from live acceptance. This does not establish the cause of the reporter's live failure or prove client typing.
 
-- [ ] Review the reporter's resume and mid-session tool-change results (versions, cache read/write counts and new thinking-drop events). Close the report if the live evidence confirms the fix, or narrow any residual failure into actionable follow-up. Do not reconstruct or claim recovery of previously lost thinking blocks.
+- [ ] Correlate the live report with the corrected native case using only redacted leader/follower role, timing around loop end/replacement and refusal-stage evidence if available. Do not infer transport loss or widen authority from the error string alone; isolate any distinct current-owner refusal before another runtime change.
+- [ ] After separately approved live validation, confirm client typing and absence of expired-loop API noise across Telegram turns and loop replacement. Preserve exact Thread targeting, independent Thread requests, best-effort presence and no unhealthy-status escalation; local native fixtures are not live acceptance.
 
 ## Stuck forwarded command after Thread re-creation
 
@@ -38,10 +36,10 @@ A target-scoped reply refusal cannot prove that a command made no prior effects.
 - [ ] 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.
 
-## macOS process-exit test flake
+## 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.
-- [ ] Retain bounded child-stage/resource diagnostics for the next genuinely failing passive-child trace; the original timeout is still unexplained. Do not spend more unchanged-head diagnostic samples. The parent records explicit shutdown separately; do not add a shutdown call to the passive child to make it pass. Correct a fixture/runtime cause only when the failing stage evidence supports it, and require fresh platform CI before resuming release recovery. Do not widen deadlines or describe the runner as the proven cause without measurement.
+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 minor release's independent tag-owned validation passed the same committed tree, which does not erase that historical 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.
+- [ ] On a genuinely failing cold-import trace under the phase-owned fixture, isolate dependency/startup cost using its actual overall/exit deadline and stage evidence before changing runtime imports or budgets. Preserve natural-exit/no-poll assertions and job budgets. Do not spend unchanged-head diagnostic samples or infer runner contention or the historical cause from passing runs.
 
 ## Windows Workspace-gate fixture timeout
 

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

@@ -4,6 +4,25 @@
 
 ## Unreleased
 
+## 0.58.3: Typing Cancellation Diagnostics
+
+- `Typing diagnostics`: Ended typing loops no longer log cancellation-only authority refusals as API failures. Real HTTP/network failures retain their provenance and diagnostics even if authority expires before settlement. Requests remain rejected and single-attempt; callbacks stay local. Native late-success/failure and follower-ACK regressions cover this case, not the cause of the live report.
+- `Prompt-cache acceptance`: Reporter-provided live Anthropic captures and connected-session measurements confirm the released fix across tool changes, resume, local/Telegram switches and reconnect, with no new thinking drops in the tested runs. The remaining live-confirmation gate is closed; connected wire capture and broader model/cache-expiry coverage remain outside this evidence. Already-lost thinking is not reconstructed.
+
+## 0.58.2: Flexible Assistant Action Markup
+
+- `HTML actions`: Complete button/voice comments activate by their delimiters and accepted payload regardless of whitespace or surrounding Markdown, including code fences. Adjacent same-line comments are independent; unfinished comments do not activate. Escape the opening delimiter as `<!--` for literal examples.
+- `In-body buttons`: Fenced `telegram_button` blocks tolerate horizontal indentation, whitespace before the exact name, and three or more backticks or tildes. Closures require the same marker and at least the opening length on a separate line. Enclosing fenced examples remain literal; incomplete blocks, malformed JSON/CML and invalid rows still register no callbacks.
+
+## 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.

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/commands.d.ts

@@ -166,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>;
@@ -661,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;
@@ -697,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>;
@@ -753,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.
@@ -2415,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));
 }
@@ -2487,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);
@@ -2585,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);
@@ -2595,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)
@@ -2643,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);

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

@@ -80,7 +80,7 @@ const telegramBusProtocolIdentity = Bus.createTelegramCurrentBusProtocolIdentity
 export default function (pi) {
     Skills.registerTelegramSkillDiscovery(pi);
     const piRuntime = Pi.createExtensionApiRuntimePorts(pi);
-    const { getActiveTools, getCommands, getThinkingLevel, sendUserMessage, registerCommand, setActiveTools, setModel, setThinkingLevel, } = piRuntime;
+    const { getActiveTools, getCommands, getThinkingLevel, sendUserMessage, setActiveTools, setModel, setThinkingLevel, } = piRuntime;
     const bridgeRuntime = Runtime.createTelegramBridgeRuntime();
     const runtimeDiagnostics = Logging.createTelegramRuntimeDiagnosticsRuntime({
         sharedFile: true,
@@ -242,7 +242,6 @@ export default function (pi) {
         captureAuthority: captureTelegramStateAuthority,
     });
     const sessionActionAssembly = Commands.createTelegramSessionActionAssembly({
-        registerCommand,
         sendUserMessage,
         store: threadStore,
         getProfileName: configStore.getActiveProfileName,
@@ -2293,9 +2292,9 @@ export default function (pi) {
             }
         },
     }.reset);
-    sessionActionsRuntime.register();
     Bindings.registerTelegramCommandsAndTools({
         pi,
+        handleInternalAction: sessionActionsRuntime.handleInternalAction,
         agentDir: Paths.resolveAgentDir(),
         configStore,
         persistConfig: persistTelegramConfigWithSync,

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

@@ -4,7 +4,7 @@
  * Owns assistant-authored telegram_button extraction, button action storage, callback handling, and prompt-turn construction
  */
 import { randomUUID } from "node:crypto";
-import { getTelegramActionString as getTelegramButtonString, parseTelegramActionPayloadRows, parseTelegramButtonPayloadRows, replaceTelegramButtonFences, replaceTopLevelHtmlComments, } from "./outbound-markup.js";
+import { getTelegramActionString as getTelegramButtonString, parseTelegramActionPayloadRows, parseTelegramButtonPayloadRows, replaceTelegramButtonFences, replaceTelegramHtmlComments, } from "./outbound-markup.js";
 import { truncateTelegramQueueSummary, } from "./queue.js";
 const TELEGRAM_BUTTON_CALLBACK_PREFIX = "tgbtn";
 const TELEGRAM_BUTTON_ACTION_TTL_MS = 24 * 60 * 60 * 1000;
@@ -117,7 +117,23 @@ export function planTelegramButtonReply(markdown, deps) {
                 }),
             }));
     };
-    const withRichButtons = replaceTelegramButtonFences(markdown, (payload, closed) => {
+    const footerKeyboard = [];
+    const stripped = replaceTelegramHtmlComments(markdown, (comment) => {
+        const command = "telegram_button";
+        const normalizedContent = comment.content
+            .replace(/^\s+/, "")
+            .replace(/^!/, "");
+        if (!normalizedContent.startsWith(command))
+            return comment.raw;
+        const payloadRows = parseTelegramActionPayloadRows(comment, command);
+        if (!payloadRows)
+            return "";
+        const rows = buildRows(payloadRows, false);
+        if (rows)
+            footerKeyboard.push(...rows);
+        return "";
+    });
+    const withRichButtons = replaceTelegramButtonFences(stripped, (payload, closed) => {
         if (!closed)
             return "";
         const payloadRows = parseTelegramButtonPayloadRows(payload);
@@ -133,22 +149,8 @@ export function planTelegramButtonReply(markdown, deps) {
         }
         return `\n${rows.map(renderTelegramRichButtonRow).join("\n\n")}\n`;
     });
-    const stripped = replaceTopLevelHtmlComments(withRichButtons, (comment) => {
-        const command = "telegram_button";
-        const normalizedContent = comment.content
-            .replace(/^\s+/, "")
-            .replace(/^!/, "");
-        if (!normalizedContent.startsWith(command))
-            return comment.raw;
-        const payloadRows = parseTelegramActionPayloadRows(comment, command);
-        if (!payloadRows)
-            return "";
-        const rows = buildRows(payloadRows, false);
-        if (rows)
-            keyboard.push(...rows);
-        return "";
-    });
-    const visibleMarkdown = normalizeMarkdownAfterButtonExtraction(stripped);
+    keyboard.push(...footerKeyboard);
+    const visibleMarkdown = normalizeMarkdownAfterButtonExtraction(withRichButtons);
     return {
         markdown: keyboard.length > 0 && !visibleMarkdown
             ? DEFAULT_TELEGRAM_BUTTON_REPLY_MARKDOWN

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

@@ -1,22 +1,22 @@
 /**
  * Telegram outbound markup parsing helpers
  * Zones: telegram outbound, assistant markup
- * Owns top-level assistant action comment extraction, attribute parsing, and markup stripping shared by voice and outbound delivery
+ * Owns delimiter-based assistant action comment extraction, attribute parsing, and markup stripping shared by voice and outbound delivery
  */
-export interface TelegramTopLevelHtmlComment {
+export interface TelegramHtmlComment {
     raw: string;
     content: string;
     start: number;
     end: number;
 }
-export declare function collectTopLevelHtmlComments(markdown: string): {
-    comments: TelegramTopLevelHtmlComment[];
+export declare function collectTelegramHtmlComments(markdown: string): {
+    comments: TelegramHtmlComment[];
     openCommentStart?: number;
 };
 export declare function replaceTelegramButtonFences(markdown: string, replace: (payload: string, closed: boolean) => string): string;
-export declare function replaceTopLevelHtmlComments(markdown: string, replacer: (comment: TelegramTopLevelHtmlComment) => string): string;
+export declare function replaceTelegramHtmlComments(markdown: string, replacer: (comment: TelegramHtmlComment) => string): string;
 export declare function parseTelegramButtonPayloadRows(source: string): Record<string, unknown>[][] | undefined;
-export declare function parseTelegramActionPayloadRows(comment: TelegramTopLevelHtmlComment, command: string): Record<string, unknown>[][] | undefined;
+export declare function parseTelegramActionPayloadRows(comment: TelegramHtmlComment, command: string): Record<string, unknown>[][] | undefined;
 export declare function stripTelegramCommentMarkupForPreview(markdown: string): string;
 export declare function stripTelegramCommentMarkupForDelivery(markdown: string): string;
 export interface TelegramVoiceReplyItem {