@llblab/pi-telegram 0.49.0 → 0.50.1

package/AGENTS.md

@@ -121,7 +121,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 an internal Pi command via `pi.sendUserMessage(..., { expandPromptTemplates: true })`; the command handler receives the real `ExtensionCommandContext` and calls `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. 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 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. 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
 

package/CHANGELOG.md

@@ -4,6 +4,18 @@
 
 ## Unreleased
 
+## 0.50.1: Queue, lifecycle, and Workspace hotfixes
+
+- `Workspace slot recovery`: Uses the canonical binding returned by target-deduplicating Workspace commit for the live leader record and connection result, preventing a provisional recovery slot from consuming a second letter and falsely blocking follower registration at A–Z capacity.
+- `Guest queue Skip`: Lets the leader discard a waiting Guest Mode prompt directly from the queue menu while other work is active. Guest callbacks use stable queue identity, settle durable admission before removal, stop placeholder rotation, and visually clear the inline globe placeholder without starting a model turn.
+- `Internal lifecycle safety`: Binds each armed `/telegram-internal` lifecycle action to an unpredictable one-use token, so manual, mismatched, and replayed calls cannot consume or execute it.
+- `Command surface`: Uses Pi-style argument-first autocomplete hints, keeps descriptions concise and punctuation-consistent, uses `profile` consistently, describes `/telegram-internal` as a manual-use warning, and removes Workspace Thread naming from `/telegram-connect`; Thread names remain configurable from Telegram.
+
+## 0.50.0: Internal lifecycle gateway and thinking cadence
+
+- `Internal lifecycle gateway`: Replaces the session-specific technical command with one `/telegram-internal` gateway for runtime-armed typed actions. Manual invocation performs no action and explains that the command cannot be run manually; settled `/new` replacement retains the same lifecycle and terminal-result guarantees.
+- `Thinking cadence`: Thinking now follows the same cadence as answer drafts: it accumulates the opening frame for two seconds, then updates at most once every two seconds while still flushing buffered reasoning when the block completes.
+
 ## 0.49.0: Unified fresh-session continuity
 
 - `/new`: Classic and Threaded Mode now share one confirmed fresh-session flow. The settled callback deletes its dialog and publishes an expiring exact-target intent; a same- or cross-process successor preserves the classic chat or re-keys the Thread/slot/name, atomically claims once, then sends one terminal result. Identity mismatches fail closed.

package/README.md

@@ -55,7 +55,7 @@ Paste the bot token. If `~/.pi/agent/telegram.json` already contains a saved tok
 /telegram-connect
 ```
 
-The connected Pi instance owns Telegram polling. Use `/telegram-connect <profile>` to activate a named profile, and optionally append `as=Name` to name a fresh Workspace Thread. Each profile is a parallel bot runtime with isolated polling, diagnostics, Threaded Mode state, and local bus transport; the `default` profile keeps unsuffixed runtime paths. In classic mode each profile uses a singleton lock. When Telegram private-chat Threaded Mode is available, one live instance becomes the profile's leader and later visible Pi instances register as followers. Reopening or resuming the same Pi session restores its remembered Thread at session startup; a distinct session in the same directory has its own binding and still requires explicit `/telegram-connect` when no remembered binding exists.
+The connected Pi instance owns Telegram polling. Use `/telegram-connect <profile>` to activate a named profile. Each profile is a parallel bot runtime with isolated polling, diagnostics, Threaded Mode state, and local bus transport; the `default` profile keeps unsuffixed runtime paths. In classic mode each profile uses a singleton lock. When Telegram private-chat Threaded Mode is available, one live instance becomes the profile's leader and later visible Pi instances register as followers. Reopening or resuming the same Pi session restores its remembered Thread at session startup; a distinct session in the same directory has its own binding and still requires explicit `/telegram-connect` when no remembered binding exists.
 
 After an unclean computer shutdown, `/telegram-connect` detects truncated or structurally invalid temporary ownership/routing files, quarantines only the damaged files under `tmp/telegram/recovery/`, and retries once. A journal snapshot removed by older broad temp cleanup is rebuilt when its complete segment history proves an empty result, while a revisionless snapshot is repaired from the first surviving segment's exact predecessor when the reconstructed tail validates. Otherwise the snapshot and segments are quarantined as recovery evidence, a fresh journal is published, and startup continues with an informational diagnostic instead of requiring manual JSON repair. Unsupported journal versions block recovery without rewriting or quarantining the retained files; use a compatible runtime rather than deleting journals. Saved `telegram.json` configuration and runtime diagnostics remain intact. Recovery never replaces a verifiable live owner; if safe automatic recovery cannot complete, the command gives one explicit Pi-restart instruction instead of requiring deletion of the whole `tmp/` directory.
 
@@ -126,7 +126,7 @@ Enable the optional capabilities the bridge needs in the [@BotFather](https://t.
 | Model and thinking | Switch model or thinking level from Telegram through safe continuation flows. | Mobile control can adjust execution strategy without tearing down the current session. |
 | Compaction | Confirm `/compact`, show native active status during compaction, and preserve Telegram-owned turn semantics. | Context maintenance is visible and safe from the phone. |
 | Draft previews | Show Telegram's native `…typing` indicator whenever the connected instance is doing agent work, or enable Rich Draft previews for streamed answer text. | Local prompts, Telegram turns, and autonomous continuations remain visibly active while draft visibility stays independent from final rendering. |
-| Activity | Keep the default `verbose` technical surface, show only `thinking`, show only `tools`, or select `quiet` for answer-only delivery. Every instance reloads this shared file-backed choice before a new agent run; thinking uses a headerless expandable quote, while each tool uses one iconless closed root row containing nested evidence details. | Persistent collapsed technical activity minimizes chat height and stays bounded, redacted, target-fenced, free of URL previews, and visually separate from semantic assistant answers. |
+| Activity | Keep the default `verbose` technical surface, show only `thinking`, show only `tools`, or select `quiet` for answer-only delivery. Every instance reloads this shared file-backed choice before a new agent run; thinking accumulates for two seconds and then updates at most every two seconds in a headerless expandable quote, while each tool uses one iconless closed root row containing nested evidence details. | Persistent collapsed technical activity minimizes chat height and stays bounded, redacted, target-fenced, free of URL previews, and visually separate from semantic assistant answers. |
 | Assistant rendering | Choose Native Rich Markdown or legacy Markdown-to-HTML for final assistant replies. | Renderer compatibility is explicit instead of being conflated with draft previews. |
 | Bridge UI rendering | Render thinking through headerless expandable HTML with inline emphasis/code, render each tool as an iconless native Rich root details tree with immediately visible arguments and collapsed secondary evidence, and keep menus, queue controls, status, settings, diagnostics, and sections on Telegram HTML/plain UI. | Harness-owned surfaces remain operationally predictable and visually distinct from model-authored answers. |
 | Inbound files | Download inbound files to the Pi agent temp directory with size limits. | Screenshots, PDFs, datasets, and artifacts enter Pi as inspectable local files. |
@@ -183,7 +183,6 @@ Run these inside Pi.
 | `/telegram-setup <profile>` | Save or update a named-profile bot token |
 | `/telegram-connect` / `/telegram-connect default` | Activate `profiles.default` and acquire its transport ownership |
 | `/telegram-connect <profile>` | Activate a named profile and acquire its transport ownership |
-| `/telegram-connect [profile] as=Name` | Give a fresh Workspace Thread one unique capitalized Latin-word identity while connecting |
 | `/telegram-disconnect` | Confirm, then stop polling, release ownership, and delete this instance's Threaded Mode tab; graceful Pi quit always preserves restart ownership and independently deletes the tab only when automatic cleanup is enabled |
 | `/telegram-status` | Inspect connection, mode, separate polling/worker progress, journal depth, queue, transport, automatic retry state, and recent diagnostics |
 

package/dist/lib/activity-verbosity.d.ts

@@ -11,7 +11,7 @@ export declare const TELEGRAM_ACTIVITY_MESSAGE_MAX_CHARS = 3900;
 export declare const TELEGRAM_ACTIVITY_MESSAGE_MAX_TOOLS = 6;
 export declare const TELEGRAM_REASONING_MESSAGE_MAX_FRAMES = 24;
 export declare const TELEGRAM_REASONING_BUFFER_MAX_CHARS = 1200;
-export declare const TELEGRAM_REASONING_MIN_INTERVAL_MS = 1200;
+export declare const TELEGRAM_REASONING_MIN_INTERVAL_MS = 2000;
 export declare const TELEGRAM_TOOL_UPDATE_MAX_ENTRIES = 4;
 interface ToolActivity {
     id: string;
@@ -41,6 +41,8 @@ export declare function createTelegramActivityVerbosityRuntime<TAuthority>(deps:
     getActivityMode: () => "quiet" | "thinking" | "tools" | "verbose";
     refreshActivityMode?: () => Promise<void>;
     getNowMs?: () => number;
+    setReasoningTimeout?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    clearReasoningTimeout?: (timer: ReturnType<typeof setTimeout>) => void;
     resolveTarget: (event: TelegramActivityEvent) => TelegramTarget | undefined;
     captureAuthority: () => TAuthority;
     isAuthorityActive: (authority: TAuthority) => boolean;

package/dist/lib/activity-verbosity.js

@@ -9,7 +9,9 @@ export const TELEGRAM_ACTIVITY_MESSAGE_MAX_CHARS = 3_900;
 export const TELEGRAM_ACTIVITY_MESSAGE_MAX_TOOLS = 6;
 export const TELEGRAM_REASONING_MESSAGE_MAX_FRAMES = 24;
 export const TELEGRAM_REASONING_BUFFER_MAX_CHARS = 1_200;
-export const TELEGRAM_REASONING_MIN_INTERVAL_MS = 1_200;
+// Match native answer drafts: accumulate the opening frame for one full
+// interval, then publish at most one updated frame per interval.
+export const TELEGRAM_REASONING_MIN_INTERVAL_MS = 2_000;
 export const TELEGRAM_TOOL_UPDATE_MAX_ENTRIES = 4;
 function targetEquals(left, right) {
     return left.chatId === right.chatId && left.threadId === right.threadId;
@@ -234,10 +236,18 @@ export function createTelegramActivityVerbosityRuntime(deps) {
     let reasoningMessage;
     let reasoningBlocked = false;
     let lastReasoningPublishMs = 0;
+    let reasoningFlushTimer;
     let toolMessage;
     const tools = new Map();
     const toolOrder = [];
+    const clearReasoningFlushTimer = () => {
+        if (!reasoningFlushTimer)
+            return;
+        (deps.clearReasoningTimeout ?? clearTimeout)(reasoningFlushTimer);
+        reasoningFlushTimer = undefined;
+    };
     const clearActivity = () => {
+        clearReasoningFlushTimer();
         activityId = undefined;
         authority = undefined;
         target = undefined;
@@ -330,6 +340,30 @@ export function createTelegramActivityVerbosityRuntime(deps) {
             deps.recordFailure?.(canEdit ? "reasoning-edit" : "reasoning-send", event, error);
         }
     };
+    const scheduleReasoningPublish = (event, acceptedGeneration) => {
+        if (reasoningFlushTimer || reasoningBlocked)
+            return;
+        const elapsed = reasoningMessageFrames === 0
+            ? 0
+            : getNowMs() - lastReasoningPublishMs;
+        const delayMs = Math.max(0, TELEGRAM_REASONING_MIN_INTERVAL_MS - elapsed);
+        const schedule = deps.setReasoningTimeout ?? setTimeout;
+        reasoningFlushTimer = schedule(() => {
+            reasoningFlushTimer = undefined;
+            const admittedAuthority = authority;
+            const task = async () => {
+                if (!isCurrent(acceptedGeneration, admittedAuthority) ||
+                    reasoningChars <= lastReasoningMessageChars)
+                    return;
+                await publishReasoning(event, acceptedGeneration);
+            };
+            const enqueue = deps.enqueue ?? ((next) => tail.then(next));
+            tail = enqueue(task).catch((error) => {
+                deps.recordFailure?.("reasoning-send", event, error);
+            });
+        }, delayMs);
+        reasoningFlushTimer?.unref?.();
+    };
     const publishTool = async (event, tool, acceptedGeneration) => {
         const admittedAuthority = authority;
         if (!isCurrent(acceptedGeneration, admittedAuthority) || !target) {
@@ -461,12 +495,8 @@ export function createTelegramActivityVerbosityRuntime(deps) {
                 return;
             reasoningChars += event.delta.length;
             reasoningBuffer = `${reasoningBuffer}${event.delta}`.slice(-TELEGRAM_REASONING_BUFFER_MAX_CHARS);
-            if (reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES &&
-                (reasoningMessageFrames === 0 ||
-                    (getNowMs() - lastReasoningPublishMs >=
-                        TELEGRAM_REASONING_MIN_INTERVAL_MS &&
-                        reasoningChars - lastReasoningMessageChars >= 160))) {
-                await publishReasoning(event, acceptedGeneration);
+            if (reasoningMessageFrames < TELEGRAM_REASONING_MESSAGE_MAX_FRAMES) {
+                scheduleReasoningPublish(event, acceptedGeneration);
             }
             return;
         }
@@ -477,6 +507,7 @@ export function createTelegramActivityVerbosityRuntime(deps) {
                 reasoningChars = event.text.length;
                 reasoningBuffer = event.text.slice(-TELEGRAM_REASONING_BUFFER_MAX_CHARS);
             }
+            clearReasoningFlushTimer();
             if (reasoningChars > 0 &&
                 reasoningChars > lastReasoningMessageChars &&
                 !reasoningBlocked) {
@@ -550,8 +581,8 @@ export function createTelegramActivityVerbosityRuntime(deps) {
             return;
         }
         if (event.type === "agent-end" || event.type === "agent-settled") {
-            if (reasoningMessage &&
-                reasoningChars > lastReasoningMessageChars &&
+            clearReasoningFlushTimer();
+            if (reasoningChars > lastReasoningMessageChars &&
                 !reasoningBlocked) {
                 await publishReasoning(event, acceptedGeneration);
             }

package/dist/lib/bindings.d.ts

@@ -165,8 +165,6 @@ interface TelegramCommandsAndToolsBindingDeps {
     stopPolling?: () => Promise<void | string>;
     recoverPollingStart?: Commands.TelegramBridgeCommandRegistrationDeps["recoverPollingStart"];
     getDisconnectThreadName?: () => string | undefined;
-    setRequestedThreadNameForPollingStart?: (threadName: string | undefined) => void;
-    validateThreadName?: Commands.TelegramBridgeCommandRegistrationDeps["validateThreadName"];
     onTransportChanged?: () => Promise<void> | void;
     getStatusLines: (options?: Status.TelegramBridgeStatusLineOptions) => string[];
     buttonActionStore: OutboundHandlers.TelegramButtonActionStore;
@@ -196,7 +194,7 @@ interface TelegramCommandsAndToolsBindingDeps {
     updateStatus: TelegramBridgeStatusUpdater;
     recordRuntimeEvent: TelegramRuntimeEventRecorder;
 }
-export declare function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, recoverPollingStart, getDisconnectThreadName, setRequestedThreadNameForPollingStart, validateThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, }: TelegramCommandsAndToolsBindingDeps): void;
+export declare function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, recoverPollingStart, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, }: TelegramCommandsAndToolsBindingDeps): void;
 interface TelegramLifecycleBindingDeps {
     pi: Pi.ExtensionAPI;
     publicationRuntime: TelegramBridgePublicationRuntime;

package/dist/lib/bindings.js

@@ -323,7 +323,7 @@ export function createTelegramActivityBindingRuntime(deps) {
         },
     };
 }
-export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, recoverPollingStart, getDisconnectThreadName, setRequestedThreadNameForPollingStart, validateThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, }) {
+export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, persistConfig, setup, activeTurnRuntime, lockedPollingRuntime, stopPolling, recoverPollingStart, getDisconnectThreadName, onTransportChanged, getStatusLines, buttonActionStore, sendMarkdownReply, sendChannelMarkdownMessage, sendChannelMediaMessage, listChannelPosts, mutateChannelPost, callMultipart, getDefaultChatId, getDefaultTarget, resolveAgentTarget, routeAgentMessage, canSendDirect, setGenerativeAppLiveSurfaceRuntime, recordRuntimeEvent, updateStatus, }) {
     GenerativeApps.registerTelegramBindTool(pi, {
         agentDir,
         getActiveProfileName: configStore.getActiveProfileName,
@@ -453,7 +453,6 @@ export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, pe
         hasBotToken: configStore.hasBotToken,
         getBotTokenDiagnostic: configStore.getBotTokenDiagnostic,
         startPolling: async (ctx, options) => {
-            setRequestedThreadNameForPollingStart?.(options?.requestedThreadName);
             try {
                 return await lockedPollingRuntime.start(ctx, options);
             }
@@ -461,14 +460,10 @@ export function registerTelegramCommandsAndTools({ pi, agentDir, configStore, pe
                 recordRuntimeEvent("recovery", error, { phase: "polling-start" });
                 throw error;
             }
-            finally {
-                setRequestedThreadNameForPollingStart?.(undefined);
-            }
         },
         stopPolling: stopPolling ?? lockedPollingRuntime.stop,
         recoverPollingStart,
         getDisconnectThreadName,
-        validateThreadName,
         queueAgentConnectionContext,
         updateStatus,
         getProfileNames: () => Config.getTelegramProfileNames(configStore.getStoredConfig()),

package/dist/lib/commands.d.ts

@@ -87,7 +87,6 @@ export declare function createTelegramBotCommandRegistrar(deps: TelegramBotComma
 export interface TelegramBridgeCommandStartPollingOptions {
     force?: boolean;
     forceFreshLeaderThread?: boolean;
-    requestedThreadName?: string;
 }
 export interface TelegramBridgeCommandStartPollingResult {
     ok: boolean;
@@ -119,7 +118,6 @@ export interface TelegramBridgeCommandRegistrationDeps {
     getProfileNames?: () => string[];
     activateDefaultProfileConfig?: (ctx: ExtensionCommandContext) => Promise<void>;
     activateProfileConfig?: (ctx: ExtensionCommandContext, profileName: string) => Promise<boolean>;
-    validateThreadName?: (threadName: string) => string | undefined;
 }
 export type TelegramThreadDisplayNameRenamePort = (target: {
     chatId: number;
@@ -145,7 +143,6 @@ export declare function createTelegramThreadDisplayNameRenameBinding(): {
     bind: (rename: TelegramThreadDisplayNameRenamePort) => void;
     rename: TelegramThreadDisplayNameRenamePort;
 };
-export declare function parseTelegramRequestedThreadName(args: string): string | undefined;
 export declare function registerTelegramBridgeCommands(pi: ExtensionAPI, deps: TelegramBridgeCommandRegistrationDeps): void;
 export declare const TELEGRAM_RESERVED_COMMAND_NAMES: readonly ["stop", "name", "new", "abort", "next", "continue", "status", "queue", "compact", "model", "thinking", "settings", "help", "start"];
 export type TelegramReservedCommandName = (typeof TELEGRAM_RESERVED_COMMAND_NAMES)[number];
@@ -574,8 +571,9 @@ export declare function createTelegramCommandHandler<TMessage extends TelegramCo
 export declare function createTelegramCommandOrPromptRuntime<TMessage, TContext>(deps: TelegramCommandOrPromptRuntimeDeps<TMessage, TContext>): {
     dispatchMessages: (messages: TMessage[], ctx: TContext) => Promise<void>;
 };
-export declare const TELEGRAM_SESSION_ACTION_COMMAND_NAME = "telegram-session-action";
-export declare const TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION = "(internal) replace the current Pi session after Telegram settlement";
+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 function delayTelegramSessionAction(delayMs: number): Promise<void>;
 export interface TelegramSessionActionRuntimeDeps {
     registerCommand: Pi.ExtensionAPI["registerCommand"];

package/dist/lib/commands.js

@@ -3,6 +3,7 @@
  * Zones: telegram controls, pi agent commands, queue controls
  * Owns Telegram slash-command normalization, bot command metadata, pi-side command registration, and command-initiated session replacement orchestration behind runtime ports
  */
+import { randomUUID } from "node:crypto";
 import { pairTelegramUserIfNeeded, TELEGRAM_DEFAULT_PROFILE_NAME, } from "./config.js";
 import { escapeHtml } from "./rendering.js";
 import { createTelegramControlItemBuilder, createTelegramControlQueueController, createTelegramQueueAdmissionReceipt, } from "./queue.js";
@@ -241,14 +242,6 @@ function parseTelegramProfileArg(args) {
         return undefined;
     return word === TELEGRAM_DEFAULT_PROFILE_NAME ? undefined : word;
 }
-export function parseTelegramRequestedThreadName(args) {
-    const token = args
-        .trim()
-        .split(/\s+/)
-        .find((word) => /^as=/i.test(word));
-    const value = token?.slice(3).trim();
-    return value || undefined;
-}
 function formatTelegramTakeoverTitle(ctx) {
     return ctx.ui.theme.fg("accent", "pi-telegram");
 }
@@ -262,7 +255,7 @@ function formatTelegramTakeoverPrompt(ctx, owner) {
 }
 export function registerTelegramBridgeCommands(pi, deps) {
     pi.registerCommand("telegram-setup", {
-        description: "Configure Telegram bot token. Use /telegram-setup <name> for named profiles.",
+        description: "<profile> — Configure Telegram bot token",
         handler: async (args, ctx) => {
             await deps.promptForConfig(ctx, parseTelegramProfileArg(args));
         },
@@ -275,26 +268,14 @@ export function registerTelegramBridgeCommands(pi, deps) {
         },
     });
     pi.registerCommand("telegram-connect", {
-        description: "Start the Telegram bridge. Use /telegram-connect <profile> and optional as=Name for a fresh Workspace Thread.",
+        description: "<profile> — Start Telegram bridge",
         handler: async (args, ctx) => {
-            const profileName = parseTelegramProfileArg(args);
-            const requestedNameTokens = args
-                .trim()
-                .split(/\s+/)
-                .filter((word) => /^as=/i.test(word));
-            const requestedThreadName = parseTelegramRequestedThreadName(args);
-            const requestedNameError = requestedNameTokens.length > 1
-                ? "Specify at most one as=Name Workspace Thread name."
-                : requestedNameTokens.length === 1 && !requestedThreadName
-                    ? "Usage: /telegram-connect [profile] as=Flightprice"
-                    : requestedThreadName
-                        ? deps.validateThreadName?.(requestedThreadName)
-                        : undefined;
-            if (requestedNameError) {
-                ctx.ui.notify(requestedNameError, "warning");
+            if (args.trim().split(/\s+/).some((word) => /^as=/i.test(word))) {
+                ctx.ui.notify("Thread names are configured from Telegram, not from Pi commands.", "warning");
                 deps.updateStatus(ctx);
                 return;
             }
+            const profileName = parseTelegramProfileArg(args);
             if (profileName && deps.activateProfileConfig) {
                 const ok = await deps.activateProfileConfig(ctx, profileName);
                 if (!ok) {
@@ -357,7 +338,6 @@ export function registerTelegramBridgeCommands(pi, deps) {
             };
             let result = await startWithRecovery({
                 forceFreshLeaderThread: true,
-                ...(requestedThreadName ? { requestedThreadName } : {}),
             });
             if (result && !result.ok && result.canTakeover) {
                 const confirmed = await ctx.ui.confirm(formatTelegramTakeoverTitle(ctx), formatTelegramTakeoverPrompt(ctx, result.owner));
@@ -369,7 +349,6 @@ export function registerTelegramBridgeCommands(pi, deps) {
                 result = await startWithRecovery({
                     force: true,
                     forceFreshLeaderThread: true,
-                    ...(requestedThreadName ? { requestedThreadName } : {}),
                 });
             }
             if (result?.message) {
@@ -382,7 +361,7 @@ export function registerTelegramBridgeCommands(pi, deps) {
         },
     });
     pi.registerCommand("telegram-disconnect", {
-        description: "Stop Telegram; in Threaded Mode, delete this instance's current thread",
+        description: "Stop Telegram and delete current thread in Threaded Mode",
         handler: async (_args, ctx) => {
             const threadName = deps.getDisconnectThreadName?.();
             if (threadName) {
@@ -1232,8 +1211,9 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
         },
     }, commandArgs);
 }
-export const TELEGRAM_SESSION_ACTION_COMMAND_NAME = "telegram-session-action";
-export const TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION = "(internal) replace the current Pi session after Telegram settlement";
+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 function delayTelegramSessionAction(delayMs) {
     return new Promise((resolve) => setTimeout(resolve, delayMs));
 }
@@ -1364,8 +1344,7 @@ export function createTelegramSessionActionAssembly(deps) {
 export function createTelegramSessionActionRuntime(deps) {
     let pendingUpdateId;
     let pendingTarget;
-    let commandPending = false;
-    let commandUpdateId;
+    let pendingAction;
     let registered = false;
     const reportFailure = (error) => {
         try {
@@ -1380,33 +1359,34 @@ export function createTelegramSessionActionRuntime(deps) {
             if (registered)
                 return;
             registered = true;
-            deps.registerCommand(TELEGRAM_SESSION_ACTION_COMMAND_NAME, {
-                description: TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION,
-                handler: async (_args, ctx) => {
-                    if (!commandPending)
+            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;
-                    commandPending = false;
-                    const target = pendingTarget;
-                    const updateId = commandUpdateId;
-                    pendingTarget = undefined;
-                    commandUpdateId = undefined;
-                    if (!target || updateId === undefined)
-                        return;
-                    try {
-                        await deps.prepareReplacement?.(ctx, updateId, target);
-                        const result = await ctx.newSession();
-                        if (result.cancelled)
-                            await deps.notifyResult(target, "cancelled");
                     }
-                    catch (error) {
-                        reportFailure(error);
-                        await deps.notifyResult(target, "failure");
+                    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;
                     }
                 },
             });
         },
         scheduleAfterUpdate(updateId, target) {
-            if (pendingUpdateId !== undefined || commandPending)
+            if (pendingUpdateId !== undefined || pendingAction !== undefined)
                 return false;
             pendingUpdateId = updateId;
             pendingTarget = { ...target };
@@ -1416,21 +1396,23 @@ export function createTelegramSessionActionRuntime(deps) {
             if (pendingUpdateId !== updateId)
                 return;
             pendingUpdateId = undefined;
-            commandUpdateId = updateId;
-            commandPending = true;
+            const target = pendingTarget;
+            pendingTarget = undefined;
+            if (!target)
+                return;
+            const token = randomUUID();
+            pendingAction = { kind: "replace-session", token, updateId, target };
             void Promise.resolve()
-                .then(() => deps.sendUserMessage(`/${TELEGRAM_SESSION_ACTION_COMMAND_NAME}`, {
+                .then(() => deps.sendUserMessage(`/${TELEGRAM_INTERNAL_COMMAND_NAME} ${token}`, {
                 expandPromptTemplates: true,
             }))
                 .catch((error) => {
-                commandPending = false;
-                commandUpdateId = undefined;
-                pendingTarget = undefined;
+                pendingAction = undefined;
                 reportFailure(error);
             });
         },
         hasPending() {
-            return pendingUpdateId !== undefined || commandPending;
+            return pendingUpdateId !== undefined || pendingAction !== undefined;
         },
     };
 }

package/dist/lib/extension.js

@@ -689,6 +689,7 @@ export default function (pi) {
         storeModelMenuState: modelMenuRuntime.storeState,
         updateStatusMessage: menuActions.updateStatusMessage,
         updateStatus,
+        dismissGuestPlaceholder: guestPlaceholderRuntime.dismiss,
     });
     const threadDisplaySettingsRuntime = ThreadDisplay.createTelegramThreadDisplaySettingsRuntime({
         getTarget() {
@@ -1449,10 +1450,6 @@ export default function (pi) {
                 return undefined;
             return record.threadName ?? "current Telegram thread";
         },
-        setRequestedThreadNameForPollingStart: telegramThreadCapabilityState.setRequestedThreadName,
-        validateThreadName(threadName) {
-            return Threads.getTelegramTopicThreadNameValidationError(threadName, undefined);
-        },
         onTransportChanged() {
             deliveryLifecycleRuntime.onSessionStart();
             activityVerbosityRuntime.reset();

package/dist/lib/menu-queue.d.ts

@@ -33,5 +33,6 @@ export declare function createTelegramQueueMenuRuntime<Context, TModel extends M
     storeModelMenuState: (state: TelegramModelMenuState<TModel>) => void;
     updateStatusMessage: (state: TelegramModelMenuState<TModel>, ctx: Context) => Promise<void>;
     updateStatus: (ctx: Context) => void;
+    dismissGuestPlaceholder?: (inlineMessageId: string) => Promise<void>;
 }): TelegramQueueMenuRuntime<Context>;
 export {};

package/dist/lib/menu-queue.js

@@ -34,6 +34,8 @@ function toTelegramQueueMenuItems(items) {
         return {
             chatId: item.chatId,
             replyToMessageId: item.replyToMessageId,
+            queueOrder: item.queueOrder,
+            isGuest: item.kind === "prompt" && item.guestQueryId !== undefined,
             queuePosition: index + 1,
             isPriority: item.queueLane === "priority",
             priorityEmoji: item.kind === "prompt" ? item.priorityEmoji : undefined,
@@ -72,7 +74,9 @@ function buildTelegramQueueMenuReplyMarkup(items, emptyRefreshIndex = 0) {
         return [
             {
                 text: label,
-                callback_data: `queue:pick:${item.chatId}:${item.replyToMessageId}`,
+                callback_data: item.isGuest
+                    ? `queue:guest-pick:${item.queueOrder}`
+                    : `queue:pick:${item.chatId}:${item.replyToMessageId}`,
             },
         ];
     });
@@ -128,6 +132,19 @@ function getTelegramQueueMenuItemText(item) {
     const preview = `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
     return `${heading}\n${preview}`;
 }
+function buildTelegramGuestQueueItemSubmenuReplyMarkup(queueOrder) {
+    return {
+        inline_keyboard: [
+            [{ text: "⬆️ Back", callback_data: "queue:list" }],
+            [
+                {
+                    text: "🔴 Skip",
+                    callback_data: `queue:guest-skip:${queueOrder}`,
+                },
+            ],
+        ],
+    };
+}
 function buildTelegramQueueItemSubmenuReplyMarkup(chatId, replyToMessageId, isPriority, isSkipped) {
     return {
         inline_keyboard: [
@@ -171,6 +188,21 @@ async function handleTelegramQueueMenuCallback(callbackQueryId, data, replyChatI
         await updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMessageId, deps, undefined, refreshMatch[1] === undefined ? 0 : Number(refreshMatch[1]));
         return true;
     }
+    const guestPickMatch = data.match(/^queue:guest-pick:(\d+)$/);
+    if (guestPickMatch) {
+        await handleTelegramGuestQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, Number(guestPickMatch[1]), deps);
+        return true;
+    }
+    const guestSkipMatch = data.match(/^queue:guest-skip:(\d+)$/);
+    if (guestSkipMatch) {
+        const skipped = await deps.skipGuest(Number(guestSkipMatch[1]), ctx);
+        if (!skipped) {
+            await refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+            return true;
+        }
+        await updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMessageId, deps, "Guest prompt skipped.");
+        return true;
+    }
     const pickMatch = data.match(/^queue:pick:(\d+):(\d+)$/);
     if (pickMatch) {
         await handleTelegramQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, Number(pickMatch[1]), Number(pickMatch[2]), deps);
@@ -208,6 +240,14 @@ async function updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMe
 async function refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps) {
     await updateTelegramQueueMenuList(callbackQueryId, replyChatId, replyMessageId, deps, "Item no longer in queue.");
 }
+async function handleTelegramGuestQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, queueOrder, deps) {
+    const item = deps.findGuestItem(queueOrder);
+    if (!item) {
+        return refreshStaleTelegramQueueMenuItem(callbackQueryId, replyChatId, replyMessageId, deps);
+    }
+    await deps.updateQueueMessage(replyChatId, replyMessageId, getTelegramQueueMenuItemText(item), buildTelegramGuestQueueItemSubmenuReplyMarkup(queueOrder));
+    await deps.answerCallbackQuery(callbackQueryId);
+}
 async function handleTelegramQueueMenuPick(callbackQueryId, replyChatId, replyMessageId, chatId, msgId, deps) {
     const item = deps.findItem(chatId, msgId);
     if (!item) {
@@ -272,6 +312,7 @@ export function createTelegramQueueMenuRuntime(deps) {
             updateStatusMessage: deps.updateStatusMessage,
             answerCallbackQuery: deps.answerCallbackQuery,
             updateStatus: deps.updateStatus,
+            dismissGuestPlaceholder: deps.dismissGuestPlaceholder,
         }),
     };
 }
@@ -318,9 +359,22 @@ function createQueueMenuCallbackHandler(deps) {
         const findItem = (cId, rId) => {
             return findTelegramQueueMenuItem(toMenuItems(), cId, rId);
         };
+        const findGuestItem = (queueOrder) => {
+            return toMenuItems().find((item) => {
+                return item.isGuest && item.queueOrder === queueOrder;
+            });
+        };
         return handleTelegramQueueMenuCallback(query.id, data, chatId, messageId, ctx, {
             getQueuedItems: toMenuItems,
             findItem,
+            findGuestItem,
+            skipGuest: (queueOrder, callbackContext) => {
+                return skipQueuedTelegramGuestPrompt(queueOrder, callbackContext, {
+                    getQueueSnapshot,
+                    queueMutationRuntime: deps.queueMutationRuntime,
+                    dismissGuestPlaceholder: deps.dismissGuestPlaceholder,
+                });
+            },
             togglePriority: (cId, rId) => {
                 return toggleQueuedTelegramPromptPriority(cId, rId, ctx, {
                     getQueueSnapshot,
@@ -345,6 +399,23 @@ function createQueueMenuCallbackHandler(deps) {
         });
     };
 }
+async function skipQueuedTelegramGuestPrompt(queueOrder, ctx, deps) {
+    const item = deps.getQueueSnapshot().find((candidate) => {
+        return candidate.kind === "prompt" &&
+            candidate.guestQueryId !== undefined &&
+            candidate.queueOrder === queueOrder;
+    });
+    if (!item || !deps.queueMutationRuntime.removeGuestPromptByQueueOrder) {
+        return false;
+    }
+    const removed = deps.queueMutationRuntime.removeGuestPromptByQueueOrder(queueOrder, ctx);
+    if (!removed)
+        return false;
+    if (item.guestInlineMessageId && deps.dismissGuestPlaceholder) {
+        await deps.dismissGuestPlaceholder(item.guestInlineMessageId);
+    }
+    return true;
+}
 function getQueueMenuReactionDisposition(item, priority, skipped) {
     if (priority && skipped) {
         return {