@llblab/pi-kit 0.18.0 → 0.18.2

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: () =>