@llblab/pi-telegram 0.49.0 → 0.50.1

package/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/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/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/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/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/dist/package.json

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

package/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.
@@ -610,7 +612,7 @@ Queue reaction behavior, lane-tail transitions, Keep/Skip independence, multi-re
 
 Complete intermediate assistant text blocks from Telegram-originated activity are sent once to the immutable originating target before active-turn final delivery; final and terminal-partial segments stay with settlement so replies are not duplicated. While this instance has exact direct or follower transport authority, completed public blocks from local/autonomous work are always sent once and in source order to the instance's authorized target. Connected companion projection is not configurable; disconnect or authority loss is its boundary. Both paths use the configured Rich or HTML renderer and exclude reasoning, tool traffic, token deltas, local prompt text, unknown sources, and stale generations. Each admitted block remains fenced to its exact target, profile/token stamp, leader epoch or follower registration generation, and session generation; non-idempotent acknowledgement ambiguity never authorizes replay.
 
-`assistant.activity` is an independent bridge-owned projection over normalized Activity events. Each process reloads the shared file-backed setting at `agent-start` before activity admission, so multi-instance mode cannot continue projecting a stale broader process-local selection. Omitted values resolve to `verbose`, while invalid values fail closed to `quiet`; `thinking` and `tools` select one technical class, while `verbose` enables both. Provider-exposed thinking uses persistent ordinary HTML containing only a standard expandable blockquote with a bounded redacted latest-text window and inline Markdown rendered as Telegram HTML. Completed executed tools use native Rich Messages: each closed `<Tool>: <status>` root details node renders snake-case names as title words while preserving an uppercase two- or three-letter repeated prefix per word, then the native disclosure chevron reveals an open-by-default `arguments` child plus closed retained `update N` and `result`/`error` child details with lowercase monospaced, marker-free summaries and JSON pre blocks; known-safe Rich rejections fall back to the previous HTML disclosure. The projection captures the exact target and transport stamp at activity admission, serializes updates, preserves tool-start order, closes coalescing across assistant/thinking boundaries, bounds retained text/update memory plus edit frames and message/tool size, disables previews and HTTP(S) auto-link recognition inside technical evidence, and never replays a possibly committed send. Session generations own independent queues, so replacement drops queued old work without waiting on an old call. Bridge-owned assistant output and activity projection share one activity-publication sequence admitted synchronously from the activity bus, so later tool disclosures cannot overtake earlier assistant blocks. Activity targets and transport authority are captured before queued work starts. Active Telegram-turn final replies/artifacts and automatic compaction notices use that same publication owner before the existing direct/follower transport split, without mutually waiting on separate output tails. Final settlement captures the exact active turn and assistant result and reserves its publication position before config loading. Empty outcomes without a publication candidate reserve no position. Replacement, preparation failure, or an unused reservation releases the position without resetting or replying for a replacement turn. Final errors also publish through this owner. Reservations accept one task; cancellation cannot undo a published task, and session reset releases unresolved reservations while fencing old queued tasks. Terminal assistant messages with a publication candidate reserve the final position synchronously; settlement consumes that reservation only for the exact originating turn. Compaction notices enter the same queue immediately, behind the reserved final rather than through a separate notice buffer. Settlement, a new agent run, or session replacement cancels an unconsumed reservation. Notice target and authority are captured when the event is observed. Pi lifecycle completion does not wait for network publication. This order is process-local and does not serialize unrelated instances or independent registered activity handlers. Settlement, replacement, disconnect, failure, or stale authority clears only local ownership; already-sent activity messages remain in chat.
+`assistant.activity` is an independent bridge-owned projection over normalized Activity events. Each process reloads the shared file-backed setting at `agent-start` before activity admission, so multi-instance mode cannot continue projecting a stale broader process-local selection. Omitted values resolve to `verbose`, while invalid values fail closed to `quiet`; `thinking` and `tools` select one technical class, while `verbose` enables both. Provider-exposed thinking uses persistent ordinary HTML containing only a standard expandable blockquote with a bounded redacted latest-text window and inline Markdown rendered as Telegram HTML. Like answer drafts, it accumulates for two seconds before the first frame, publishes at most one update every two seconds, and flushes remaining buffered reasoning on terminal completion. Completed executed tools use native Rich Messages: each closed `<Tool>: <status>` root details node renders snake-case names as title words while preserving an uppercase two- or three-letter repeated prefix per word, then the native disclosure chevron reveals an open-by-default `arguments` child plus closed retained `update N` and `result`/`error` child details with lowercase monospaced, marker-free summaries and JSON pre blocks; known-safe Rich rejections fall back to the previous HTML disclosure. The projection captures the exact target and transport stamp at activity admission, serializes updates, preserves tool-start order, closes coalescing across assistant/thinking boundaries, bounds retained text/update memory plus edit frames and message/tool size, disables previews and HTTP(S) auto-link recognition inside technical evidence, and never replays a possibly committed send. Session generations own independent queues, so replacement drops queued old work without waiting on an old call. Bridge-owned assistant output and activity projection share one activity-publication sequence admitted synchronously from the activity bus, so later tool disclosures cannot overtake earlier assistant blocks. Activity targets and transport authority are captured before queued work starts. Active Telegram-turn final replies/artifacts and automatic compaction notices use that same publication owner before the existing direct/follower transport split, without mutually waiting on separate output tails. Final settlement captures the exact active turn and assistant result and reserves its publication position before config loading. Empty outcomes without a publication candidate reserve no position. Replacement, preparation failure, or an unused reservation releases the position without resetting or replying for a replacement turn. Final errors also publish through this owner. Reservations accept one task; cancellation cannot undo a published task, and session reset releases unresolved reservations while fencing old queued tasks. Terminal assistant messages with a publication candidate reserve the final position synchronously; settlement consumes that reservation only for the exact originating turn. Compaction notices enter the same queue immediately, behind the reserved final rather than through a separate notice buffer. Settlement, a new agent run, or session replacement cancels an unconsumed reservation. Notice target and authority are captured when the event is observed. Pi lifecycle completion does not wait for network publication. This order is process-local and does not serialize unrelated instances or independent registered activity handlers. Settlement, replacement, disconnect, failure, or stale authority clears only local ownership; already-sent activity messages remain in chat.
 
 Telegram prompt guidance is context- and authority-aware. The package and source-checkout extension contribute `telegram-bridge`, optional `generated-control-surface`, and `generative-apps` Skills through Pi resource discovery. Generated Control Surface treats `interface = f(state, capabilities, intent)` as a renderer-neutral primitive, compiling transient evidence-backed controls over domain-owned workflows, systems, navigation, supervision, and decisions without creating parallel application state. It composes an ordered ragged sequence of independently sized semantic rows rather than filling a rectangular grid: compact rows contain genuine peers, singleton rows isolate structurally independent actions, and rectangular layouts remain reserved for genuinely spatial state. Text-bearing controls use at most two columns and flow into additional rows, while denser rows are reserved for short position-bearing glyphs or codes and never exceed the eight-column phone-width UX maximum. Vertical extent is independent: a true spatial surface may retain substantially more rows, while non-spatial button walls route to grouping, disclosure, or pagination. Symmetry is treated as an evidence claim about equal relationships or real spatial topology; an abstract layout catalog supplies adaptable singleton, peer, staged, navigational, repeated-pair, and rectangular shapes without forcing tasks into preset grids. Repeated controls carry the smallest sufficient action delta when visible conversation is unambiguous; larger or error-prone state moves to a deterministic task-owned Markdown artifact, correctness-sensitive transitions move to a small domain-owned transition implementation, and repeated clicks are adjudicated against current state rather than stale button appearance. Its filesystem adapter reserves the first full-width row for parent traversal outside root, places available Previous/Next controls together in one compact row immediately afterward, orders visible directories, hidden directories, visible files, and hidden files alphabetically within each category before fixed ten-entry pagination, renders path/range metadata as stacked status-style key-value rows instead of middle-dot prose, emits the complete Telegram control set through one JSON-matrix action, suppresses duplicate plain/monospaced listings and default Refresh unless user preference overrides presentation, and retains an ordinary numbered fallback when buttons are unavailable. Only an exact direct owner or live registered follower exposes the two pi-telegram delivery tools, their active-tool metadata, and the compact routing suffix. Disconnect or authority loss removes those tool surfaces for subsequent requests without touching foreign tools; reconnect/recovery restores only the pi-telegram subset that was active before suspension, including across same-process reload. Repeated stable interactions may graduate from that model-mediated surface into a reviewed Generative App whose deterministic bound methods bypass Pi queue admission; the `generative-apps` Skill owns this compilation and operating workflow while the underlying capability retains domain authority. Telegram-originated turns route to the stable Skill contracts and retain dynamic blocks such as `[voice] delivery: automatic voice`; the Skills and public documentation own syntax, target routing, Threaded Mode behavior, Generative App operation, and diagnostics.
 

package/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/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.
 
@@ -51,7 +51,7 @@ Stable commands inside Pi:
 Stable commands inside the paired Telegram DM:
 
 - `/start` — pair when needed and open the main application menu.
-- `/new` — after idle and empty-queue checks, request a new Pi session in the current classic chat or Thread. The bridge acknowledges the callback, deletes its confirmation, completes and removes the exact durable update, then dispatches an internal Pi command through `pi.sendUserMessage(..., { expandPromptTemplates: true })`. Its real `ExtensionCommandContext` calls `ctx.newSession()`; one discriminated durable intent preserves either exact classic Profile/CWD/session/chat continuity or the Thread binding with slot/name re-key. The successor CAS-claims that intent before sending one terminal result. Busy, identity-mismatch, and unavailable-host paths fail closed.
+- `/new` — after idle and empty-queue checks, request a new Pi session in the current classic chat or Thread. The bridge acknowledges the callback, deletes its confirmation, completes and removes the exact durable update, then dispatches one runtime-armed typed action through the internal `/telegram-internal` Pi gateway using `pi.sendUserMessage(..., { expandPromptTemplates: true })`. Manual invocation reports that the gateway cannot be run manually; the armed handler receives a real `ExtensionCommandContext` and calls `ctx.newSession()`; one discriminated durable intent preserves either exact classic Profile/CWD/session/chat continuity or the Thread binding with slot/name re-key. The successor CAS-claims that intent before sending one terminal result. Busy, identity-mismatch, and unavailable-host paths fail closed.
 - `/compact` — open confirmation and compact when idle.
 - `/next` — abort active work first when needed, let the interrupted prompt receive its abort notice, then reply `Dispatching next queued turn.` to the exact queued prompt selected for the next model turn. The command itself is never the lifecycle-notice reply target, and aborted pending assistant text is suppressed.
 - `/continue` — enqueue a priority `continue` prompt.

package/lib/activity-verbosity.ts

@@ -24,7 +24,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;
 
 interface ToolActivity {
@@ -325,6 +327,11 @@ export 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;
@@ -360,11 +367,18 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
   let reasoningMessage: ReasoningMessage | undefined;
   let reasoningBlocked = false;
   let lastReasoningPublishMs = 0;
+  let reasoningFlushTimer: ReturnType<typeof setTimeout> | undefined;
   let toolMessage: ToolMessage | undefined;
   const tools = new Map<string, ToolActivity>();
   const toolOrder: string[] = [];
 
+  const clearReasoningFlushTimer = () => {
+    if (!reasoningFlushTimer) return;
+    (deps.clearReasoningTimeout ?? clearTimeout)(reasoningFlushTimer);
+    reasoningFlushTimer = undefined;
+  };
   const clearActivity = () => {
+    clearReasoningFlushTimer();
     activityId = undefined;
     authority = undefined;
     target = undefined;
@@ -466,6 +480,33 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       );
     }
   };
+  const scheduleReasoningPublish = (
+    event: TelegramActivityEvent,
+    acceptedGeneration: number,
+  ) => {
+    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: () => Promise<void>) => tail.then(next));
+      tail = enqueue(task).catch((error) => {
+        deps.recordFailure?.("reasoning-send", event, error);
+      });
+    }, delayMs) as ReturnType<typeof setTimeout>;
+    reasoningFlushTimer?.unref?.();
+  };
   const publishTool = async (
     event: TelegramActivityEvent,
     tool: ToolActivity,
@@ -602,13 +643,8 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       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;
     }
@@ -620,6 +656,7 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
           -TELEGRAM_REASONING_BUFFER_MAX_CHARS,
         );
       }
+      clearReasoningFlushTimer();
       if (
         reasoningChars > 0 &&
         reasoningChars > lastReasoningMessageChars &&
@@ -687,8 +724,8 @@ export function createTelegramActivityVerbosityRuntime<TAuthority>(deps: {
       return;
     }
     if (event.type === "agent-end" || event.type === "agent-settled") {
+      clearReasoningFlushTimer();
       if (
-        reasoningMessage &&
         reasoningChars > lastReasoningMessageChars &&
         !reasoningBlocked
       ) {

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

package/lib/commands.ts

@@ -4,6 +4,8 @@
  * 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,
   type TelegramConfigStore,
@@ -366,7 +368,6 @@ export function createTelegramBotCommandRegistrar(
 export interface TelegramBridgeCommandStartPollingOptions {
   force?: boolean;
   forceFreshLeaderThread?: boolean;
-  requestedThreadName?: string;
 }
 
 export interface TelegramBridgeCommandStartPollingResult {
@@ -407,7 +408,6 @@ export interface TelegramBridgeCommandRegistrationDeps {
     ctx: ExtensionCommandContext,
     profileName: string,
   ) => Promise<boolean>;
-  validateThreadName?: (threadName: string) => string | undefined;
 }
 
 export type TelegramThreadDisplayNameRenamePort = (
@@ -466,17 +466,6 @@ function parseTelegramProfileArg(args: string): string | undefined {
   return word === TELEGRAM_DEFAULT_PROFILE_NAME ? undefined : word;
 }
 
-export function parseTelegramRequestedThreadName(
-  args: string,
-): string | undefined {
-  const token = args
-    .trim()
-    .split(/\s+/)
-    .find((word) => /^as=/i.test(word));
-  const value = token?.slice(3).trim();
-  return value || undefined;
-}
-
 function formatTelegramTakeoverTitle(ctx: ExtensionCommandContext): string {
   return ctx.ui.theme.fg("accent", "pi-telegram");
 }
@@ -498,7 +487,7 @@ export function registerTelegramBridgeCommands(
   deps: TelegramBridgeCommandRegistrationDeps,
 ): void {
   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));
     },
@@ -513,28 +502,17 @@ export function registerTelegramBridgeCommands(
     },
   });
   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) {
@@ -597,7 +575,6 @@ export function registerTelegramBridgeCommands(
       };
       let result = await startWithRecovery({
         forceFreshLeaderThread: true,
-        ...(requestedThreadName ? { requestedThreadName } : {}),
       });
       if (result && !result.ok && result.canTakeover) {
         const confirmed = await ctx.ui.confirm(
@@ -612,7 +589,6 @@ export function registerTelegramBridgeCommands(
         result = await startWithRecovery({
           force: true,
           forceFreshLeaderThread: true,
-          ...(requestedThreadName ? { requestedThreadName } : {}),
         });
       }
       if (result?.message) {
@@ -625,8 +601,7 @@ export function registerTelegramBridgeCommands(
     },
   });
   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) {
@@ -2335,9 +2310,11 @@ async function handleTelegramCommandRuntime<
   );
 }
 
-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: number): Promise<void> {
   return new Promise<void>((resolve) => setTimeout(resolve, delayMs));
@@ -2538,6 +2515,13 @@ export function createTelegramSessionActionAssembly(
   return { action, settlement };
 }
 
+type TelegramPendingInternalAction = {
+  kind: "replace-session";
+  token: string;
+  updateId: number;
+  target: { chatId: number; threadId?: number; messageId: number };
+};
+
 export interface TelegramSessionActionRuntime {
   register: () => void;
   scheduleAfterUpdate: (
@@ -2557,8 +2541,7 @@ export function createTelegramSessionActionRuntime(
     threadId?: number;
     messageId: number;
   } | undefined;
-  let commandPending = false;
-  let commandUpdateId: number | undefined;
+  let pendingAction: TelegramPendingInternalAction | undefined;
   let registered = false;
 
   const reportFailure = (error: unknown): void => {
@@ -2573,29 +2556,32 @@ export function createTelegramSessionActionRuntime(
     register() {
       if (registered) return;
       registered = true;
-      deps.registerCommand(TELEGRAM_SESSION_ACTION_COMMAND_NAME, {
-        description: TELEGRAM_SESSION_ACTION_COMMAND_DESCRIPTION,
-        handler: async (_args, ctx) => {
-          if (!commandPending) 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");
+      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;
+          }
+          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) return false;
+      if (pendingUpdateId !== undefined || pendingAction !== undefined) return false;
       pendingUpdateId = updateId;
       pendingTarget = { ...target };
       return true;
@@ -2603,23 +2589,24 @@ export function createTelegramSessionActionRuntime(
     onUpdateCompleted(updateId) {
       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}`, {
+          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/lib/extension.ts

@@ -871,6 +871,7 @@ export default function (pi: Pi.ExtensionAPI) {
     storeModelMenuState: modelMenuRuntime.storeState,
     updateStatusMessage: menuActions.updateStatusMessage,
     updateStatus,
+    dismissGuestPlaceholder: guestPlaceholderRuntime.dismiss,
   });
   const threadDisplaySettingsRuntime =
     ThreadDisplay.createTelegramThreadDisplaySettingsRuntime({
@@ -1731,14 +1732,6 @@ export default function (pi: Pi.ExtensionAPI) {
       if (!record?.target.threadId) return undefined;
       return record.threadName ?? "current Telegram thread";
     },
-    setRequestedThreadNameForPollingStart:
-      telegramThreadCapabilityState.setRequestedThreadName,
-    validateThreadName(threadName) {
-      return Threads.getTelegramTopicThreadNameValidationError(
-        threadName,
-        undefined,
-      );
-    },
     onTransportChanged() {
       deliveryLifecycleRuntime.onSessionStart();
       activityVerbosityRuntime.reset();