@llblab/pi-kit 0.18.1 → 0.19.0

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

@@ -4,6 +4,13 @@
 
 ## 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.

package/node_modules/@llblab/pi-telegram/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.
 
@@ -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/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/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];
@@ -575,7 +572,7 @@ export declare function createTelegramCommandOrPromptRuntime<TMessage, TContext>
     dispatchMessages: (messages: TMessage[], ctx: TContext) => Promise<void>;
 };
 export declare const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
-export declare const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "(internal) dispatch one settled Telegram lifecycle action";
+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 {

package/node_modules/@llblab/pi-telegram/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) {
@@ -1233,7 +1212,7 @@ async function handleTelegramCommandRuntime(commandName, message, ctx, deps, com
     }, commandArgs);
 }
 export const TELEGRAM_INTERNAL_COMMAND_NAME = "telegram-internal";
-export const TELEGRAM_INTERNAL_COMMAND_DESCRIPTION = "(internal) dispatch one settled Telegram lifecycle action";
+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));
@@ -1382,9 +1361,9 @@ export function createTelegramSessionActionRuntime(deps) {
             registered = true;
             deps.registerCommand(TELEGRAM_INTERNAL_COMMAND_NAME, {
                 description: TELEGRAM_INTERNAL_COMMAND_DESCRIPTION,
-                handler: async (_args, ctx) => {
+                handler: async (args, ctx) => {
                     const action = pendingAction;
-                    if (!action) {
+                    if (!action || args.trim() !== action.token) {
                         ctx.ui.notify(TELEGRAM_INTERNAL_MANUAL_USE_MESSAGE, "warning");
                         return;
                     }
@@ -1421,9 +1400,10 @@ export function createTelegramSessionActionRuntime(deps) {
             pendingTarget = undefined;
             if (!target)
                 return;
-            pendingAction = { kind: "replace-session", updateId, target };
+            const token = randomUUID();
+            pendingAction = { kind: "replace-session", token, updateId, target };
             void Promise.resolve()
-                .then(() => deps.sendUserMessage(`/${TELEGRAM_INTERNAL_COMMAND_NAME}`, {
+                .then(() => deps.sendUserMessage(`/${TELEGRAM_INTERNAL_COMMAND_NAME} ${token}`, {
                 expandPromptTemplates: true,
             }))
                 .catch((error) => {

package/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/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 {

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

@@ -242,6 +242,11 @@ export declare function removeTelegramQueueItemsByMessageIds<TContext = unknown>
     removedItems: TelegramQueueItem<TContext>[];
     removedCount: number;
 };
+export declare function removeTelegramQueuedGuestPromptByOrder<TContext = unknown>(items: TelegramQueueItem<TContext>[], queueOrder: number): {
+    items: TelegramQueueItem<TContext>[];
+    removedItems: PendingTelegramTurn[];
+    removedCount: number;
+};
 export declare function applyTelegramQueuePromptReactionDisposition<TContext = unknown>(items: TelegramQueueItem<TContext>[], messageId: number, disposition: TelegramQueueReactionDisposition, destinationLaneOrder?: number, scope?: TelegramQueueMessageScope): {
     items: TelegramQueueItem<TContext>[];
     changed: boolean;
@@ -624,6 +629,7 @@ export interface TelegramQueueMutationController<TContext> {
     reorder: (ctx: TContext) => void;
     clear: (ctx: TContext) => number;
     removeByMessageIds: (messageIds: number[], ctx: TContext, scope?: TelegramQueueMessageScope) => number;
+    removeGuestPromptByQueueOrder?: (queueOrder: number, ctx: TContext) => boolean;
     applyReactionByMessageId: (messageId: number, disposition: TelegramQueueReactionDisposition, ctx: TContext, scope?: TelegramQueueMessageScope) => boolean;
 }
 export interface TelegramControlQueueControllerDeps<TContext> {
@@ -673,6 +679,7 @@ export declare function createTelegramQueueMutationController<TContext>(deps: Te
 export declare function reorderTelegramQueueItemsRuntime<TContext>(deps: TelegramQueueMutationRuntimeDeps<TContext>): void;
 export declare function clearTelegramQueueItemsRuntime<TContext>(deps: TelegramQueueMutationRuntimeDeps<TContext>): number;
 export declare function removeTelegramQueueItemsByMessageIdsRuntime<TContext>(messageIds: number[], deps: TelegramQueueMutationRuntimeDeps<TContext>, scope?: TelegramQueueMessageScope): number;
+export declare function removeTelegramQueuedGuestPromptByOrderRuntime<TContext>(queueOrder: number, deps: TelegramQueueMutationRuntimeDeps<TContext>): boolean;
 export declare function applyTelegramQueuePromptReactionDispositionRuntime<TContext>(messageId: number, disposition: TelegramQueueReactionDisposition, deps: TelegramQueueMutationRuntimeDeps<TContext>, scope?: TelegramQueueMessageScope): boolean;
 export declare function enqueueTelegramPromptTurnRuntime<TMessage, TContext = unknown>(messages: TMessage[], deps: TelegramPromptEnqueueRuntimeDeps<TMessage, TContext>): Promise<PendingTelegramTurn>;
 export declare function createTelegramPromptEnqueueController<TMessage, TContext = unknown>(deps: TelegramPromptEnqueueControllerDeps<TMessage, TContext>): TelegramPromptEnqueueController<TMessage, TContext>;

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

@@ -491,6 +491,21 @@ export function removeTelegramQueueItemsByMessageIds(items, messageIds, scope) {
         removedCount: removedItems.length,
     };
 }
+export function removeTelegramQueuedGuestPromptByOrder(items, queueOrder) {
+    const index = items.findIndex((item) => {
+        return isPendingTelegramTurn(item) &&
+            item.guestQueryId !== undefined &&
+            item.queueOrder === queueOrder;
+    });
+    if (index < 0)
+        return { items, removedItems: [], removedCount: 0 };
+    const removedItem = items[index];
+    return {
+        items: [...items.slice(0, index), ...items.slice(index + 1)],
+        removedItems: [removedItem],
+        removedCount: 1,
+    };
+}
 export function applyTelegramQueuePromptReactionDisposition(items, messageId, disposition, destinationLaneOrder, scope) {
     let nextItems = items;
     for (const [index, item] of items.entries()) {
@@ -1440,6 +1455,7 @@ export function createTelegramQueueMutationController(deps) {
         reorder: (ctx) => reorderTelegramQueueItemsRuntime(buildRuntimeDeps(ctx)),
         clear: (ctx) => clearTelegramQueueItemsRuntime(buildRuntimeDeps(ctx)),
         removeByMessageIds: (messageIds, ctx, scope) => removeTelegramQueueItemsByMessageIdsRuntime(messageIds, buildRuntimeDeps(ctx), scope),
+        removeGuestPromptByQueueOrder: (queueOrder, ctx) => removeTelegramQueuedGuestPromptByOrderRuntime(queueOrder, buildRuntimeDeps(ctx)),
         applyReactionByMessageId: (messageId, disposition, ctx, scope) => applyTelegramQueuePromptReactionDispositionRuntime(messageId, disposition, buildRuntimeDeps(ctx), scope),
     };
 }
@@ -1492,6 +1508,17 @@ export function removeTelegramQueueItemsByMessageIdsRuntime(messageIds, deps, sc
     updateTelegramQueueStatusRuntime(deps);
     return removedCount;
 }
+export function removeTelegramQueuedGuestPromptByOrderRuntime(queueOrder, deps) {
+    const { items, removedItems, removedCount } = removeTelegramQueuedGuestPromptByOrder(deps.getQueuedItems(), queueOrder);
+    if (removedCount === 0)
+        return false;
+    // A menu Skip means permanent discard, so settle durable admission before
+    // removing the live item. A failed settlement keeps the prompt retryable.
+    deps.onItemsDiscarded?.(removedItems, deps.ctx);
+    deps.setQueuedItems(items);
+    updateTelegramQueueStatusRuntime(deps);
+    return true;
+}
 export function applyTelegramQueuePromptReactionDispositionRuntime(messageId, disposition, deps, scope) {
     const queuedItems = deps.getQueuedItems();
     const changesLane = queuedItems.some((item) => {

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

@@ -190,6 +190,7 @@ export declare const TELEGRAM_GUEST_PLACEHOLDER_FRAME_MS = 1000;
 export declare const TELEGRAM_GUEST_PLACEHOLDER_MIN_MS = 20000;
 export declare const TELEGRAM_GUEST_PLACEHOLDER_MAX_MS = 26000;
 export declare const TELEGRAM_GUEST_PLACEHOLDER_FRAMES: readonly ["<b>🌎 Working on it.</b>", "<b>🌍 Working on it.</b>", "<b>🌏 Working on it..</b>", "<b>🌎 Working on it..</b>", "<b>🌍 Working on it...</b>", "<b>🌏 Working on it...</b>"];
+export declare const TELEGRAM_DISMISSED_GUEST_PLACEHOLDER_TEXT = "\u2063";
 export declare function buildTelegramGuestPlaceholderFrame(step: number): string;
 export interface TelegramGuestPlaceholderRuntimeDeps {
     editGuestInlineMessage: (inlineMessageId: string, content: {
@@ -211,5 +212,7 @@ export interface TelegramGuestPlaceholderRuntime {
     stop: (inlineMessageId: string) => Promise<void>;
     /** Cancels every loop without waiting for in-flight edits (session shutdown). */
     stopAll: () => void;
+    /** Stops rotation and visually clears the inline placeholder. */
+    dismiss: (inlineMessageId: string) => Promise<void>;
 }
 export declare function createTelegramGuestPlaceholderRuntime(deps: TelegramGuestPlaceholderRuntimeDeps): TelegramGuestPlaceholderRuntime;

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

@@ -612,6 +612,9 @@ export const TELEGRAM_GUEST_PLACEHOLDER_FRAMES = [
     "<b>🌍 Working on it...</b>",
     "<b>🌏 Working on it...</b>",
 ];
+// Telegram does not expose deletion for inline messages. This non-printing,
+// non-empty edit visually clears a guest placeholder after its query is skipped.
+export const TELEGRAM_DISMISSED_GUEST_PLACEHOLDER_TEXT = "\u2063";
 export function buildTelegramGuestPlaceholderFrame(step) {
     const frames = TELEGRAM_GUEST_PLACEHOLDER_FRAMES;
     const index = ((step % frames.length) + frames.length) % frames.length;
@@ -734,5 +737,19 @@ export function createTelegramGuestPlaceholderRuntime(deps) {
             }
             sessions.clear();
         },
+        async dismiss(inlineMessageId) {
+            await stop(inlineMessageId);
+            try {
+                await deps.editGuestInlineMessage(inlineMessageId, {
+                    text: TELEGRAM_DISMISSED_GUEST_PLACEHOLDER_TEXT,
+                    parseMode: "HTML",
+                });
+            }
+            catch (error) {
+                deps.recordRuntimeEvent?.("guest", error, {
+                    phase: "guest-placeholder-dismiss",
+                });
+            }
+        },
     };
 }

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

@@ -381,7 +381,14 @@ export async function ensureTelegramLeaderThreadBinding(deps) {
         assertLeaderEpoch("before-workspace-persist");
         await deps.topicTargetStore.persist();
         assertLeaderEpoch("after-workspace-persist");
-        return { ...result, ...(committed.displayTitle ? { displayTitle: committed.displayTitle } : {}) };
+        const { target: _target, slot: _slot, threadName: _threadName, displayTitle: _displayTitle, ...rest } = result;
+        return {
+            ...rest,
+            target: { ...committed.target },
+            slot: committed.slot ?? result.slot,
+            ...(committed.threadName ? { threadName: committed.threadName } : {}),
+            ...(committed.displayTitle ? { displayTitle: committed.displayTitle } : {}),
+        };
     };
     try {
         const unavailableTargetKeys = new Set([

package/node_modules/@llblab/pi-telegram/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.50.0",
+  "version": "0.50.1",
   "private": false,
   "publishConfig": {
     "access": "public"

package/node_modules/@llblab/pi-telegram/docs/architecture.md

@@ -480,6 +480,8 @@ Priority and Skip may coexist, including `👍 + 💩`. The prompt remains at it
 
 Menu and reaction controls share the same canonical queue state. A menu Keep can clear internal Skip without changing Priority or queue position, but Telegram's Bot API cannot remove a reaction created by the user; the visible user reaction can therefore remain until that user removes it. Once Pi has consumed or dropped a prompt, later reactions cannot retract or restore it.
 
+Guest Mode is the deliberate exception to deferred Keep/Skip semantics. A guest prompt has no source message reaction surface and may share zero-valued chat/message placeholders with other guest prompts, so queue-menu callbacks address it by immutable `queueOrder` and expose an immediate `Skip`. The leader settles its durable admission, removes it while other agent work may continue, stops placeholder animation, and replaces the inline globe placeholder with non-printing content. Bot API inline messages have no delete method, so this visual clear is the supported deletion equivalent. The guest prompt never reaches a model turn.
+
 Admission and planning validate lane contracts. Invalid lane/kind pairings fail predictably instead of being silently coerced.
 
 Prompt preparation completes downloads, inbound handlers, and binary image reads before synchronous final assembly and queue commit. Enqueue captures only intended abort-history identities before preparation; afterward it reads the current queue, folds surviving selected prompts using their current text and receipts, allocates the new turn's order, and appends without another asynchronous boundary. The handed-off head remains in place until `agent_start` consumes it, even if preparation finishes first. Concurrent arrivals, removals, and lane/reaction edits remain intact; preparation failure or stale-generation completion leaves intervening queue changes untouched.

package/node_modules/@llblab/pi-telegram/docs/multi-instance-bus.md

@@ -186,7 +186,7 @@ Status: locally implemented and validated for the next minor release; final comp
 
 A durable Workspace binding is owned by the selected bot profile plus `{ cwd, sessionId? }`. `cwd` is the normalized exact full path. When present, `sessionId` is the exact non-empty bounded value returned by the public `ctx.sessionManager.getSessionId()` API. Session display names, selector positions, session file paths, process instance IDs, and lifecycle generations are metadata or transient fences, never substitutes for the stable session ID. Absence is a real identity value `{ cwd, ∅ }`, not a wildcard; malformed present values still fail closed.
 
-The persisted binding stores the exact session ID and derives its new binding key from the existing collision-verified Workspace directory key plus a full SHA-256 digest of the session ID. Exact persisted values remain the collision check; the digest is an index component, not independent authority. Reopening, `/resume`, `/continue`/continue-recent, or process replacement with the same `{ cwd, sessionId }` reclaims the same retained target and profile-wide letter when current ownership, accepted-work, admission, and retirement evidence allow it. `/new` and `/fork` produce distinct session IDs and therefore distinct bindings even in the same directory. `/reload` changes neither component.
+The persisted binding stores the exact session ID and derives its new binding key from the existing collision-verified Workspace directory key plus a full SHA-256 digest of the session ID. Exact persisted values remain the collision check; the digest is an index component, not independent authority. Reopening, `/resume`, `/continue`/continue-recent, or process replacement with the same `{ cwd, sessionId }` reclaims the same retained target and profile-wide letter when current ownership, accepted-work, admission, and retirement evidence allow it. When target deduplication resolves a provisional claim to an already retained binding, the committed binding's canonical target, slot, and generated name must drive the live record and reported result; provisional metadata must not consume a second letter. `/new` and `/fork` produce distinct session IDs and therefore distinct bindings even in the same directory. `/reload` changes neither component.
 
 Legacy cwd-only bindings remain exact compatibility identities whose absent session component is itself a unique key. They are neither wildcard session bindings nor adoption candidates: session-aware claims never stamp, migrate, consume, or restore them, and instead allocate their own `{ cwd, sessionId }` binding subject to the same global slot and protection rules. `{ cwd, ∅ }`, `{ cwd, session-a }`, and `{ cwd, session-b }` may coexist as majestic degradation for older state and peers. The 0.46 runtime reads strict legacy records as inert independent `{ cwd, ∅ }` bindings but never migrates, adopts, or routes a session through them. Protocol v2 is session-native and intentionally incompatible with protocol-v1 0.45.x peers. Upgrade requires stopping all Telegram instances first, updating them together, and then starting them again; the first v2 process becomes leader with its own session-qualified binding.
 

package/node_modules/@llblab/pi-telegram/docs/public-api.md

@@ -40,7 +40,7 @@ import {
 Stable commands inside Pi:
 
 - `/telegram-setup` — configure/update the bot token.
-- `/telegram-connect` — start polling here and acquire external Telegram control ownership. `/telegram-connect [profile] as=Name` assigns an optional unique capitalized Latin-word identity only when provisioning a fresh Workspace Thread. Accepted queue/reply state stays local if ownership later moves elsewhere. A successful command queues a hidden connection-state note for delivery with the agent's next turn without triggering one; it says Telegram is connected and that connectivity alone is not user intent.
+- `/telegram-connect` — start polling here and acquire external Telegram control ownership, optionally for a named profile. Thread names are configured from Telegram rather than Pi commands. Accepted queue/reply state stays local if ownership later moves elsewhere. A successful command queues a hidden connection-state note for delivery with the agent's next turn without triggering one; it says Telegram is connected and that connectivity alone is not user intent.
 - `/telegram-disconnect` — after destructive confirmation, stop polling and release ownership without deleting or silencing accepted local queue state. A successful command queues the corresponding hidden, non-triggering disconnected context note; cancelled or failed disconnects do not publish a false state transition. In Threaded Mode it deletes this instance's current Telegram thread; a follower waits for its active leader to confirm generation-fenced cleanup before stopping. Graceful Pi `quit` performs the same teardown without prompting, while `reload`, `new`, `resume`, and `fork` preserve same-process handoff.
 - `/telegram-status` — show connection, polling, execution, queue, and recent event diagnostics; debug output separates poller and worker progress, durable automatic-retry state, exact foreign queued-owner identity, and negotiated protocol/build/capabilities.
 

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

@@ -563,10 +563,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,
@@ -615,8 +611,6 @@ export function registerTelegramCommandsAndTools({
   stopPolling,
   recoverPollingStart,
   getDisconnectThreadName,
-  setRequestedThreadNameForPollingStart,
-  validateThreadName,
   onTransportChanged,
   getStatusLines,
   buttonActionStore,
@@ -785,20 +779,16 @@ export function registerTelegramCommandsAndTools({
     hasBotToken: configStore.hasBotToken,
     getBotTokenDiagnostic: configStore.getBotTokenDiagnostic,
     startPolling: async (ctx, options) => {
-      setRequestedThreadNameForPollingStart?.(options?.requestedThreadName);
       try {
         return await lockedPollingRuntime.start(ctx, options);
       } catch (error) {
         recordRuntimeEvent("recovery", error, { phase: "polling-start" });
         throw error;
-      } finally {
-        setRequestedThreadNameForPollingStart?.(undefined);
       }
     },
     stopPolling: stopPolling ?? lockedPollingRuntime.stop,
     recoverPollingStart,
     getDisconnectThreadName,
-    validateThreadName,
     queueAgentConnectionContext,
     updateStatus,
     getProfileNames: () =>