@llblab/pi-telegram 0.9.5 → 0.9.7

package/AGENTS.md

@@ -11,7 +11,7 @@
 
 ## 1. Concept
 
-`pi-telegram` is a π extension that turns a Telegram DM into a session-local frontend for π, including text/file forwarding, streaming previews, queued follow-ups, model controls, and outbound attachment delivery.
+`pi-telegram` is a Telegram Runtime Adapter for π: a session-local operator console that turns a private Telegram DM into a runtime surface for prompt intake, streaming previews, queue management, model/thinking/settings controls, inbound/outbound handler pipelines, voice/buttons, artifacts, and extension callback interop. Treat it as a Telegram membrane around π, not a narrow message pipe.
 
 ## 2. Identity & Naming Contract
 
@@ -28,7 +28,7 @@
 - `/tests/*.test.ts`: Domain-mirrored regression suites that follow the same flat naming as `/lib`
 - `/docs/README.md`: Documentation index for technical project docs
 - `/docs/architecture.md`: Runtime and subsystem overview for the bridge
-- `/README.md`: User-facing project entry point, install guide, and fork summary
+- `/README.md`: User-facing project entry point. Keep its rhythm as install → connect → use → core features → docs, with vivid examples that explain the runtime adapter/operator-console model without duplicating full docs.
 - `/AGENTS.md`: Durable engineering and runtime conventions
 - `/BACKLOG.md`: Canonical open work
 - `/CHANGELOG.md`: Completed delivery history
@@ -122,6 +122,8 @@ The canonical detailed ownership map lives in [`docs/architecture.md`](./docs/ar
 - When Telegram-visible behavior changes, sync `README.md` and the relevant `/docs` entry in the same pass
 - When durable runtime constraints or repeat bug patterns emerge, record them here instead of burying them in changelog prose
 - When fork identity changes, keep `README.md`, package metadata, and docs aligned so the published package does not point back at stale upstream coordinates
+- README positioning should emphasize `/start` as the primary Telegram operator menu and keep reaction shortcuts secondary. Reactions are useful queue affordances, but menu controls are the core CLI-to-Telegram bridge.
+- Document configuration knobs without UI in the root README when they affect bootstrap, networking, or transport limits; currently this includes token env bootstrap, Node env proxy mode, and inbound/outbound size limits.
 - Work only inside this repository during development tasks; updating the installed Pi extension checkout is a separate manual operator step, not part of normal in-repo implementation work
 
 ## 8. Integration Protocols

package/BACKLOG.md

@@ -2,9 +2,9 @@
 
 ## Open Work
 
-- Implement Telegram Extension Sections Platform for the 0.10.0 line.
+- [ ] Implement Telegram Extension Sections Platform for the 0.10.0 line.
   - Exit: Runtime registry, main-menu integration, `section:` callback routing, safe section context ports, diagnostics, docs, and at least one small demo/fixture prove ordinary pi extensions can add Telegram menu sections without owning a second poller.
-- Explore always-available outbound Telegram tools for queued artifacts and controls.
+- [ ] Explore always-available outbound Telegram tools for queued artifacts and controls.
   - Priority: Low.
   - Idea: Provide tools such as `telegram_attach_file` and `telegram_attach_button` that can be called outside an active Telegram turn, using the paired chat/session as the delivery target when safe.
   - Exit: Design note defines active-turn versus ambient delivery semantics, safety constraints, failure modes, and whether the current `telegram_attach` contract should stay turn-scoped or gain an ambient companion.

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.9.7: Bot API 10.0 Alignment
+
+- `[Dependencies]` Migrated peer dependencies and imports from `@mariozechner/*` to `@earendil-works/*` (`pi-agent-core`, `pi-ai`, `pi-coding-agent`). Impact: the extension now tracks the new `@earendil-works` package scope; transitive `@mariozechner` packages remain in the lockfile until their upstreams migrate.
+- `[Package]` Added `engines: { "node": ">=22.0.0" }` to document the supported Node expectation while keeping dev dependencies on `latest` for early-stage iteration. Impact: users know the minimum Node version without constraining the development dependency matrix prematurely.
+- `[Polling]` Added `"guest_message"` to `TELEGRAM_ALLOWED_UPDATES` so the bot receives guest-mode updates. Impact: without this, guest mentions are silently ignored by Telegram.
+- `[Telegram API]` Updated `sendMessageDraft` wrapper for Bot API 10.0 semantics: removed the empty-text guard, made `text` optional, and added optional `parse_mode`, `entities`, and `message_thread_id` parameters. Impact: preview can now show a "Thinking…" placeholder with empty text, and callers can pass rich formatting through `parse_mode` or `entities`.
+- `[Telegram API]` Added `answerGuestQuery` to the API runtime for Bot API 10.0 Guest Mode support. Impact: callers can reply to guest queries in chats where the bot is not a member. Uses `InlineQueryResultArticle` as the result payload per Bot API 10.0 contract.
+- `[Updates]` Extended inbound update routing to recognize `guest_message` updates. Added `getAuthorizedTelegramGuestMessage`, guest flow action, execution plan, runtime handler, and prompt enqueue support. Unauthorized guest queries receive an "Access denied." reply via `answerGuestQuery`. Guest turns customize the agent-end delivery to use `answerGuestQuery` instead of normal reply transport. Impact: the bridge can now receive and route guest-mode mentions in group chats while preserving the existing private-message authorization model.
+- `[Runtime]` Added typing-loop skip for guest turns (`chatId === 0`) to avoid spurious `sendChatAction` errors in the status bar.
+- `[Tests]` Added regression tests for empty-text draft delivery, undefined-text draft delivery, rich preview with `parse_mode` and `entities`, guest query answers, guest extraction, guest flow classification, guest execution plan, guest deny reply, and guest message routing through the runtime.
+- `[Preview]` Updated `sendDraft` interface in `lib/preview.ts` to accept optional text and formatting options, keeping the preview pipeline aligned with the new API wrapper.
+
+## 0.9.6: Runtime Adapter Positioning
+
+- `[Package]` Bumped package metadata to `0.9.6` and repositioned the package description from "Better Telegram DM bridge extension for π" to "Telegram Runtime Adapter for π". Impact: package metadata now reflects the runtime adapter/operator-console role rather than a narrow pipe metaphor.
+- `[Telegram API]` Introduced `TELEGRAM_API_BASE` for the Bot API endpoint and documented native HTTP/HTTPS proxy operation through `HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY`, and explicit `NODE_USE_ENV_PROXY=1` / `--use-env-proxy` enablement. Impact: users behind corporate proxies, local HTTP tunnels, or restricted networks get a zero-runtime-dependency proxy path without replacing native `fetch`; SOCKS5 remains outside the zero-dependency core.
+- `[Dependencies]` Refreshed the lockfile transitive dependency set so `npm audit` clears current `fast-uri` and `fast-xml-builder` advisories inherited through development peer installs. Impact: the full `npm run validate` pipeline passes without changing runtime dependencies.
+- `[README]` Restructured the user entrypoint around install → connect → use → core features → docs, then consolidated examples, terminology, proxy setup, `PI_CODING_AGENT_DIR`, and other environment-only configuration around the runtime-adapter/operator-console model. Impact: first-time users get a clearer path from installation to operation, while vivid examples and non-UI runtime knobs stay discoverable.
+- `[Context]` Promoted the runtime-adapter/operator-console README rhythm, `/start` menu emphasis, and environment-only configuration rule into `AGENTS.md`. Impact: future documentation edits preserve the same positioning and env-knob coverage instead of drifting back toward a narrow bridge metaphor.
+
 ## 0.9.5: Telegram Delivery Resilience Hotfix
 
 - `[Preview Delivery]` Preview flush failures from Telegram transport errors such as `fetch failed` / `ECONNRESET` are now caught and recorded as runtime diagnostics instead of escaping from the preview pipeline. Impact: transient Telegram connectivity failures no longer crash the extension during streamed preview edits.

package/README.md

@@ -2,24 +2,11 @@
 
 ![pi-telegram screenshot](screenshot.png)
 
-This repository is an actively maintained fork of [`badlogic/pi-telegram`](https://github.com/badlogic/pi-telegram). It started from upstream commit [`cb34008460b6c1ca036d92322f69d87f626be0fc`](https://github.com/badlogic/pi-telegram/commit/cb34008460b6c1ca036d92322f69d87f626be0fc) and has since diverged substantially.
+**Telegram Runtime Adapter for π.**
 
-## Start Here
+`pi-telegram` turns a private Telegram DM into a session-local operator console for π. It admits work, preserves context, streams readable replies, keeps busy sessions usable through queues, lets other extensions share one bot, and turns assistant-authored intent into native Telegram artifacts.
 
-- [Project Context](./AGENTS.md)
-- [Open Backlog](./BACKLOG.md)
-- [Changelog](./CHANGELOG.md)
-- [Documentation](./docs/README.md)
-
-## Key Features
-
-- **Telegram Controls**: `/start` opens the inline application menu with command help, available π prompt templates, status rows, model, thinking, and queue sections; the Status row reports `compacting` during Telegram `/compact`; `/stop`, `/abort`, `/next`, and `/continue` provide queue-clear, queue-preserve, force-next, and queued-resume semantics respectively; model-switch continuation turns still use the control lane when a restart needs to resume safely.
-- **Interactive UI**: Manage your session directly from Telegram. Inline buttons expose an application menu for switching models, choosing model pages from the pagination indicator, adjusting reasoning (thinking) levels, and inspecting or mutating the waiting queue; model scope/pagination controls stay at the top of the model menu, the Queue button shows the current item count, and command emoji are reused on matching controls such as model and thinking.
-- **In-flight Model Switching**: Change the active model mid-generation. The agent gracefully pauses, applies the new model, and restarts its response without losing context.
-- **Smart Message Queue**: Messages sent while the agent is busy are queued and previewed in the π status bar, and queued turns can be reprioritized or removed with Telegram reactions or the queue section of the inline application menu.
-- **Mobile-Optimized Rendering**: Tables and lists are formatted for narrow screens, table padding accounts for emoji grapheme and wide Unicode display width, and Telegram-originated runs prompt the assistant to prefer narrow table columns for phone readability. Markdown is correctly parsed and split to fit Telegram's limits without breaking HTML structures or code blocks, block spacing stays faithful to the original Markdown with readable heading separation, supported absolute links stay clickable, and unsupported link forms degrade safely.
-- **File Handling & Attachments**: Send images and files to the agent, transcribe or transform inbound text/media with configured inbound handlers, or ask π to generate and return artifacts. Inbound downloads and outbound attachments are size-limited by default, and outbound files are delivered automatically via the `telegram_attach` tool.
-- **Streaming Responses**: Closed Markdown blocks stream back as rich Telegram HTML while π is generating, and the still-growing tail stays readable until the final fully rendered reply lands.
+This repository is an actively maintained fork of [`badlogic/pi-telegram`](https://github.com/badlogic/pi-telegram). It started from upstream commit [`cb34008`](https://github.com/badlogic/pi-telegram/commit/cb34008460b6c1ca036d92322f69d87f626be0fc) and has since diverged substantially.
 
 ## Install
 
@@ -35,22 +22,16 @@ From git:
 pi install git:github.com/llblab/pi-telegram
 ```
 
-## Configure
-
-### Configuration Philosophy
-
-The extension intentionally keeps rich visual/TUI configuration minimal for now. Rich setup screens may arrive later, but they are not the main configuration surface yet.
+## Connect
 
-For advanced setup, ask an agent to read this `README.md` and the docs, then update `~/.pi/agent/telegram.json` for your workflow. Agents are good at small configuration changes, and this keeps the bridge simple while handler pipelines and operator preferences continue to evolve.
-
-### 1. Telegram Bot
+### 1. Create a Telegram bot
 
 1. Open [@BotFather](https://t.me/BotFather)
 2. Run `/newbot`
 3. Pick a name and username
 4. Copy the bot token
 
-### 2. Configure the extension in π
+### 2. Configure the bot token in π
 
 Start π, then run:
 
@@ -66,63 +47,97 @@ Paste your bot token when prompted. If a bot token is already saved in `~/.pi/ag
 /telegram-connect
 ```
 
-The bridge is session-local: only one π instance polls Telegram at a time. `/telegram-connect` records polling ownership in `~/.pi/agent/locks.json`; live ownership moves require confirmation, while `/new` and same-`cwd` process restarts resume automatically.
+The adapter is session-local: only one π instance polls Telegram at a time. `/telegram-connect` records polling ownership in `~/.pi/agent/locks.json`; live ownership moves require confirmation, while `/new` and same-`cwd` process restarts resume automatically.
 
-### 4. Pair your account from Telegram
+### 4. Pair your Telegram account
 
 1. Open the DM with your bot in Telegram
 2. Send `/start`
 
-The first user to message the bot becomes the exclusive owner of the bridge. The extension will only accept messages from this user.
+The first user to message the bot becomes the exclusive owner of the adapter. Messages from other users are ignored.
 
-## Usage
+### Environment-only configuration
 
-Once paired, simply chat with your bot in Telegram. All text, images, and files are forwarded to π.
+Most day-to-day controls live in the Telegram menu or π commands. A few important runtime knobs intentionally stay in environment variables because they affect bootstrap, networking, or transport limits before a menu can help:
 
-### Telegram Commands & Controls
+- **Bot token bootstrap**: `/telegram-setup` can prefill from `TELEGRAM_BOT_TOKEN`, `TELEGRAM_BOT_KEY`, `TELEGRAM_TOKEN`, or `TELEGRAM_KEY` when no token is already saved.
+- **HTTP/HTTPS proxy**: native `fetch` can use `HTTP_PROXY`, `HTTPS_PROXY`, and `NO_PROXY` when Node's environment proxy mode is enabled. Use `NODE_USE_ENV_PROXY=1` or start Node with `--use-env-proxy`. SOCKS5 is not part of the zero-dependency core. If you need it, run a local HTTP-to-SOCKS bridge or system tunnel and point `HTTP_PROXY` / `HTTPS_PROXY` at the HTTP endpoint.
+- **Agent data root / temp location**: `PI_CODING_AGENT_DIR` changes the base agent directory used for `telegram.json`, locks, generated outbound-handler artifacts, and Telegram temp files. When unset, the adapter uses `~/.pi/agent`, so inbound Telegram files land in `~/.pi/agent/tmp/telegram`.
+- **Inbound file limit**: `PI_TELEGRAM_INBOUND_FILE_MAX_BYTES` or `TELEGRAM_MAX_FILE_SIZE_BYTES` changes the default 50 MiB Telegram download limit.
+- **Outbound attachment limit**: `PI_TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES` or `TELEGRAM_MAX_ATTACHMENT_SIZE_BYTES` changes the default 50 MiB `telegram_attach` delivery limit.
 
-Use these inside the Telegram DM with your bot:
+## Use
 
-- **`/start`**: Pair the first Telegram user when needed, register bridge bot commands, and open the inline application menu with command help, available π prompt templates, status rows, and controls.
-- **`/compact`**: Start session compaction (only works when the session is idle).
-- **`/next`**: Dispatch the next queued turn (aborts π first if busy).
-- **`/continue`**: Enqueue a priority `continue` prompt. It waits like normal Telegram work when π is busy and can trigger prompt/skill handling that listens for `continue`.
-- **`/abort`**: Abort the active run without touching the queue.
-- **`/stop`**: Abort the active run and clear all waiting Telegram queue items.
+Once paired, chat with your bot in Telegram. Text, images, files, replies, edits, media groups, and configured handler output are forwarded into π as Telegram-originated turns.
+
+What it feels like:
 
-Prompt-template commands: π prompt templates are mapped to Telegram-safe aliases (`fix-tests.md` becomes `/fix_tests`) and shown as compact command-only rows between the built-in commands and status rows in `/start`. They are not registered in the Telegram bot command menu, keeping the bot menu focused on bridge controls. Sending `/template_name args` from Telegram expands the matching π prompt-template file and queues the expanded prompt like normal Telegram work.
+- Open `/start` and get a Telegram control panel for the running π session: status, prompt templates, model, thinking, settings, and queue.
+- Fire off three tasks while π is busy. They become visible queue items instead of terminal noise.
+- Open Queue from the menu, inspect waiting work, delete stale prompts, or move important work forward.
+- Switch models from Telegram mid-run; the adapter schedules a safe continuation instead of tearing state apart.
+- Send a voice note; an inbound handler transcribes it; π answers in the same chat.
+- Drop a screenshot and ask, "what is broken here?" The image payload reaches π with the local file context.
+- Ask for a generated file; when π calls `telegram_attach`, the artifact returns to Telegram with the next reply.
 
-Hidden compatibility shortcuts: `/help` and `/status` open the same main application menu, `/model` opens the model section, `/thinking` opens the thinking section, `/queue` opens the queue section, and `/settings` opens hidden bridge settings. Settings rows open detail submenus with Back plus green/black/yellow option controls such as On and Off for checkboxes. These shortcuts are intentionally not shown in the bot command menu.
+### Telegram controls
 
-Telegram command admission is explicit: `/compact`, `/queue`, `/settings`, `/stop`, `/abort`, `/next`, `/help`, `/start`, `/status`, `/model`, and `/thinking` execute immediately. `/continue` is a command shortcut that enqueues a priority Telegram prompt containing `continue`. Prompt-template commands expand before queueing and then follow normal prompt-queue rules. Synthetic model-switch continuation turns still enter the high-priority control lane so they can resume before normal queued prompts when π becomes safe to dispatch.
+Use these inside the Telegram DM with your bot. The main entrypoint is `/start`: it opens the operator menu and exposes many of the important agent controls that normally live in the CLI, adapted for Telegram.
 
-### Pi Commands
+- **`/start`**: Pair the first Telegram user when needed, register bot commands, and open the inline application menu with command help, prompt-template commands, status rows, model controls, thinking controls, settings, and queue controls.
+- **`/compact`**: Start session compaction when the session is idle.
+- **`/next`**: Dispatch the next queued turn, aborting π first if needed.
+- **`/continue`**: Enqueue a priority `continue` prompt.
+- **`/abort`**: Abort the active run without touching the queue.
+- **`/stop`**: Abort the active run and clear waiting Telegram queue items.
+
+Hidden compatibility shortcuts: `/help` and `/status` open the main application menu, `/model` opens model controls, `/thinking` opens reasoning controls, `/queue` opens queue controls, and `/settings` opens bridge settings.
+
+Prompt-template commands are discovered from π prompt templates, mapped to Telegram-safe aliases (`fix-tests.md` becomes `/fix_tests`), shown in `/start`, and expanded before queueing.
+
+### π commands
 
 Run these inside π, not Telegram:
 
 - **`/telegram-setup`**: Configure or update the Telegram bot token.
-- **`/telegram-status`**: Check bridge status, connection, polling, execution, queue, and recent redacted runtime/API failure events.
-- **`/telegram-settings`**: Open local bridge settings and toggle proactive push using the same `telegram.json` flag as the Telegram `/settings` menu.
-- **`/telegram-connect`**: Start polling Telegram updates in the current π session, acquire the singleton lock, or interactively move ownership here from another live instance.
+- **`/telegram-connect`**: Start polling Telegram updates in the current π session and acquire the singleton lock.
+- **`/telegram-settings`**: Open local settings and toggle proactive push using the same `telegram.json` flag as the Telegram `/settings` menu.
 - **`/telegram-disconnect`**: Stop polling in the current π session and release the singleton lock.
+- **`/telegram-status`**: Inspect adapter status, connection, polling, execution, queue, and recent redacted runtime/API failure events.
+
+### Files and artifacts
+
+Send files or images directly to the bot. Inbound downloads are saved under `<agent-dir>/tmp/telegram` and default to a 50 MiB limit. The agent dir is `~/.pi/agent` unless `PI_CODING_AGENT_DIR` overrides it.
+
+If you ask π for a generated file, π can call the `telegram_attach` tool and the adapter sends the file with the next Telegram reply. Outbound attachments also default to a 50 MiB limit. Environment variables for both limits are listed in [Environment-only configuration](#environment-only-configuration).
 
-### Queue, Reactions, and Media
+## Core features
 
-- If you send more Telegram messages while π is busy, they enter the default prompt queue and are processed in order.
-- Very long text messages that Telegram appears to split automatically are coalesced through a short conservative debounce and forwarded to π as one prompt when the first chunk is near Telegram's text limit, currently using a 3600-character threshold. Commands, bot messages, media groups, and normal short follow-ups are not coalesced.
-- `👍`, `⚡️`, `❤️`, `🕊`, and `🔥` move a waiting prompt into the priority prompt queue, behind control actions but ahead of default prompts. Removing the last priority reaction sends it back to its normal queue position, and adding a priority reaction again gives it a fresh priority position.
-- `👎`, `👻`, `💔`, `💩`, and `🗑` remove a waiting turn from the queue. Telegram Bot API does not expose ordinary DM message-deletion events through the polling path used here, so queue removal is bound to removal reactions.
-- Reactions apply to any waiting Telegram turn, including text, voice, files, images, and media groups. For media groups, a reaction on any message in the group applies to the whole queued turn.
-- If you edit a Telegram message while it is still waiting in the queue, the queued turn is updated instead of creating a duplicate prompt. Edits after a turn has already started may not affect the active run.
-- Telegram replies to earlier text or caption messages are forwarded as `[reply]` context for normal prompts, while slash commands still parse from the new message text only.
-- Inbound images, albums, and files are saved to `~/.pi/agent/tmp/telegram`. Unhandled local file paths are included in the prompt, handled attachment output is injected into the prompt text, and inbound images are forwarded to π as image inputs. Inbound downloads default to a 50 MiB limit and can be adjusted with `PI_TELEGRAM_INBOUND_FILE_MAX_BYTES` or `TELEGRAM_MAX_FILE_SIZE_BYTES`.
-- Queue reactions depend on Telegram delivering `message_reaction` updates for your bot and chat type.
+### Operator menu and controls
 
-### Inbound Handlers
+The inline application menu is the primary operator surface. It exposes status, prompt-template commands, model selection, thinking level selection, settings, and queue inspection/mutation: a Telegram-shaped subset of the important handles normally available from the CLI. A typical control loop stays inside Telegram: open `/start`, inspect status, jump into Queue, delete stale work, switch model, return to the main menu, and keep the π session running without touching the terminal.
 
-`telegram.json` can set `proactivePush: true` to send successful local non-Telegram final replies to the paired Telegram chat when no Telegram turn is active. Local prompt text is not sent because the bot does not own or mirror terminal user messages. The mode is off by default, can be toggled from the hidden `/settings` menu, persists across contexts until explicitly disabled or removed from config, is gated by the current Telegram lock owner, and skips aborted or failed turns.
+### Queue runtime
 
-`telegram.json` can define ordered `inboundHandlers` for Telegram → π preprocessing such as text translation, voice transcription, OCR, or PDF extraction. Matching handlers run before the Telegram turn enters the π queue. If a matching media/file handler fails, the next matching handler is tried as a fallback. Legacy `attachmentHandlers` still work as a deprecated compatibility alias and are appended after `inboundHandlers`.
+Messages sent while π is busy enter the prompt queue and are processed in order. Control actions and model-switch continuation turns use higher-priority lanes so operational commands can resume before normal prompts.
+
+The menu is the primary way to inspect and mutate the queue. Reactions are an extra shortcut when Telegram delivers `message_reaction` updates for the chat: `👍`, `⚡️`, `❤️`, `🕊`, and `🔥` promote waiting work; `👎`, `👻`, `💔`, `💩`, and `🗑` remove it. The same rules apply to text, voice, files, images, and media groups.
+
+### Streaming and Telegram HTML rendering
+
+Closed Markdown blocks stream back as rich Telegram HTML while π is generating. The growing tail stays conservative until the final rendered reply lands. Long replies are split below Telegram limits without intentionally breaking HTML structures, links, code blocks, blockquotes, lists, or code fences.
+
+Rendering is phone-aware: tables and lists stay narrow, table padding accounts for emoji graphemes and wide Unicode display width, unsupported link forms degrade safely, and block spacing stays faithful to the original Markdown.
+
+### Media, replies, edits, and split text
+
+Telegram replies to earlier text or caption messages are forwarded as `[reply]` context for normal prompts, while slash commands still parse from the new message text only. If a Telegram message is edited while still waiting in the queue, the queued turn is updated instead of duplicated. Very long text messages that Telegram appears to split automatically are coalesced through a conservative debounce when the first chunk is near Telegram's text limit.
+
+### Inbound handlers
+
+`telegram.json` can define ordered `inboundHandlers` for Telegram → π preprocessing: text translation, voice transcription, OCR, PDF extraction, or any command-template pipeline. Matching handlers run before the turn enters the queue; failed handlers record diagnostics and fall back safely. Legacy `attachmentHandlers` still work as a deprecated compatibility alias appended after `inboundHandlers`.
+
+A practical voice setup is simple: Telegram `.ogg` arrives, STT runs locally or through your chosen command, stdout is injected as `[outputs]`, and π receives the result as usable prompt context.
 
 ```json
 {
@@ -149,19 +164,9 @@ Run these inside π, not Telegram:
 }
 ```
 
-Matching supports optional `mime`, `type`, or `match`; `mime` can be used without `type`, and wildcards like `audio/*` or `text/*` are accepted. Raw Telegram text can match `type: "text"`, `mime: "text/plain"`, or `mime: "text/*"`; it is passed on stdin and as `{text}`, and non-empty stdout replaces the prompt text. Media/file handlers receive `{file}`, `{mime}`, and `{type}`; local attachments stay in the prompt under `[attachments] <directory>` with relative file entries, and successful media/file handler stdout is added under `[outputs]`. Attached `text/plain`/`text/*` files have a built-in fail-open reader that injects UTF-8 content into `[outputs]` when no configured handler produced output. Failed handlers record diagnostics and fall back safely. The portable command-template contract is documented in [`docs/command-templates.md`](./docs/command-templates.md); Telegram-specific inbound config is documented in [`docs/inbound-handlers.md`](./docs/inbound-handlers.md).
-
-### Requesting Files
-
-If you ask π for a file or generated artifact (e.g., _"generate a shell script and attach it"_), π can call the `telegram_attach` tool, and the extension will send the file alongside its next Telegram reply. `telegram_attach` is the only π tool registered by `pi-telegram`; use it for ordinary files, not for Telegram-native voice or buttons. Outbound attachments default to a 50 MiB limit and can be adjusted with `PI_TELEGRAM_OUTBOUND_ATTACHMENT_MAX_BYTES` or `TELEGRAM_MAX_ATTACHMENT_SIZE_BYTES`.
-
-### Assistant-Authored Outbound Actions
-
-Assistant replies can include hidden outbound blocks. `telegram_voice` and `telegram_button` are not π tools; they are assistant-authored HTML comments that the bridge removes from Telegram text and handles after `agent_end`. Recognized blocks must start at column zero on a top-level line outside fenced code, quotes, and lists, so documentation examples remain literal. The agent writes normal Markdown; the extension owns voice generation, button markup, callback routing, and delivery.
-
-#### Voice
+### Outbound handlers, voice, and buttons
 
-Voice blocks synthesize their text and upload it as a native Telegram `sendVoice` OGG/Opus message. Use body form for multiline text, `text="..."` for explicit one-line text with optional attributes, and the colon shorthand for a one-line voice with no attributes. The spoken text may be a concise companion summary, but it does not have to follow that format; write what you want spoken and keep it TTS-friendly:
+Assistant replies can include hidden outbound blocks. `telegram_voice` and `telegram_button` are not π tools; they are assistant-authored HTML comments that the adapter removes from Telegram text and handles after `agent_end`. Recognized blocks must start at column zero on a top-level line outside fenced code, quotes, and lists.
 
 ```md
 Full technical answer stays readable as text.
@@ -170,27 +175,14 @@ Full technical answer stays readable as text.
 Text to synthesize as a Telegram voice message.
 -->
 
-<!-- telegram_voice lang=ru rate=+30% text="Short spoken companion summary." -->
-
-<!-- telegram_voice: Short spoken companion summary. -->
-```
-
-Outbound `type: "text"` handlers can transform final text/Markdown before Telegram rendering and delivery, using stdin and `{text}` as input and non-empty stdout as replacement text. They are a good fit for machine translation, tone normalization, redaction, glossary expansion, or any other final text rewrite that should happen outside the agent prompt. The transform also applies when the bridge finalizes an already streamed rich preview, so Telegram may briefly show the pre-transform preview before the final edited message lands. Inline button labels are transformed too, while callback data and prompts stay unchanged.
-
-```json
-{
-  "outboundHandlers": [
-    {
-      "type": "text",
-      "template": "/path/to/translate --lang {lang=ru} --text {text}"
-    }
-  ]
-}
+<!-- telegram_button label="Show risks"
+List the main risks first.
+-->
 ```
 
-Outbound voice is disabled unless a matching `outboundHandlers[]` entry is configured. Multiple `telegram_voice` blocks in one reply are synthesized and sent independently, preserving each block's attributes. The bridge uses the same [command-template contract](./docs/command-templates.md) as inbound handlers: split the template into args, substitute placeholders, execute without a shell, and use stdout as the result channel for a single template.
+Outbound `type: "text"` handlers can transform final text/Markdown before Telegram rendering and delivery. Outbound `type: "voice"` handlers can translate, synthesize, and convert hidden `telegram_voice` text into Telegram-native OGG/Opus voice through the same command-template contract used by inbound handlers.
 
-A composed voice setup can translate the hidden `telegram_voice` text, synthesize it, and convert MP3 to Telegram-native OGG/Opus in one pipeline. The bridge provides `{text}`, `{mp3}`, and `{ogg}` to every step; top-level `args`/`defaults` apply to all steps unless a step defines private values, the default command timeout applies automatically, and each step's stdout is passed to the next step's stdin by default. Use `"output": "ogg"` when the artifact path should come from the generated `{ogg}` value instead of final stdout:
+A composed voice pipeline can translate, synthesize, and convert in one pass:
 
 ```json
 {
@@ -208,43 +200,36 @@ A composed voice setup can translate the hidden `telegram_voice` text, synthesiz
 }
 ```
 
-#### Buttons
+The agent writes intent; the adapter owns transport. Text remains readable, voice becomes native Telegram media, and buttons route back as queued prompts.
 
-Button blocks attach inline quick replies to the final text. Use one independent `telegram_button` block per action. If the prompt should equal the label, use the colon shorthand. If the prompt differs, use the inline `prompt="..."` attribute for one-line prompts or the body form for multiline prompts:
+### Extension interop
 
-```md
-I can continue.
+Unknown inline-button callbacks are forwarded to π as `[callback] <data>` when they do not belong to pi-telegram, so other extensions can namespace and handle Telegram buttons without polling the bot themselves. Layered extensions that need synchronous update handling can register a runtime interceptor on the shared update registry.
 
-<!-- telegram_button label="Show risks"
-List the main risks first.
--->
-
-<!-- telegram_button label=Continue prompt="Continue with the current plan." -->
+### Proactive push
 
-<!-- telegram_button: OK -->
-```
+`telegram.json` can set `proactivePush: true` to send successful local non-Telegram final replies to the paired Telegram chat when no Telegram turn is active. Local prompt text is not mirrored because the bot does not own terminal user messages. The mode is off by default and can be toggled from settings.
 
-Button prompts are routed back into the normal Telegram queue as prompt turns. Keep the opening comment unclosed until the body-ending `-->` for body-form buttons. Closed heads must use `prompt="..."` or the colon shorthand to create a button. Unknown inline-button callbacks that do not belong to pi-telegram are forwarded to π as `[callback] <data>` so other extensions can namespace and handle their own Telegram buttons without polling the bot themselves; see the [Callback Namespace Standard](./docs/callback-namespaces.md). Layered extensions that need to react to Telegram updates synchronously inside their own runtime (for example, to resolve a blocking-tool approval Promise the moment a callback arrives) can register a runtime interceptor on the shared update registry; see [External Handlers](./docs/external-handlers.md). Outbound handler details are documented in [`docs/outbound-handlers.md`](./docs/outbound-handlers.md).
+## Docs
 
-## Streaming
-
-The extension streams assistant previews back to Telegram while π is generating.
-
-Rich previews are sent through editable messages because Telegram drafts are text-only. Closed top-level Markdown blocks can appear with formatting before the answer finishes, while the still-growing tail remains conservative and readable until the preview is replaced with the fully rendered Telegram HTML reply. Editable preview messages are also attached as replies to the source Telegram prompt when possible.
-
-## Status bar
-
-The π status bar shows the current bridge state plus queued Telegram turns as compact previews. Busy labels distinguish states such as `active`, `dispatching`, `queued`, `tool running`, `model`, and `compacting`. Telegram prompt guidance asks agents to keep tables, dense list items, and compact text blocks within about 37 visible cells when possible so mobile replies stay readable.
-
-```text
-telegram active +3
-```
+- [Project Context](./AGENTS.md): durable engineering conventions and architecture constraints.
+- [Open Backlog](./BACKLOG.md): planned work and known follow-ups.
+- [Changelog](./CHANGELOG.md): completed delivery history.
+- [Documentation Index](./docs/README.md): technical docs hub.
+- [Architecture](./docs/architecture.md): runtime and subsystem overview.
+- [Inbound Handlers](./docs/inbound-handlers.md): Telegram → π preprocessing.
+- [Outbound Handlers](./docs/outbound-handlers.md): final text, voice, and artifact pipelines.
+- [Command Templates](./docs/command-templates.md): portable command-template contract.
+- [Callback Namespaces](./docs/callback-namespaces.md): callback interop for layered extensions.
+- [External Handlers](./docs/external-handlers.md): shared update interception.
+- [Extension Sections Draft](./docs/extension-sections.md): future Telegram extension sections platform.
+- [Locks](./docs/locks.md): singleton polling ownership.
 
 ## Notes
 
-- Replies to Telegram prompts are sent as Telegram replies to the source message when possible; if the source message is unavailable, delivery falls back to a normal message
-- Long replies are split below Telegram's 4096 character limit without intentionally breaking Telegram HTML formatting; only the first split message is attached as a Telegram reply to the source prompt
-- Temporary inbound Telegram files are cleaned up on later session starts
+- The extension intentionally keeps rich visual/TUI configuration minimal for now. For advanced setup, ask an agent to read this README and the docs, then update `~/.pi/agent/telegram.json` for your workflow.
+- Replies to Telegram prompts are sent as Telegram replies to the source message when possible; if the source message is unavailable, delivery falls back to a normal message.
+- Temporary inbound Telegram files are cleaned up on later session starts.
 
 ## License
 

package/docs/architecture.md

@@ -24,7 +24,7 @@ Naming rule: because the repository already scopes this codebase to Telegram, ex
 Current runtime areas use these ownership boundaries:
 
 - `index.ts`: single composition root for live π/Telegram ports, session state, API-bound transport adapters, and status updates.
-- `api`: Bot API transport shapes/helpers, retries, file download, temp-dir lifecycle, inbound limits, chat actions, lazy bot-token clients, and runtime error recording.
+- `api`: Bot API transport shapes/helpers, retries, file download, temp-dir lifecycle, inbound limits, chat actions, lazy bot-token clients, runtime error recording, and the `TELEGRAM_API_BASE` constant for the Bot API endpoint.
 - `config` / `setup`: persisted bot/session pairing state, authorization, first-user pairing, token prompting, env fallback, validation, and config persistence.
 - `locks` / `polling`: singleton `locks.json` ownership, takeover/restart semantics, long-poll controller state, update offset persistence, and poll-loop runtime wiring.
 - `updates` / `routing`: update classification/execution planning, paired authorization, reactions, edits, callbacks, and inbound route composition.

package/docs/extension-sections.md

@@ -114,7 +114,7 @@ unregister();
 Sections are registered by normal pi extensions:
 
 ```ts
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerTelegramSection } from "@llblab/pi-telegram/lib/extension-sections.ts";
 
 export default function (pi: ExtensionAPI) {

package/index.ts

@@ -148,6 +148,7 @@ export default function (pi: Pi.ExtensionAPI) {
     downloadFile: downloadTelegramBridgeFile,
     editMessageText: editTelegramMessageText,
     answerCallbackQuery,
+    answerGuestQuery,
     prepareTempDir,
   } = Api.createDefaultTelegramBridgeApiRuntime({
     getBotToken: configStore.getBotToken,
@@ -333,6 +334,7 @@ export default function (pi: Pi.ExtensionAPI) {
     updateStatus,
     dispatchNextQueuedTelegramTurn,
     answerCallbackQuery,
+    answerGuestQuery,
     sendTextReply,
     setMyCommands,
     getCommands,
@@ -494,6 +496,7 @@ export default function (pi: Pi.ExtensionAPI) {
     sendMarkdownReply,
     sendTextReply,
     sendQueuedAttachments: queuedAttachmentSender,
+    answerGuestQuery,
     planOutboundReply: outboundReplyPlanner,
     sendOutboundReplyArtifacts: outboundReplyArtifactSender,
     isCurrentOwner: lockOwnershipGuard.ownsContext,

package/lib/api.ts

@@ -12,6 +12,8 @@ import { join, resolve } from "node:path";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 
+export const TELEGRAM_API_BASE = "https://api.telegram.org";
+
 export const TELEGRAM_FILE_MAX_BYTES = 50 * 1024 * 1024;
 
 export function getTelegramInboundFileByteLimitFromEnv(
@@ -149,12 +151,25 @@ export interface TelegramMessageReactionUpdated {
   date: number;
 }
 
+export interface TelegramGuestMessage {
+  message_id: number;
+  from?: TelegramUser;
+  chat: TelegramChat;
+  date: number;
+  text?: string;
+  caption?: string;
+  guest_query_id: string;
+  guest_bot_caller_user?: TelegramUser;
+  guest_bot_caller_chat?: TelegramChat;
+}
+
 export interface TelegramUpdate {
   update_id: number;
   message?: TelegramMessage;
   edited_message?: TelegramMessage;
   callback_query?: TelegramCallbackQuery;
   message_reaction?: TelegramMessageReactionUpdated;
+  guest_message?: TelegramGuestMessage;
   deleted_business_messages?: { message_ids?: unknown };
 }
 
@@ -182,6 +197,15 @@ export type TelegramEditMessageTextBody = Record<string, unknown> & {
   parse_mode?: "HTML";
 };
 
+export type TelegramSendMessageDraftBody = Record<string, unknown> & {
+  chat_id: number;
+  draft_id: number;
+  text?: string;
+  parse_mode?: string;
+  entities?: unknown[];
+  message_thread_id?: number;
+};
+
 interface TelegramApiResponse<T> {
   ok: boolean;
   result?: T;
@@ -231,6 +255,7 @@ export interface TelegramApiClient {
     callbackQueryId: string,
     text?: string,
   ) => Promise<void>;
+  answerGuestQuery?: (guestQueryId: string, text?: string) => Promise<void>;
 }
 
 export interface TelegramBridgeApiRuntimeDeps {
@@ -273,7 +298,12 @@ export interface TelegramBridgeApiRuntime {
   sendMessageDraft: (
     chatId: number,
     draftId: number,
-    text: string,
+    text?: string,
+    options?: {
+      parse_mode?: string;
+      entities?: unknown[];
+      message_thread_id?: number;
+    },
   ) => Promise<boolean>;
   sendMessage: (body: TelegramSendMessageBody) => Promise<TelegramSentMessage>;
   editMessageText: (
@@ -283,6 +313,7 @@ export interface TelegramBridgeApiRuntime {
     callbackQueryId: string,
     text?: string,
   ) => Promise<void>;
+  answerGuestQuery: (guestQueryId: string, text?: string) => Promise<void>;
   prepareTempDir: () => Promise<number>;
 }
 
@@ -513,7 +544,7 @@ export async function callTelegram<TResponse>(
   return callTelegramWithRetry(
     method,
     async () =>
-      fetch(`https://api.telegram.org/bot${configuredBotToken}/${method}`, {
+      fetch(`${TELEGRAM_API_BASE}/bot${configuredBotToken}/${method}`, {
         method: "POST",
         headers: { "content-type": "application/json" },
         body: JSON.stringify(body),
@@ -532,9 +563,7 @@ export async function fetchTelegramBotIdentity(
   botToken: string,
   fetchImpl: typeof fetch = fetch,
 ): Promise<TelegramBotIdentityResponse> {
-  const response = await fetchImpl(
-    `https://api.telegram.org/bot${botToken}/getMe`,
-  );
+  const response = await fetchImpl(`${TELEGRAM_API_BASE}/bot${botToken}/getMe`);
   return response.json() as Promise<TelegramBotIdentityResponse>;
 }
 
@@ -557,14 +586,11 @@ export async function callTelegramMultipart<TResponse>(
         form.set(key, value);
       }
       form.set(fileField, fileBlob, fileName);
-      return fetch(
-        `https://api.telegram.org/bot${configuredBotToken}/${method}`,
-        {
-          method: "POST",
-          body: form,
-          signal: options?.signal,
-        },
-      );
+      return fetch(`${TELEGRAM_API_BASE}/bot${configuredBotToken}/${method}`, {
+        method: "POST",
+        body: form,
+        signal: options?.signal,
+      });
     },
     options,
   );
@@ -591,7 +617,7 @@ export async function downloadTelegramFile(
     `${randomUUID()}-${sanitizeFileName(suggestedName)}`,
   );
   const response = await fetch(
-    `https://api.telegram.org/file/bot${configuredBotToken}/${file.file_path}`,
+    `${TELEGRAM_API_BASE}/file/bot${configuredBotToken}/${file.file_path}`,
     { signal: options?.signal },
   );
   if (!response.ok) {
@@ -730,13 +756,18 @@ export function createTelegramBridgeApiRuntime(
         }),
       "typing",
     ),
-    sendMessageDraft: (chatId, draftId, text) => {
-      if (text.length === 0) return Promise.resolve(false);
-      return callRecorded<boolean>("sendMessageDraft", {
+    sendMessageDraft: (chatId, draftId, text, options) => {
+      const body: Record<string, unknown> = {
         chat_id: chatId,
         draft_id: draftId,
-        text,
-      });
+      };
+      if (text !== undefined) body.text = text;
+      if (options?.parse_mode !== undefined)
+        body.parse_mode = options.parse_mode;
+      if (options?.entities !== undefined) body.entities = options.entities;
+      if (options?.message_thread_id !== undefined)
+        body.message_thread_id = options.message_thread_id;
+      return callRecorded<boolean>("sendMessageDraft", body);
     },
     sendMessage: (body) =>
       callRecorded<TelegramSentMessage>("sendMessage", body),
@@ -753,6 +784,18 @@ export function createTelegramBridgeApiRuntime(
     answerCallbackQuery: (callbackQueryId, text) => {
       return deps.client.answerCallbackQuery(callbackQueryId, text);
     },
+    answerGuestQuery: (guestQueryId, text) => {
+      const body: Record<string, unknown> = { guest_query_id: guestQueryId };
+      if (text !== undefined) {
+        body.result = {
+          type: "article",
+          id: "1",
+          title: text.length > 64 ? text.slice(0, 61) + "..." : text,
+          input_message_content: { message_text: text },
+        };
+      }
+      return callRecorded<void>("answerGuestQuery", body);
+    },
     prepareTempDir: () =>
       prepareTelegramTempDir(deps.tempDir, deps.tempFileMaxAgeMs),
   };

package/lib/pi.ts

@@ -15,7 +15,7 @@ import {
   type SessionStartEvent,
   type SlashCommandInfo,
   SettingsManager,
-} from "@mariozechner/pi-coding-agent";
+} from "@earendil-works/pi-coding-agent";
 
 export type {
   AgentEndEvent,

package/lib/polling.ts

@@ -20,6 +20,7 @@ export const TELEGRAM_ALLOWED_UPDATES = [
   "edited_message",
   "callback_query",
   "message_reaction",
+  "guest_message",
 ] as const;
 
 export function buildTelegramInitialSyncRequest(): {

package/lib/preview.ts

@@ -61,7 +61,12 @@ export interface TelegramPreviewRuntimeDeps<
   sendDraft: (
     chatId: number,
     draftId: number,
-    text: string,
+    text?: string,
+    options?: {
+      parse_mode?: string;
+      entities?: unknown[];
+      message_thread_id?: number;
+    },
   ) => Promise<unknown>;
   sendMessage: (
     chatId: number,
@@ -158,7 +163,12 @@ export interface TelegramPreviewControllerDeps<
   sendDraft: (
     chatId: number,
     draftId: number,
-    text: string,
+    text?: string,
+    options?: {
+      parse_mode?: string;
+      entities?: unknown[];
+      message_thread_id?: number;
+    },
   ) => Promise<unknown>;
   sendMessage: (
     chatId: number,

package/lib/queue.ts

@@ -66,6 +66,7 @@ export interface TelegramQueueItemBase {
   kind: TelegramQueueItemKind;
   chatId: number;
   replyToMessageId: number;
+  guestQueryId?: string;
   queueOrder: number;
   queueLane: TelegramQueueLane;
   laneOrder: number;
@@ -113,6 +114,7 @@ export interface TelegramActiveTurnStore<
   clear: () => void;
   getChatId: () => number | undefined;
   getReplyToMessageId: () => number | undefined;
+  getGuestQueryId: () => string | undefined;
   getSourceMessageIds: () => number[] | undefined;
 }
 
@@ -203,6 +205,7 @@ export function createTelegramActiveTurnStore<
     },
     getChatId: () => activeTurn?.chatId,
     getReplyToMessageId: () => activeTurn?.replyToMessageId,
+    getGuestQueryId: () => activeTurn?.guestQueryId,
     getSourceMessageIds: () => activeTurn?.sourceMessageIds,
   };
 }
@@ -785,6 +788,7 @@ export interface TelegramAgentEndRuntimeDeps<
     text: string,
   ) => Promise<unknown>;
   sendQueuedAttachments: (turn: TTurn) => Promise<void>;
+  answerGuestQuery?: (guestQueryId: string, text?: string) => Promise<void>;
   planOutboundReply?: (
     markdown: string,
   ) => TelegramAgentEndOutboundReplyPlan<TReplyMarkup>;
@@ -832,6 +836,7 @@ export interface TelegramAgentEndHookRuntimeDeps<
   >["sendMarkdownReply"];
   sendTextReply: TelegramAgentEndRuntimeDeps<TTurn>["sendTextReply"];
   sendQueuedAttachments: (turn: TTurn) => Promise<void>;
+  answerGuestQuery?: TelegramAgentEndRuntimeDeps<TTurn>["answerGuestQuery"];
   planOutboundReply?: TelegramAgentEndRuntimeDeps<
     TTurn,
     TReplyMarkup
@@ -952,6 +957,7 @@ export function createTelegramAgentEndHook<
       sendMarkdownReply: deps.sendMarkdownReply,
       sendTextReply: deps.sendTextReply,
       sendQueuedAttachments: deps.sendQueuedAttachments,
+      answerGuestQuery: deps.answerGuestQuery,
       planOutboundReply: deps.planOutboundReply,
       sendOutboundReplyArtifacts: deps.sendOutboundReplyArtifacts,
       getDefaultChatId: deps.getDefaultChatId,
@@ -1007,6 +1013,25 @@ export async function handleTelegramAgentEndRuntime<
     if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
     return;
   }
+  if (turn.guestQueryId) {
+    if (deps.isCurrentOwner && !deps.isCurrentOwner()) {
+      if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
+      return;
+    }
+    if (assistant.errorMessage) {
+      await deps.answerGuestQuery?.(
+        turn.guestQueryId,
+        "Telegram bridge: π failed while processing the request.",
+      );
+      if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
+      return;
+    }
+    if (finalText) {
+      await deps.answerGuestQuery?.(turn.guestQueryId, finalText);
+    }
+    if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
+    return;
+  }
   if (endPlan.shouldClearPreview) {
     await deps.clearPreview(turn.chatId);
   }

package/lib/routing.ts

@@ -17,6 +17,7 @@ import type { TelegramBridgeRuntime } from "./runtime.ts";
 import * as TextGroups from "./text-groups.ts";
 import * as Turns from "./turns.ts";
 import * as Updates from "./updates.ts";
+import type { TelegramUser } from "./updates.ts";
 
 export type TelegramRoutedMessage = Updates.TelegramUpdateMessage &
   Media.TelegramMediaMessage &
@@ -80,6 +81,7 @@ export interface TelegramInboundRouteRuntimeDeps<
     callbackQueryId: string,
     text?: string,
   ) => Promise<void>;
+  answerGuestQuery: (guestQueryId: string, text?: string) => Promise<void>;
   sendTextReply: (
     chatId: number,
     replyToMessageId: number,
@@ -364,6 +366,33 @@ export function createTelegramInboundRouteRuntime<
     ...deps.telegramQueueStore,
     updateStatus: deps.updateStatus,
   });
+  const handleAuthorizedTelegramGuestMessage = async (
+    guestMessage: Updates.TelegramGuestMessage & { from: TelegramUser },
+    ctx: TContext,
+  ): Promise<void> => {
+    const text = guestMessage.text ?? "";
+    const order = deps.bridgeRuntime.queue.allocateItemOrder();
+    const guestTurn: Queue.PendingTelegramTurn = {
+      kind: "prompt",
+      chatId: 0,
+      replyToMessageId: 0,
+      guestQueryId: guestMessage.guest_query_id,
+      sourceMessageIds: [],
+      queueOrder: order,
+      queueLane: "default",
+      laneOrder: order,
+      queuedAttachments: [],
+      content: [{ type: "text", text }],
+      historyText: text,
+      statusSummary: Turns.truncateTelegramQueueSummary(text),
+    };
+    const items = deps.telegramQueueStore.getQueuedItems();
+    deps.telegramQueueStore.setQueuedItems(
+      Queue.appendTelegramQueueItem(items, guestTurn),
+    );
+    deps.updateStatus(ctx);
+    deps.dispatchNextQueuedTelegramTurn(ctx);
+  };
   return Updates.createTelegramPairedUpdateRuntime<TContext, TUpdate>({
     getAllowedUserId: deps.configStore.getAllowedUserId,
     setAllowedUserId: deps.configStore.setAllowedUserId,
@@ -377,9 +406,11 @@ export function createTelegramInboundRouteRuntime<
     prioritizeQueuedTelegramTurnByMessageId:
       deps.queueMutationRuntime.prioritizeByMessageId,
     answerCallbackQuery: deps.answerCallbackQuery,
+    answerGuestQuery: deps.answerGuestQuery,
     handleAuthorizedTelegramCallbackQuery: callbackHandler,
     sendTextReply: deps.sendTextReply,
     handleAuthorizedTelegramMessage: textDispatch.handleMessage,
     handleAuthorizedTelegramEditedMessage: editRuntime.updateFromEditedMessage,
+    handleAuthorizedTelegramGuestMessage,
   });
 }

package/lib/runtime.ts

@@ -365,7 +365,8 @@ export function startTelegramTypingLoop(
   state: TelegramBridgeRuntimeState,
   deps: TelegramTypingLoopDeps,
 ): boolean {
-  if (state.typingInterval || deps.chatId === undefined) return false;
+  if (state.typingInterval || deps.chatId === undefined || deps.chatId === 0)
+    return false;
   const sendTyping = (): void => {
     void deps.sendTypingAction(deps.chatId as number);
   };

package/lib/updates.ts

@@ -130,10 +130,19 @@ export interface TelegramCallbackQuery {
   message?: TelegramUpdateMessage;
 }
 
+export interface TelegramGuestMessage {
+  guest_query_id: string;
+  chat: TelegramChat;
+  from?: TelegramUser;
+  message_id?: number;
+  text?: string;
+}
+
 export interface TelegramUpdateRouting {
   message?: TelegramUpdateMessage;
   edited_message?: TelegramUpdateMessage;
   callback_query?: TelegramCallbackQuery;
+  guest_message?: TelegramGuestMessage;
 }
 
 export function getAuthorizedTelegramCallbackQuery(
@@ -178,6 +187,16 @@ export function getAuthorizedTelegramEditedMessage(
   return message;
 }
 
+export function getAuthorizedTelegramGuestMessage(
+  update: TelegramUpdateRouting,
+): TelegramGuestMessage | undefined {
+  const guestMessage = update.guest_message;
+  if (!guestMessage || !guestMessage.from || guestMessage.from.is_bot) {
+    return undefined;
+  }
+  return guestMessage;
+}
+
 // --- Flow ---
 
 export interface TelegramMessageReactionUpdated {
@@ -198,6 +217,7 @@ export type TelegramUpdateFlowAction<
     TelegramMessageReactionUpdated,
   TCallbackQuery extends TelegramCallbackQuery = TelegramCallbackQuery,
   TMessage extends TelegramUpdateMessage = TelegramUpdateMessage,
+  TGuestMessage extends TelegramGuestMessage = TelegramGuestMessage,
 > =
   | { kind: "ignore" }
   | { kind: "deleted"; messageIds: number[] }
@@ -216,6 +236,11 @@ export type TelegramUpdateFlowAction<
       kind: "edited-message";
       message: TMessage & { from: TelegramUser };
       authorization: TelegramAuthorizationState;
+    }
+  | {
+      kind: "guest";
+      guestMessage: TGuestMessage & { from: TelegramUser };
+      authorization: TelegramAuthorizationState;
     };
 
 export function buildTelegramUpdateFlowAction<
@@ -226,7 +251,8 @@ export function buildTelegramUpdateFlowAction<
 ): TelegramUpdateFlowAction<
   NonNullable<TUpdate["message_reaction"]>,
   NonNullable<TUpdate["callback_query"]>,
-  NonNullable<TUpdate["message"] | TUpdate["edited_message"]>
+  NonNullable<TUpdate["message"] | TUpdate["edited_message"]>,
+  NonNullable<TUpdate["guest_message"]>
 > {
   const deletedMessageIds = extractDeletedTelegramMessageIds(update);
   if (deletedMessageIds.length > 0) {
@@ -272,6 +298,19 @@ export function buildTelegramUpdateFlowAction<
       ),
     };
   }
+  const guestMessage = getAuthorizedTelegramGuestMessage(update);
+  if (guestMessage?.from) {
+    return {
+      kind: "guest",
+      guestMessage: guestMessage as NonNullable<TUpdate["guest_message"]> & {
+        from: TelegramUser;
+      },
+      authorization: getTelegramAuthorizationState(
+        guestMessage.from.id,
+        allowedUserId,
+      ),
+    };
+  }
   return { kind: "ignore" };
 }
 
@@ -282,6 +321,7 @@ export type TelegramUpdateExecutionPlan<
     TelegramMessageReactionUpdated,
   TCallbackQuery extends TelegramCallbackQuery = TelegramCallbackQuery,
   TMessage extends TelegramUpdateMessage = TelegramUpdateMessage,
+  TGuestMessage extends TelegramGuestMessage = TelegramGuestMessage,
 > =
   | { kind: "ignore" }
   | { kind: "deleted"; messageIds: number[] }
@@ -307,15 +347,31 @@ export type TelegramUpdateExecutionPlan<
       message: TMessage & { from: TelegramUser };
       shouldPair: boolean;
       shouldDeny: boolean;
+    }
+  | {
+      kind: "guest";
+      guestMessage: TGuestMessage & { from: TelegramUser };
+      shouldDeny: boolean;
     };
 
 export function buildTelegramUpdateExecutionPlan<
   TReactionUpdate extends TelegramMessageReactionUpdated,
   TCallbackQuery extends TelegramCallbackQuery,
   TMessage extends TelegramUpdateMessage,
+  TGuestMessage extends TelegramGuestMessage,
 >(
-  action: TelegramUpdateFlowAction<TReactionUpdate, TCallbackQuery, TMessage>,
-): TelegramUpdateExecutionPlan<TReactionUpdate, TCallbackQuery, TMessage> {
+  action: TelegramUpdateFlowAction<
+    TReactionUpdate,
+    TCallbackQuery,
+    TMessage,
+    TGuestMessage
+  >,
+): TelegramUpdateExecutionPlan<
+  TReactionUpdate,
+  TCallbackQuery,
+  TMessage,
+  TGuestMessage
+> {
   switch (action.kind) {
     case "ignore":
       return { kind: "ignore" };
@@ -345,6 +401,12 @@ export function buildTelegramUpdateExecutionPlan<
         shouldPair: action.authorization.kind === "pair",
         shouldDeny: action.authorization.kind === "deny",
       };
+    case "guest":
+      return {
+        kind: "guest",
+        guestMessage: action.guestMessage,
+        shouldDeny: action.authorization.kind === "deny",
+      };
   }
 }
 
@@ -387,6 +449,7 @@ export interface TelegramUpdateRuntimeDeps<
     callbackQueryId: string,
     text?: string,
   ) => Promise<void>;
+  answerGuestQuery: (guestQueryId: string, text?: string) => Promise<void>;
   handleAuthorizedTelegramCallbackQuery: (
     query: TCallbackQuery,
     ctx: TContext,
@@ -404,6 +467,10 @@ export interface TelegramUpdateRuntimeDeps<
     message: TMessage,
     ctx: TContext,
   ) => unknown;
+  handleAuthorizedTelegramGuestMessage?: (
+    guestMessage: TelegramGuestMessage & { from: TelegramUser },
+    ctx: TContext,
+  ) => Promise<void>;
 }
 
 export interface TelegramUpdateRuntimeControllerDeps<
@@ -431,6 +498,7 @@ export interface TelegramUpdateRuntimeControllerDeps<
     callbackQueryId: string,
     text?: string,
   ) => Promise<void>;
+  answerGuestQuery: (guestQueryId: string, text?: string) => Promise<void>;
   handleAuthorizedTelegramCallbackQuery: (
     query: TCallbackQuery,
     ctx: TContext,
@@ -448,6 +516,10 @@ export interface TelegramUpdateRuntimeControllerDeps<
     message: TMessage,
     ctx: TContext,
   ) => unknown;
+  handleAuthorizedTelegramGuestMessage?: (
+    guestMessage: TelegramGuestMessage & { from: TelegramUser },
+    ctx: TContext,
+  ) => Promise<void>;
 }
 
 export interface TelegramUpdateRuntimeController<
@@ -536,12 +608,15 @@ export function createTelegramPairedUpdateRuntime<
       updateStatus: deps.updateStatus,
     }).pairIfNeeded,
     answerCallbackQuery: deps.answerCallbackQuery,
+    answerGuestQuery: deps.answerGuestQuery,
     handleAuthorizedTelegramCallbackQuery:
       deps.handleAuthorizedTelegramCallbackQuery,
     sendTextReply: deps.sendTextReply,
     handleAuthorizedTelegramMessage: deps.handleAuthorizedTelegramMessage,
     handleAuthorizedTelegramEditedMessage:
       deps.handleAuthorizedTelegramEditedMessage,
+    handleAuthorizedTelegramGuestMessage:
+      deps.handleAuthorizedTelegramGuestMessage,
   });
 }
 
@@ -582,12 +657,15 @@ export function createTelegramUpdateRuntime<
         handleAuthorizedTelegramReactionUpdate: handleAuthorizedReactionUpdate,
         pairTelegramUserIfNeeded: deps.pairTelegramUserIfNeeded,
         answerCallbackQuery: deps.answerCallbackQuery,
+        answerGuestQuery: deps.answerGuestQuery,
         handleAuthorizedTelegramCallbackQuery:
           deps.handleAuthorizedTelegramCallbackQuery,
         sendTextReply: deps.sendTextReply,
         handleAuthorizedTelegramMessage: deps.handleAuthorizedTelegramMessage,
         handleAuthorizedTelegramEditedMessage:
           deps.handleAuthorizedTelegramEditedMessage,
+        handleAuthorizedTelegramGuestMessage:
+          deps.handleAuthorizedTelegramGuestMessage,
       }),
   };
 }
@@ -712,6 +790,22 @@ export async function executeTelegramUpdatePlan<
     await deps.handleAuthorizedTelegramCallbackQuery(plan.query, deps.ctx);
     return;
   }
+  if (plan.kind === "guest") {
+    if (plan.shouldDeny) {
+      await deps.answerGuestQuery(
+        plan.guestMessage.guest_query_id,
+        "Access denied.",
+      );
+      return;
+    }
+    if (deps.handleAuthorizedTelegramGuestMessage) {
+      await deps.handleAuthorizedTelegramGuestMessage(
+        plan.guestMessage,
+        deps.ctx,
+      );
+    }
+    return;
+  }
   const pairedNow = plan.shouldPair
     ? await deps.pairTelegramUserIfNeeded(plan.message.from.id, deps.ctx)
     : false;

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "private": false,
-  "description": "Better Telegram DM bridge extension for π",
+  "publishConfig": {
+    "access": "public"
+  },
+  "description": "Telegram Runtime Adapter for π",
   "type": "module",
   "keywords": [
     "pi-package",
@@ -20,6 +23,9 @@
   "bugs": {
     "url": "https://github.com/llblab/pi-telegram/issues"
   },
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "scripts": {
     "test": "node --experimental-strip-types --test tests/*.test.ts",
     "typecheck": "tsc --noEmit",
@@ -37,9 +43,6 @@
     "docs/",
     "screenshot.png"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
   "pi": {
     "extensions": [
       "./index.ts"
@@ -47,9 +50,9 @@
     "image": "https://github.com/llblab/pi-telegram/raw/main/screenshot.png"
   },
   "peerDependencies": {
-    "@mariozechner/pi-agent-core": "*",
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
     "@sinclair/typebox": "*"
   },
   "devDependencies": {