@llblab/pi-telegram 0.15.0 → 0.16.0

package/CHANGELOG.md

@@ -2,7 +2,13 @@
 
 ## Unreleased
 
-No open changes.
+## 0.16.0: Telegram Extension Commands
+
+- `[API]` Added `registerTelegramCommand()` on the public `/commands` subpath so companion extensions can explicitly provide Telegram-native slash commands without adding workflow-specific commands to core. Built-in bridge commands stay reserved, extension command names must be Bot API safe, duplicate extension names are rejected, commands stay hidden unless `showInMenu` is enabled, visible commands must provide an emoji used in `/start` help and Bot API descriptions, extension-command descriptions are shown in `/start`, visible extension commands are inserted after `/compact` before queue-control commands, prompt-template commands remain separated in `/start`, handler failures are isolated with runtime diagnostics, and routing precedence is built-ins → extension commands → prompt-template aliases. Impact: commands such as fresh-session controls can live in companion extensions while `pi-telegram` remains a lightweight Telegram shell.
+
+## 0.15.1: Typing Keepalive Cadence
+
+- `[Typing Status]` Pinned the default native Telegram typing keepalive interval at 2500 ms while preserving the 250 ms idle-drain cap. Impact: runtime behavior matches the intended conservative chat-action cadence.
 
 ## 0.15.0: Companion Status Lines
 

package/README.md

@@ -114,7 +114,7 @@ If you ask π for a generated file, π can call `telegram_attach`: during a Tele
 
 ### Operator menu and controls
 
-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.
+The inline application menu is the primary operator surface. It exposes status, prompt-template commands, companion-extension Telegram 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.
 
 ### Queue runtime
 
@@ -209,7 +209,7 @@ Unknown inline-button callbacks are forwarded to π as `[callback] <data>` when
 
 ### Extension Sections
 
-Ordinary pi extensions can register structured UI sections that appear in the main Telegram menu and Settings submenu without owning a second polling loop. Companion extensions can also register compact status lines for the `/start` menu status text, allowing widgets such as quota indicators to appear beside Status, Usage, Cost, and Context only when relevant to the active model. Each section gets a narrow typed context with `edit`, `open`, `enqueuePrompt`, `answerCallback`, and `callbackData()` — enough to build interactive Telegram-native surfaces while `pi-telegram` owns transport, callback routing, navigation hierarchy, and diagnostics.
+Ordinary pi extensions can register Telegram-native slash commands, structured UI sections, and compact status lines without owning a second polling loop. Slash commands use explicit opt-in registration from `@llblab/pi-telegram/commands`, so workflow-specific commands such as a fresh-session control can live in companion extensions instead of expanding the core bridge command set. UI sections appear in the main Telegram menu and Settings submenu, while status lines allow widgets such as quota indicators to appear beside Status, Usage, Cost, and Context only when relevant to the active model. Each section gets a narrow typed context with `edit`, `open`, `enqueuePrompt`, `answerCallback`, and `callbackData()` — enough to build interactive Telegram-native surfaces while `pi-telegram` owns transport, callback routing, navigation hierarchy, and diagnostics.
 
 Import `registerTelegramSection()` from `@llblab/pi-telegram/sections` and return a disposer on shutdown. Sections can send interactive messages directly into the chat via `ctx.open()` — confirmation dialogs, approve/deny gates, and multi-step forms live outside the menu hierarchy while callbacks route through the same typed handler. See [`@llblab/pi-telegram-extension-demo`](https://github.com/llblab/pi-telegram-extension-demo) for a working reference and the [Extension Sections Standard](./docs/sections.md) for the full contract.
 

package/api/commands.ts

@@ -0,0 +1,11 @@
+/**
+ * Public Telegram commands API
+ * Zones: package boundary, companion extension interop
+ * Exposes the stable Telegram slash-command registration surface while keeping registry internals package-private
+ */
+
+export {
+  registerTelegramCommand,
+  type TelegramExtensionCommandContext,
+  type TelegramExtensionCommandRegistration,
+} from "../lib/commands.ts";

package/docs/README.md

@@ -2,6 +2,8 @@
 
 Living index of project documentation in `/docs`.
 
+`public-api.md` is the canonical entrypoint for stable extension surfaces. Focused documents exist only when a surface has enough runtime rules to need a dedicated standard.
+
 ## Documents
 
 - [architecture.md](./architecture.md) — Overview of the Telegram bridge runtime, queueing model, rendering pipeline, and interactive controls

package/docs/architecture.md

@@ -207,12 +207,13 @@ Unknown callback data outside owned prefixes is forwarded as `[callback] <data>`
 `pi-telegram` intentionally owns one `getUpdates` loop per bot. `polling` owns that internal loop; `updates` owns classification/default-routing plans plus the public handler registry layered extensions use to observe or consume updates without opening a competing polling connection. Layered extensions should integrate through extension surfaces instead of polling the same bot independently.
 
 - Raw update observation/consumption: [Updates](./updates.md).
+- Telegram-native slash commands: `registerTelegramCommand()` from [Public API](./public-api.md#commands).
 - Structured inline UI sections: [Sections](./sections.md).
 - Callback namespace discipline: [Callback Namespaces](./callback-namespaces.md).
 - Voice/STT/TTS providers: [Voice Integration](./voice.md).
 - Inbound/outbound command-template handlers: [Command Templates](./command-templates.md).
 
-Extension callbacks must avoid `pi-telegram` owned prefixes such as `compact:`, `tgbtn:`, `menu:`, `model:`, `thinking:`, `status:`, `queue:`, `settings:`, and `section:`.
+Extension callbacks must avoid `pi-telegram` owned prefixes such as `compact:`, `tgbtn:`, `menu:`, `model:`, `thinking:`, `status:`, `queue:`, `settings:`, and `section:`. Workflow-specific Telegram slash commands should use the public command registry instead of becoming new core built-ins unless they are bridge lifecycle, transport ownership, queue safety, or essential operator controls.
 
 ## Diagnostics And Operational Behavior
 

package/docs/public-api.md

@@ -18,6 +18,7 @@ import telegram from "@llblab/pi-telegram";
 import { registerTelegramSection } from "@llblab/pi-telegram/sections";
 import { registerTelegramStatusLineProvider } from "@llblab/pi-telegram/status";
 import { registerTelegramUpdateHandler } from "@llblab/pi-telegram/updates";
+import { registerTelegramCommand } from "@llblab/pi-telegram/commands";
 import { registerTelegramInboundHandler } from "@llblab/pi-telegram/inbound";
 import { registerTelegramOutboundHandler } from "@llblab/pi-telegram/outbound";
 import {
@@ -26,7 +27,7 @@ import {
 } from "@llblab/pi-telegram/voice";
 ```
 
-`0.12.0` intentionally removes the published `@llblab/pi-telegram/lib/*.ts` compatibility wildcard. Integrations should use the public API domain subpaths above. Package exports point at `/api/*.ts` membranes that re-export only stable companion-extension symbols; implementation modules under `lib/` remain package-private. See [Public API Smoke Examples](#public-api-smoke-examples) below for minimal companion-extension patterns that avoid implementation imports.
+`0.12.0` intentionally removes the published `@llblab/pi-telegram/lib/*.ts` compatibility wildcard. Integrations should use the public API domain subpaths above. Package exports point at `/api/*.ts` membranes that re-export only stable companion-extension symbols; implementation modules under `lib/` remain package-private. Telegram command extensions use `/commands` as an explicit opt-in surface instead of automatically exposing arbitrary π slash commands to Telegram. See [Public API Smoke Examples](#public-api-smoke-examples) below for minimal companion-extension patterns that avoid implementation imports.
 
 ## User-Facing API
 
@@ -103,6 +104,9 @@ High-level stable APIs:
 - `registerTelegramSection()`
   - Identity: required `id`.
   - Purpose: managed menu/settings UI surfaces.
+- `registerTelegramCommand()`
+  - Identity: command name.
+  - Purpose: explicit opt-in Telegram-native slash commands for companion workflows.
 - `registerTelegramStatusLineProvider()`
   - Identity: required `id`.
   - Purpose: compact companion status rows in the `/start` menu status text.
@@ -133,6 +137,34 @@ Advanced stable diagnostics:
 
 All registration APIs return a disposer. Companion extensions should call disposers on shutdown and re-register on session start when they recreate runtime state. Low-level bus APIs intentionally avoid ids and run in registration order. High-level provider/UI APIs require stable identity in their public contract so diagnostics, replacement, and cleanup are understandable. Generated voice-provider ids remain a temporary compatibility path where documented.
 
+## Commands
+
+Import from `@llblab/pi-telegram/commands`. This registers Telegram slash commands only; it does not expose π slash commands and is unrelated to command-template handlers.
+
+```ts
+const off = registerTelegramCommand({
+  name: "new",
+  description: "Start fresh",
+  showInMenu: true,
+  emoji: "🆕",
+  handler: async (ctx) => {
+    await ctx.reply("Starting a fresh session is handled by my extension.");
+  },
+});
+```
+
+Contract:
+
+- Command names are Telegram Bot API names: lowercase `a-z`, digits, and `_`, up to 32 characters. Hyphenated names are rejected.
+- Built-in bridge commands such as `/start`, `/compact`, `/next`, `/abort`, and `/stop` are reserved and cannot be claimed by extensions.
+- Duplicate extension command names are rejected. The disposer removes only its own command registration.
+- Routing precedence is built-in bridge commands first, registered extension commands second, and prompt-template aliases after that. This lets an extension intentionally claim a command name; prompt-template owners can resolve collisions by renaming the template alias.
+- `showInMenu` defaults to `false`. When `true`, `emoji` is required and the command appears in `/start` help with that marker; it also joins Bot API command sync only when `description` is provided, because Telegram command-list entries require descriptions. The emoji is prefixed to the Bot API description as well. Workflow/product commands should opt in deliberately instead of expanding the core command row by default.
+- The command context currently provides `name`, `args`, `reply(text)`, and `enqueuePrompt(prompt)`. Use `enqueuePrompt()` when a command should create normal queued π work rather than perform immediate Telegram-side handling.
+- Handler failures are isolated: the bridge records a `telegram-command` runtime diagnostic, sends a compact failure reply, and keeps Telegram polling/routing alive.
+
+Core commands stay reserved for bridge lifecycle, transport ownership, queue safety, and essential operator controls. Opinionated workflow commands should live in companion extensions through this registry.
+
 ## Sections
 
 Import from `@llblab/pi-telegram/sections`.

package/index.ts

@@ -256,7 +256,7 @@ export default function (pi: Pi.ExtensionAPI) {
   const getPromptTemplateCommands =
     PromptTemplates.createTelegramPromptTemplateCommandGetter({
       getCommands,
-      reservedCommandNames: Commands.TELEGRAM_RESERVED_COMMAND_NAMES,
+      getReservedCommandNames: Commands.getTelegramReservedCommandNames,
     });
   const menuActions = Menu.createTelegramMenuActionRuntimeWithStateBuilder({
     runtime: modelMenuRuntime,

package/lib/commands.ts

@@ -27,6 +27,130 @@ export interface TelegramPromptTemplateMenuCommand {
   description?: string;
 }
 
+const TELEGRAM_EXTENSION_COMMAND_REGISTRY_KEY = "__piTelegramCommandRegistry__";
+const TELEGRAM_BOT_COMMAND_NAME_PATTERN = /^[a-z0-9_]{1,32}$/;
+
+export interface TelegramExtensionCommandContext {
+  name: string;
+  args: string;
+  reply: (text: string) => Promise<void>;
+  enqueuePrompt: (prompt: string) => Promise<void>;
+}
+
+export interface TelegramExtensionCommandRegistration {
+  name: string;
+  description?: string;
+  order?: number;
+  showInMenu?: boolean;
+  emoji?: string;
+  handler: (ctx: TelegramExtensionCommandContext) => Promise<void> | void;
+}
+
+interface RegisteredTelegramExtensionCommand {
+  name: string;
+  description?: string;
+  order: number;
+  showInMenu: boolean;
+  emoji?: string;
+  handler: TelegramExtensionCommandRegistration["handler"];
+}
+
+interface TelegramExtensionCommandRegistry {
+  commands: Map<string, RegisteredTelegramExtensionCommand>;
+}
+
+function getOrCreateTelegramCommandRegistry(): TelegramExtensionCommandRegistry {
+  const existing = (globalThis as Record<string, unknown>)[
+    TELEGRAM_EXTENSION_COMMAND_REGISTRY_KEY
+  ];
+  if (
+    existing &&
+    typeof existing === "object" &&
+    existing !== null &&
+    "commands" in existing &&
+    existing.commands instanceof Map
+  ) {
+    return existing as TelegramExtensionCommandRegistry;
+  }
+  const registry: TelegramExtensionCommandRegistry = { commands: new Map() };
+  (globalThis as Record<string, unknown>)[
+    TELEGRAM_EXTENSION_COMMAND_REGISTRY_KEY
+  ] = registry;
+  return registry;
+}
+
+export function normalizeTelegramExtensionCommandName(name: string): string {
+  return name.trim().replace(/^\/+/, "").toLowerCase();
+}
+
+export function isTelegramExtensionCommandName(name: string): boolean {
+  return TELEGRAM_BOT_COMMAND_NAME_PATTERN.test(name);
+}
+
+function normalizeTelegramExtensionCommandEmoji(
+  emoji: string | undefined,
+): string | undefined {
+  const normalized = emoji?.trim();
+  return normalized ? normalized : undefined;
+}
+
+export function registerTelegramCommand(
+  registration: TelegramExtensionCommandRegistration,
+): () => void {
+  const name = normalizeTelegramExtensionCommandName(registration.name);
+  const showInMenu = registration.showInMenu ?? false;
+  const emoji = normalizeTelegramExtensionCommandEmoji(registration.emoji);
+  if (!isTelegramExtensionCommandName(name)) {
+    throw new Error(`Invalid Telegram command name: ${registration.name}`);
+  }
+  if (showInMenu && !emoji) {
+    throw new Error(`Visible Telegram command requires emoji: ${name}`);
+  }
+  if (emoji && emoji.length > 8) {
+    throw new Error(`Telegram command emoji is too long: ${name}`);
+  }
+  if (isTelegramReservedCommandName(name)) {
+    throw new Error(
+      `Telegram command conflicts with built-in command: ${name}`,
+    );
+  }
+  const registry = getOrCreateTelegramCommandRegistry();
+  if (registry.commands.has(name)) {
+    throw new Error(`Telegram command is already registered: ${name}`);
+  }
+  const command: RegisteredTelegramExtensionCommand = {
+    name,
+    description: registration.description,
+    order: registration.order ?? 0,
+    showInMenu,
+    emoji,
+    handler: registration.handler,
+  };
+  registry.commands.set(name, command);
+  return () => {
+    if (registry.commands.get(name) === command) registry.commands.delete(name);
+  };
+}
+
+export function getTelegramExtensionCommands(): RegisteredTelegramExtensionCommand[] {
+  return Array.from(
+    getOrCreateTelegramCommandRegistry().commands.values(),
+  ).sort((a, b) => a.order - b.order || a.name.localeCompare(b.name));
+}
+
+export function findTelegramExtensionCommand(
+  name: string | undefined,
+): RegisteredTelegramExtensionCommand | undefined {
+  if (!name) return undefined;
+  return getOrCreateTelegramCommandRegistry().commands.get(
+    normalizeTelegramExtensionCommandName(name),
+  );
+}
+
+export function clearTelegramExtensionCommands(): void {
+  getOrCreateTelegramCommandRegistry().commands.clear();
+}
+
 export const TELEGRAM_COMMAND_EMOJI = {
   start: "🟢",
   status: "📊",
@@ -106,6 +230,22 @@ export const TELEGRAM_BUILTIN_BOT_COMMANDS: readonly TelegramBotCommandDefinitio
 
 export const TELEGRAM_BOT_COMMANDS = TELEGRAM_BUILTIN_BOT_COMMANDS;
 
+function getVisibleTelegramExtensionBotCommands(): TelegramBotCommandDefinition[] {
+  return getTelegramExtensionCommands()
+    .filter((command) => command.showInMenu && command.description)
+    .map((command) => ({
+      command: command.name,
+      description: `${command.emoji} ${command.description ?? command.name}`,
+    }));
+}
+
+export function getTelegramReservedCommandNames(): string[] {
+  return [
+    ...TELEGRAM_RESERVED_COMMAND_NAMES,
+    ...getTelegramExtensionCommands().map((command) => command.name),
+  ];
+}
+
 export interface TelegramBotCommandRegistrationDeps {
   setMyCommands: (
     commands: readonly TelegramBotCommandDefinition[],
@@ -115,7 +255,23 @@ export interface TelegramBotCommandRegistrationDeps {
 export async function registerTelegramBotCommands(
   deps: TelegramBotCommandRegistrationDeps,
 ): Promise<void> {
-  await deps.setMyCommands(TELEGRAM_BOT_COMMANDS);
+  const extensionCommands = getVisibleTelegramExtensionBotCommands();
+  if (extensionCommands.length === 0) {
+    await deps.setMyCommands(TELEGRAM_BOT_COMMANDS);
+    return;
+  }
+  const compactCommandIndex = TELEGRAM_BOT_COMMANDS.findIndex(
+    (command) => command.command === "compact",
+  );
+  if (compactCommandIndex === -1) {
+    await deps.setMyCommands([...TELEGRAM_BOT_COMMANDS, ...extensionCommands]);
+    return;
+  }
+  await deps.setMyCommands([
+    ...TELEGRAM_BOT_COMMANDS.slice(0, compactCommandIndex + 1),
+    ...extensionCommands,
+    ...TELEGRAM_BOT_COMMANDS.slice(compactCommandIndex + 1),
+  ]);
 }
 
 export function createTelegramBotCommandRegistrar(
@@ -566,6 +722,11 @@ export interface TelegramCommandOrPromptRuntimeDeps<TMessage, TContext> {
     message: TMessage,
     ctx: TContext,
   ) => Promise<boolean>;
+  executeExtensionCommand?: (
+    command: ParsedTelegramCommand,
+    message: TMessage,
+    ctx: TContext,
+  ) => Promise<boolean>;
   expandPromptTemplateCommand?: (
     commandName: string,
     args: string,
@@ -650,15 +811,41 @@ function buildTelegramPromptTemplateMenuHtml(
     .join("\n");
 }
 
+function buildTelegramExtensionCommandMenuLines(): string[] {
+  return getTelegramExtensionCommands()
+    .filter((command) => command.showInMenu)
+    .map((command) => {
+      const prefix = `${escapeTelegramCommandMenuHtml(command.emoji ?? "")} /${escapeTelegramCommandMenuHtml(command.name)}`;
+      if (!command.description) return prefix;
+      return `${prefix} — ${escapeTelegramCommandMenuHtml(command.description)}`;
+    });
+}
+
+function buildTelegramAppMenuIntroHtml(): string {
+  const extensionLines = buildTelegramExtensionCommandMenuLines();
+  if (extensionLines.length === 0) return TELEGRAM_APP_MENU_INTRO_HTML;
+  return [
+    "<b>π Telegram</b>",
+    "",
+    `${formatTelegramCommandEmojiPrefix("start")}/start — Open menu / Pair bridge`,
+    `${formatTelegramCommandEmojiPrefix("compact")}/compact — Compact current session`,
+    ...extensionLines,
+    `${formatTelegramCommandEmojiPrefix("next")}/next — Force next turn`,
+    `${formatTelegramCommandEmojiPrefix("continue")}/continue — Queue continue prompt`,
+    `${formatTelegramCommandEmojiPrefix("abort")}/abort — Abort π`,
+    `${formatTelegramCommandEmojiPrefix("stop")}/stop — Abort π & Clear queue`,
+  ].join("\n");
+}
+
 export function buildTelegramAppMenuHtml(
   statusHtml: string,
   promptTemplates: readonly TelegramPromptTemplateMenuCommand[] = [],
 ): string {
+  const introHtml = buildTelegramAppMenuIntroHtml();
   const promptTemplateHtml =
     buildTelegramPromptTemplateMenuHtml(promptTemplates);
-  if (!promptTemplateHtml)
-    return `${TELEGRAM_APP_MENU_INTRO_HTML}\n\n${statusHtml}`;
-  return `${TELEGRAM_APP_MENU_INTRO_HTML}\n\n${promptTemplateHtml}\n\n${statusHtml}`;
+  if (!promptTemplateHtml) return `${introHtml}\n\n${statusHtml}`;
+  return `${introHtml}\n\n${promptTemplateHtml}\n\n${statusHtml}`;
 }
 
 export function createTelegramAppMenuHtmlBuilder<TContext>(deps: {
@@ -1133,6 +1320,14 @@ export function createTelegramCommandOrPromptRuntime<TMessage, TContext>(
         ctx,
       );
       if (handled) return;
+      if (command && deps.executeExtensionCommand) {
+        const handledByExtension = await deps.executeExtensionCommand(
+          command,
+          messages[0]!,
+          ctx,
+        );
+        if (handledByExtension) return;
+      }
       if (command?.name && deps.expandPromptTemplateCommand) {
         const expanded = deps.expandPromptTemplateCommand(
           command.name,

package/lib/prompt-templates.ts

@@ -99,6 +99,7 @@ export function mapPiPromptTemplateNameToTelegramCommandName(
 export interface TelegramPromptTemplateCommandGetterDeps {
   getCommands: () => readonly PiSlashCommandInfo[];
   reservedCommandNames?: readonly string[];
+  getReservedCommandNames?: () => readonly string[];
 }
 
 export function getTelegramPromptTemplateCommands(
@@ -128,9 +129,14 @@ export function getTelegramPromptTemplateCommands(
 export function createTelegramPromptTemplateCommandGetter(
   deps: TelegramPromptTemplateCommandGetterDeps,
 ): () => TelegramPromptTemplateCommand[] {
-  const reservedNames = new Set(deps.reservedCommandNames);
   return function getPromptTemplateCommands() {
-    return getTelegramPromptTemplateCommands(deps.getCommands(), reservedNames);
+    return getTelegramPromptTemplateCommands(
+      deps.getCommands(),
+      new Set([
+        ...(deps.reservedCommandNames ?? []),
+        ...(deps.getReservedCommandNames?.() ?? []),
+      ]),
+    );
   };
 }
 

package/lib/routing.ts

@@ -358,13 +358,12 @@ export function createTelegramInboundRouteRuntime<
     deps.queueMutationRuntime.append(continueTurn, ctx);
     deps.dispatchNextQueuedTelegramTurn(ctx);
   };
-  const reservedCommandNames = new Set(
-    Commands.TELEGRAM_RESERVED_COMMAND_NAMES,
-  );
+  const reservedCommandNames = () =>
+    new Set(Commands.getTelegramReservedCommandNames());
   const getPromptTemplateCommands = () =>
     PromptTemplates.getTelegramPromptTemplateCommands(
       deps.getCommands(),
-      reservedCommandNames,
+      reservedCommandNames(),
     );
   const commandHandler = Commands.createTelegramCommandHandlerTargetRuntime<
     TMessage,
@@ -434,6 +433,43 @@ export function createTelegramInboundRouteRuntime<
   >({
     extractRawText: Media.extractFirstTelegramMessageText,
     handleCommand: commandHandler,
+    executeExtensionCommand: async (command, message, ctx) => {
+      const extensionCommand = Commands.findTelegramExtensionCommand(
+        command.name,
+      );
+      if (!extensionCommand) return false;
+      try {
+        await extensionCommand.handler({
+          name: command.name,
+          args: command.args,
+          reply: (text) =>
+            deps
+              .sendTextReply(message.chat.id, message.message_id, text)
+              .then(() => {}),
+          enqueuePrompt: (prompt) =>
+            promptEnqueue(
+              [
+                {
+                  ...message,
+                  text: prompt,
+                  caption: undefined,
+                } as TMessage,
+              ],
+              ctx,
+            ),
+        });
+      } catch (error) {
+        deps.recordRuntimeEvent?.("telegram-command", error, {
+          command: command.name,
+        });
+        await deps.sendTextReply(
+          message.chat.id,
+          message.message_id,
+          "Command failed.",
+        );
+      }
+      return true;
+    },
     expandPromptTemplateCommand: (commandName, args) =>
       PromptTemplates.expandTelegramPromptTemplateCommand(
         commandName,

package/lib/runtime.ts

@@ -4,8 +4,8 @@
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
 
-const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 3000;
-const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 300;
+const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 2500;
+const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 
 export interface TelegramRuntimeQueueCounters {
   nextQueuedTelegramItemOrder: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.15.0",
+  "version": "0.16.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -49,6 +49,7 @@
     "./inbound": "./api/inbound.ts",
     "./outbound": "./api/outbound.ts",
     "./updates": "./api/updates.ts",
+    "./commands": "./api/commands.ts",
     "./sections": "./api/sections.ts",
     "./status": "./api/status.ts",
     "./voice": "./api/voice.ts",