@llblab/pi-telegram 0.56.0 → 0.56.2

package/docs/ui-style.md

@@ -56,7 +56,7 @@ Use emoji as stable semantic markers, not decoration. Emoji carry transportable
 | `☑️` | Activate / choose this item | Model detail activation action, generated button-only choice heading | Positive selection cue; use `🟢 Active` for already-current state. |
 | `⛔️` | Cancel source routing | `⛔️ Cancel routing` chooser action and the `Routing cancelled` toast | Not an abort of active Pi work. Private retention remains mandatory; disposable-tab removal stays bound to exact eligible target authority and follows only once every input in the tab is resolved. |
 | `❌` | No / cancel / terminal failure | Confirmation cancel buttons and terminal failure notices | Do not use for a recoverable operation failure that leaves session state intact. |
-| `🗑` | Delete / defer removal | Destructive confirmations and removal reaction | In the queue menu, reversible Keep/Skip selectors replace immediate deletion. |
+| `🗑` | Delete | Destructive confirmations | Not a queue reaction shortcut; queue menus use reversible Keep/Skip selectors. |
 
 ### Informational Feedback
 
@@ -96,14 +96,10 @@ The menu may clear internal Skip but cannot remove a reaction created by the use
 | --- | --- | --- | --- |
 | `👍` | Promote to priority | Queue reaction shortcut | Normalized from variants like `👍️`. |
 | `⚡` | Producer-owned Control marker | Control queue rows | Not a positive-reaction alias or command classifier; old stored Priority badges project `👍` without changing lane authority. |
-| `❤` / `❤️` | Promote to priority | Queue reaction shortcut | Normalize display consistently where code normalizes reactions. |
-| `🕊` / `🕊️` | Promote to priority | Queue reaction shortcut | Soft/peaceful promotion gesture. |
-| `🔥` | Select Steer | Queue reaction shortcut and Steer badge | Dominates `👍`, heart and dove; not immediate issuance or model-use proof. |
+| `🔥` | Select Steer | Queue reaction shortcut and Steer badge | Dominates `👍`; not immediate issuance or model-use proof. |
 | `👎` | Defer removal of waiting turn | Queue reaction shortcut and queue emoji marker | Reversible until the marked turn reaches dispatch; not negative feedback to the agent. |
-| `👻` | Defer removal of waiting turn | Queue reaction shortcut and queue emoji marker | Disappear/remove metaphor. |
-| `💔` | Defer removal of waiting turn | Queue reaction shortcut and queue emoji marker | Reversible cancel metaphor. |
-| `💩` | Defer removal of waiting turn | Queue reaction shortcut and queue emoji marker | Reversible reject metaphor. |
-| `🗑` | Defer removal | Queue reaction shortcut and queue emoji marker | Like Skip, the reaction remains reversible until dispatch reaches the marked turn. |
+
+Only `👍`, `👎`, and `🔥` are queue reaction shortcuts. Every other reaction is decorative, including the retired aliases. Retained queue state uses canonical badges without changing lane, disposition or receipt authority.
 
 ### Decorative Or Local-Example Emoji
 

package/lib/bus-follower.ts

@@ -42,7 +42,6 @@ import {
   sendTelegramBusLocalEnvelope,
   TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT,
   TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY,
-  TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_COMMAND_SET,
   TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE,
   TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE,
   TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION,
@@ -52,6 +51,7 @@ import {
   TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE,
   TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME,
   TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES,
+  getTelegramBusHeldCommandCapabilities,
   TELEGRAM_BUS_LIVE_REBIND_CAPABILITIES,
   TelegramBusLocalAuthorityError,
   type TelegramBusAgentMessage,
@@ -178,6 +178,7 @@ export interface TelegramBusFollowerRegistrationRuntime<TContext> {
       target?: TelegramTarget;
       previousInstanceId?: string;
       restoreWorkspace?: boolean;
+      recoverConnection?: boolean;
     },
   ) => Promise<boolean>;
   setContext: (ctx: TContext) => void | Promise<void>;
@@ -2930,7 +2931,7 @@ export function createTelegramBusFollowerRegistrationRuntime<
         deps.setActiveAuthSecret?.(undefined);
         await deps.stopReceiving?.();
       };
-      const pendingHandoff = options
+      const pendingHandoff = options && !options.recoverConnection
         ? undefined
         : getTelegramFollowerSessionHandoff();
       const pendingHandoffOptions = isTelegramFollowerSessionHandoffFresh(
@@ -2946,8 +2947,9 @@ export function createTelegramBusFollowerRegistrationRuntime<
             target?: TelegramTarget;
             previousInstanceId?: string;
             restoreWorkspace?: boolean;
+            recoverConnection?: boolean;
           }
-        | undefined = options ?? pendingHandoffOptions;
+        | undefined = options ? { ...pendingHandoffOptions, ...options } : pendingHandoffOptions;
       const leaderSocketPath =
         leader.busSocketPath ??
         deps.getLeaderSocketPath?.() ??
@@ -2968,6 +2970,8 @@ export function createTelegramBusFollowerRegistrationRuntime<
           : "follower.register",
         requestId: registrationGeneration,
         auth: activeAuthSecret,
+        ...(registrationOptions?.recoverConnection && !registrationOptions.restoreWorkspace
+          ? { recoverConnection: true as const } : {}),
         registration: {
           instanceId: deps.instanceId,
           ...(registrationOptions?.previousInstanceId
@@ -4546,8 +4550,7 @@ export function createTelegramBusForwardedUpdateReceiverRuntime<TContext>(
             ? [
                 TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY,
                 TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE,
-                TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_COMMAND_SET,
-                TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY,
+                ...getTelegramBusHeldCommandCapabilities(commandInput.name),
               ]
             : []),
         ];

package/lib/bus-leader.ts

@@ -23,6 +23,7 @@ import {
   TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT,
   TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION,
   TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF,
+  TELEGRAM_BUS_CAPABILITY_CONNECT_RECOVERY,
   hasTelegramBusSteerQueueHandoffCapability,
   TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY,
   TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT,
@@ -1529,7 +1530,7 @@ export function createTelegramBusFollowerTargetProvisioner(
   deps: TelegramBusFollowerTargetProvisionerDeps,
 ): (
   registration: TelegramBusInstanceRegistration,
-  options?: { existingWorkspaceBindingOnly?: boolean },
+  options?: { existingWorkspaceBindingOnly?: boolean; recoverConnection?: boolean },
 ) => Promise<
   (TelegramTarget & { slot?: string; threadName?: string }) | undefined
 > {
@@ -1548,6 +1549,16 @@ export function createTelegramBusFollowerTargetProvisioner(
     const chatId = deps.getAllowedUserId();
     if (typeof chatId !== "number") return registration.target;
     await deps.topicTargetStore.load();
+    if (options?.recoverConnection && !options.existingWorkspaceBindingOnly) {
+      const epoch = deps.getCurrentLeaderEpoch?.();
+      await Threads.resetTelegramConnectionProvisioning({
+        store: deps.topicTargetStore, owner: "manual-follower", instanceId: registration.instanceId,
+        profileKey: registration.profileKey ?? `manual:${registration.instanceId}`,
+        isCurrent: () => !deps.getCurrentLeaderEpoch ||
+          (epoch !== undefined && deps.getCurrentLeaderEpoch() === epoch),
+        recordEvent: deps.recordRuntimeEvent,
+      });
+    }
     let restoredPredecessor: Threads.TelegramTopicTargetRecord | undefined;
     if (options?.existingWorkspaceBindingOnly && registration.cwd && registration.sessionId &&
         !registration.previousInstanceId && deps.getLiveFollowers && deps.isFollowerProcessAlive) {
@@ -1580,6 +1591,7 @@ export function createTelegramBusFollowerTargetProvisioner(
           {
             existingBindingOnly: options?.existingWorkspaceBindingOnly === true,
             sessionId: registration.sessionId,
+            provisionProfileKey: registration.profileKey ?? `manual:${registration.instanceId}`,
             onCapacityUnavailable() {
               capacityUnavailable = true;
             },
@@ -1842,12 +1854,6 @@ export function createTelegramBusFollowerTargetProvisioner(
         };
       }
       const probeRequiredRecord = reconnectRecord?.status === "probe-required";
-      const exactSessionHandoff =
-        crossSessionReuse &&
-        !!requestedTarget &&
-        registration.previousInstanceId === reconnectRecord?.instanceId &&
-        requestedTarget.chatId === reconnectRecord.target.chatId &&
-        requestedTarget.threadId === reconnectRecord.target.threadId;
       const requiresVisibilityProbe =
         crossSessionReuse ||
         probeRequiredRecord ||
@@ -1869,19 +1875,14 @@ export function createTelegramBusFollowerTargetProvisioner(
         try {
           assertRestoreRegistration();
           await deps.callApi(
-            exactSessionHandoff ? "sendChatAction" : "sendMessage",
-            exactSessionHandoff
-              ? {
-                  chat_id: connectedAnnouncement.target.chatId,
-                  message_thread_id: connectedAnnouncement.target.threadId,
-                  action: "typing",
-                }
-              : {
-                  chat_id: connectedAnnouncement.target.chatId,
-                  message_thread_id: connectedAnnouncement.target.threadId,
-                  text: connectedAnnouncement.text,
-                  parse_mode: connectedAnnouncement.parseMode,
-                },
+            // Typing is presence, not evidence that a retained Thread still accepts messages.
+            "sendMessage",
+            {
+              chat_id: connectedAnnouncement.target.chatId,
+              message_thread_id: connectedAnnouncement.target.threadId,
+              text: connectedAnnouncement.text,
+              parse_mode: connectedAnnouncement.parseMode,
+            },
           );
           assertRestoreRegistration();
           if (recoverableTarget || probeRequiredRecord) {
@@ -2944,7 +2945,7 @@ export interface TelegramBusLeaderEnvelopeHandlerDeps {
   ) => Promise<unknown> | unknown;
   provisionFollowerTarget?: (
     registration: TelegramBusInstanceRegistration,
-    options?: { existingWorkspaceBindingOnly?: boolean },
+    options?: { existingWorkspaceBindingOnly?: boolean; recoverConnection?: boolean },
   ) =>
     | Promise<
         (TelegramTarget & { slot?: string; threadName?: string }) | undefined
@@ -3453,6 +3454,9 @@ export function createTelegramBusLeaderEnvelopeHandler(
             ));
         const restoringWorkspace =
           envelope.kind === "follower.restoreWorkspace";
+        const recoverConnection = envelope.kind === "follower.register" && envelope.recoverConnection === true;
+        const supportsConnectionRecovery = [deps.protocolIdentity, envelope.registration.protocol]
+          .every(identity => hasTelegramBusCapability(identity, TELEGRAM_BUS_CAPABILITY_CONNECT_RECOVERY));
         const supportsWorkspaceAutoConnect =
           hasTelegramBusCapability(
             deps.protocolIdentity,
@@ -3468,7 +3472,8 @@ export function createTelegramBusLeaderEnvelopeHandler(
           !readerCompatible() ||
           (envelope.registration.cwd !== undefined &&
             envelope.registration.sessionId === undefined) ||
-          (restoringWorkspace && !supportsWorkspaceAutoConnect)
+          (restoringWorkspace && !supportsWorkspaceAutoConnect) ||
+          (recoverConnection && !supportsConnectionRecovery)
         ) {
           return {
             kind: "bus.ack" as const,
@@ -3526,7 +3531,7 @@ export function createTelegramBusLeaderEnvelopeHandler(
                 );
               const target = await deps.provisionFollowerTarget?.(
                 envelope.registration,
-                { existingWorkspaceBindingOnly: restoringWorkspace },
+                { existingWorkspaceBindingOnly: restoringWorkspace, ...(recoverConnection ? { recoverConnection: true } : {}) },
               );
               if (restoringWorkspace && !target) {
                 return {

package/lib/bus.ts

@@ -144,6 +144,7 @@ export const TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF =
   "queue-handoff-v1" as const;
 /** Unspent Steer lane codec; independent from baseline receipt handoff support. */
 export const TELEGRAM_BUS_CAPABILITY_QUEUE_STEER = "queue-steer-v1" as const;
+export const TELEGRAM_BUS_CAPABILITY_CONNECT_RECOVERY = "explicit-connect-recovery-v1" as const;
 export const TELEGRAM_BUS_CAPABILITY_INPUT_CUSTODY_REFERENCE =
   "input-custody-reference-v1" as const;
 export const TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME =
@@ -184,6 +185,14 @@ export const TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES = [
   TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY,
 ] as const;
 
+/** Start/help are restricted menu aliases, negotiated separately from the original held-command set. */
+export const TELEGRAM_BUS_CAPABILITY_HELD_MENU_ALIASES = "held-menu-aliases-v1" as const;
+export function getTelegramBusHeldCommandCapabilities(name: string): readonly string[] {
+  return name === "start" || name === "help"
+    ? [...TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES, TELEGRAM_BUS_CAPABILITY_HELD_MENU_ALIASES]
+    : TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES;
+}
+
 export interface TelegramBusSelectedCommandInput {
   name: string;
   target: TelegramTarget & { threadId: number };
@@ -1009,6 +1018,7 @@ export type TelegramBusEnvelope = (
   | {
       kind: "follower.register";
       requestId: string;
+      recoverConnection?: true;
       registration: TelegramBusInstanceRegistration;
     }
   | {
@@ -2539,12 +2549,7 @@ export function createTelegramBusLiveRebindController(deps: {
         : []),
       ...(settling || held ? [TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE] : []),
       ...(observingHeld ? [TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION] : []),
-      ...(held
-        ? [
-            TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_COMMAND_SET,
-            TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY,
-          ]
-        : []),
+      ...(held ? getTelegramBusHeldCommandCapabilities(held.name) : []),
     ];
     const follower = deps.getFollower(expected.instanceId),
       secret = deps.getAuthSecret();
@@ -3545,8 +3550,12 @@ function parseRegisterEnvelope(
   requestId: string,
   kind: "follower.register" | "follower.restoreWorkspace",
 ): TelegramBusEnvelope | undefined {
+  if (value.recoverConnection !== undefined &&
+      (kind !== "follower.register" || value.recoverConnection !== true)) return undefined;
   const registration = parseRegistration(value.registration);
-  return registration ? { kind, requestId, registration } : undefined;
+  return registration ? { kind, requestId, registration,
+    ...(kind === "follower.register" && value.recoverConnection === true ? { recoverConnection: true as const } : {}),
+  } : undefined;
 }
 
 function parseFollowerPresenceEnvelope(

package/lib/commands.ts

@@ -53,7 +53,7 @@ import {
 } from "./updates.ts";
 
 export type TelegramHeldCommandName =
-  "status" | "abort" | "stop" | "next" | "continue";
+  "status" | "start" | "help" | "abort" | "stop" | "next" | "continue";
 
 /** Commands-owned no-fold admission over the ordinary recipient queue; source reporting stays separate from removal. */
 export interface TelegramHeldTurnAdmission {
@@ -2773,53 +2773,58 @@ export function createTelegramCommandHandler<
       },
     };
   };
-  const heldPlans: Record<TelegramHeldCommandName, HeldPlan> = {
-    status: {
-      completion: "before-effect",
-      effect: "showStatus",
-      prepare(ctx, effects) {
-        const scopedStatus = effects?.showStatus;
-        const captured = {
-          ...deps,
-          showStatus: scopedStatus
-            ? (
-                message: TMessage,
-                context: TContext,
-                options?: Pick<TelegramApiCallOptions, "assertAuthority">,
-              ) => {
-                const address = getTelegramCommandMessageTarget(message);
-                return scopedStatus.call(
-                  effects,
-                  address.chatId,
-                  address.replyToMessageId,
-                  context,
-                  address.threadId,
-                  options,
-                );
-              }
-            : deps.showStatus,
-        };
-        return {
-          captured,
-          portsCurrent: () => !effects || effects.showStatus === scopedStatus,
-          async run({ message, command, assertRecipient }) {
-            const recipientOptions = { assertAuthority: assertRecipient };
-            return handleTelegramCommandRuntime(
-              command.name,
-              message,
-              ctx,
-              {
-                ...captured,
-                assertExecutionCurrent: assertRecipient,
-                showStatus: (value: TMessage, context: TContext) =>
-                  captured.showStatus(value, context, recipientOptions),
-              },
-              command.args,
-            );
-          },
-        };
-      },
+  // Held followers are already paired and bound. Start/help open the same restricted menu as status;
+  // they cannot pair an operator, bootstrap another Thread or invoke unrestricted Bot API effects.
+  const heldMenuPlan: HeldPlan = {
+    completion: "before-effect",
+    effect: "showStatus",
+    prepare(ctx, effects) {
+      const scopedStatus = effects?.showStatus;
+      const captured = {
+        ...deps,
+        showStatus: scopedStatus
+          ? (
+              message: TMessage,
+              context: TContext,
+              options?: Pick<TelegramApiCallOptions, "assertAuthority">,
+            ) => {
+              const address = getTelegramCommandMessageTarget(message);
+              return scopedStatus.call(
+                effects,
+                address.chatId,
+                address.replyToMessageId,
+                context,
+                address.threadId,
+                options,
+              );
+            }
+          : deps.showStatus,
+      };
+      return {
+        captured,
+        portsCurrent: () => !effects || effects.showStatus === scopedStatus,
+        async run({ message, command, assertRecipient }) {
+          const recipientOptions = { assertAuthority: assertRecipient };
+          return handleTelegramCommandRuntime(
+            "status",
+            message,
+            ctx,
+            {
+              ...captured,
+              assertExecutionCurrent: assertRecipient,
+              showStatus: (value: TMessage, context: TContext) =>
+                captured.showStatus(value, context, recipientOptions),
+            },
+            command.args,
+          );
+        },
+      };
     },
+  };
+  const heldPlans: Record<TelegramHeldCommandName, HeldPlan> = {
+    status: heldMenuPlan,
+    start: heldMenuPlan,
+    help: heldMenuPlan,
     abort: {
       completion: "after-semantics",
       effect: "sendTextReply",

package/lib/extension.ts

@@ -65,6 +65,8 @@ const telegramBusProtocolIdentity =
     Bus.TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION,
     Bus.TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF,
     Bus.TELEGRAM_BUS_CAPABILITY_QUEUE_STEER,
+    Bus.TELEGRAM_BUS_CAPABILITY_CONNECT_RECOVERY,
+    Bus.TELEGRAM_BUS_CAPABILITY_HELD_MENU_ALIASES,
     Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT,
     Bus.TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME,
     Bus.TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE,
@@ -1238,7 +1240,7 @@ export default function (pi: Pi.ExtensionAPI) {
           follower.protocol,
           [
             ...Bus.TELEGRAM_BUS_LIVE_REBIND_CAPABILITIES,
-            ...Bus.TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES,
+            ...Bus.getTelegramBusHeldCommandCapabilities(name),
           ],
         ) &&
         typeof selectedMenuDelivery === "function" &&
@@ -1559,6 +1561,7 @@ export default function (pi: Pi.ExtensionAPI) {
     threadStore,
     runWorkspaceOperation: telegramWorkspaceOperationRuntime.run,
     liveRebindCleanupSchedule: Routing.TELEGRAM_LIVE_REBIND_CLEANUP_SCHEDULE,
+    liveRebindCommandCompletionTimeoutMs: 8_000,
     updateStatus,
     isContextActive: telegramSessionContextStore.isCurrent,
     dispatchNextQueuedTelegramTurn,

package/lib/locks.ts

@@ -1981,6 +1981,7 @@ export interface TelegramLockedPollingRuntime<
   registerFollowerWithOwner?: (
     ctx: TContext,
     owner: TelegramLockEntry,
+    options?: { recoverConnection?: boolean },
   ) => boolean | undefined | Promise<boolean | undefined>;
   restoreFollowerWithOwner?: (
     ctx: TContext,
@@ -2008,6 +2009,7 @@ interface TelegramLockedPollingRuntimeDeps<
   registerFollowerWithOwner?: (
     ctx: TContext,
     owner: TelegramLockEntry,
+    options?: { recoverConnection?: boolean },
   ) => boolean | undefined | Promise<boolean | undefined>;
   restoreFollowerWithOwner?: (
     ctx: TContext,
@@ -2294,6 +2296,7 @@ export function createTelegramLockedPollingRuntime<
             const registered = await deps.registerFollowerWithOwner(
               ctx,
               acquired.lock,
+              options.forceFreshLeaderThread ? { recoverConnection: true } : undefined,
             );
             if (!isCurrent()) return cancelled;
             if (registered) {
@@ -2518,8 +2521,8 @@ export function createTelegramLockedPollingRuntime<
       sessionAutoStartRun = run;
     },
     registerFollowerWithOwner: deps.registerFollowerWithOwner
-      ? async (ctx, owner) => {
-          const registered = await deps.registerFollowerWithOwner?.(ctx, owner);
+      ? async (ctx, owner, options) => {
+          const registered = await deps.registerFollowerWithOwner?.(ctx, owner, options);
           if (registered) deps.updateStatus(ctx);
           return registered === true;
         }

package/lib/menu-queue.ts

@@ -115,7 +115,7 @@ function buildTelegramQueueMenuReplyMarkup(
   if (items.length === 0) return { inline_keyboard: [backRow, refreshRow] };
   const rows = items.map((item) => {
     const badge = getTelegramQueueMenuLaneBadge(item);
-    const prefix = item.reactionSuppressionEmoji ? `${item.reactionSuppressionEmoji} ` :
+    const prefix = item.reactionSuppressionEmoji ? "👎 " :
       badge ? `${badge} ` : item.hasAttachments ? "📎 " : "";
     const position = item.reactionSuppressionEmoji
       ? formatSkippedTelegramQueuePosition(item.queuePosition)
@@ -179,16 +179,15 @@ function escapeTelegramQueueMenuHtmlPreview(text: string): string {
   return truncated ? escaped + suffix : escaped;
 }
 
-function getTelegramQueueMenuLaneBadge(item: Pick<TelegramQueueMenuItem, "queueLane" | "priorityEmoji">): string {
+function getTelegramQueueMenuLaneBadge(item: Pick<TelegramQueueMenuItem, "queueLane">): string {
   if (item.queueLane === "control") return "⚡";
   if (item.queueLane === "steer") return "🔥";
   if (item.queueLane !== "priority") return "";
-  const emoji = item.priorityEmoji?.replace(/\uFE0F/g, "");
-  return emoji === "❤" || emoji === "🕊" ? emoji : "👍";
+  return "👍";
 }
 
 function getTelegramQueueMenuItemText(item: TelegramQueueMenuItem): string {
-  const marker = item.reactionSuppressionEmoji ?? getTelegramQueueMenuLaneBadge(item);
+  const marker = item.reactionSuppressionEmoji ? "👎" : getTelegramQueueMenuLaneBadge(item);
   const badge = marker ? ` ${marker}` : "";
   const position = item.reactionSuppressionEmoji
     ? `<s>${item.queuePosition}</s>.`
@@ -920,10 +919,9 @@ function applyQueuedTelegramPromptMenuFlags<Context>(
   const disposition: Extract<Queue.TelegramQueueReactionDisposition, { kind: "reaction-transition" }> = { kind: "reaction-transition" };
   if (flags.lane !== undefined) {
     disposition.promptLane = flags.lane;
-    disposition.priorityEmoji = flags.lane === "steer" ? "🔥" : flags.lane === "priority" ?
-      getTelegramQueueMenuLaneBadge({ queueLane: "priority", priorityEmoji: item.queueLane === "priority" ? item.priorityEmoji : undefined }) : null;
+    disposition.priorityEmoji = flags.lane === "steer" ? "🔥" : flags.lane === "priority" ? "👍" : null;
   }
-  if (flags.skipped !== undefined) disposition.suppressionEmoji = flags.skipped ? (item.reactionSuppressionEmoji ?? "👎") : null;
+  if (flags.skipped !== undefined) disposition.suppressionEmoji = flags.skipped ? "👎" : null;
   return deps.queueMutationRuntime.applyReactionByMessageId(replyToMessageId, disposition, ctx) ||
     ((flags.lane === undefined || flags.lane === item.queueLane) &&
       (flags.skipped === undefined || flags.skipped === (item.reactionSuppressionEmoji !== undefined)));

package/lib/polling.ts

@@ -757,6 +757,7 @@ export interface TelegramThreadAwarePollingPorts<TContext, TOwner> {
   registerFollowerWithOwner: (
     ctx: TContext,
     owner: TOwner,
+    options?: { recoverConnection?: boolean },
   ) => Promise<boolean | undefined>;
   restoreFollowerWithOwner: (
     ctx: TContext,
@@ -776,6 +777,7 @@ export interface TelegramThreadAwarePollingControls<TContext, TOwner> {
   registerFollowerWithLeader: (
     ctx: TContext,
     owner: TOwner,
+    options?: { recoverConnection?: boolean },
   ) => Promise<boolean | undefined>;
   restoreFollowerWithLeader?: (
     ctx: TContext,
@@ -1180,9 +1182,10 @@ export function createTelegramThreadAwarePollingPorts<TContext, TOwner>(
   const registerFollowerWithOwner = async (
     ctx: TContext,
     owner: TOwner,
+    options?: { recoverConnection?: boolean },
   ): Promise<boolean | undefined> => {
     if (!(await refreshFollowerState())) return undefined;
-    return deps.registerFollowerWithLeader(ctx, owner);
+    return deps.registerFollowerWithLeader(ctx, owner, options);
   };
   const restoreFollowerWithOwner = async (
     ctx: TContext,

package/lib/routing.ts

@@ -916,6 +916,16 @@ export function createTelegramLiveRebindCoordinator(input: {
           }
         : undefined;
     },
+    /** Observe only an already-issued leader command; never prepares, relocates or executes input. */
+    observeCommandCompletion(): "unknown" | "released" | undefined {
+      if (!continuationIssued || !leader?.complete) return undefined;
+      if (!current()) return "unknown";
+      try { return observeCommandCompletion(); }
+      catch (error) {
+        input.recordRuntimeEvent?.("telegram", error, { phase: "live-rebind-command-observation" });
+        return "unknown";
+      }
+    },
     async advance(): Promise<"protected" | "unknown" | "released"> {
       if (advancing || !current()) return "protected";
       if (released) return "released";
@@ -1561,6 +1571,8 @@ export interface TelegramInboundRouteRuntimeDeps<
   /** Quiet period after the last cancelled input before one cleanup attempt; defaults to 0 ms. */
   temporaryThreadCleanupDelayMs?: number;
   /** Live-rebind cleanup attempt pacing; the bounded window ends in `not-issued`, never a time-based deletion. */
+  /** Bounded ACK observation inside the original chooser admission, independent from menu/reply delivery. */
+  liveRebindCommandCompletionTimeoutMs?: number;
   liveRebindCleanupSchedule?: {
     delaysMs: readonly number[];
     intervalMs: number;
@@ -1937,6 +1949,7 @@ export function createTelegramInboundRouteRuntime<
       extensionCommand?: Commands.ParsedTelegramCommand;
       extensionKind?: Commands.PreparedSelectedCommand["kind"];
       coordinator?: ReturnType<typeof createTelegramLiveRebindCoordinator>;
+      commandCompletionWaited?: true;
       isCurrent?: () => boolean;
     };
     /** The acknowledged tab presenting an All source; `sourceTarget` is this tab, not the original's location. */
@@ -4870,7 +4883,7 @@ export function createTelegramInboundRouteRuntime<
         Bus.isSameTelegramBusFollowerRegistration(live, follower!) &&
         [
           ...Bus.TELEGRAM_BUS_LIVE_REBIND_CAPABILITIES,
-          ...(heldSelected ? Bus.TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES : []),
+          ...(heldSelected ? Bus.getTelegramBusHeldCommandCapabilities(heldSelected.name) : []),
         ].every((cap) => Bus.hasTelegramBusCapability(live.protocol, cap)) &&
         !!live.target &&
         live.target.chatId === binding.target.chatId &&
@@ -5642,6 +5655,7 @@ export function createTelegramInboundRouteRuntime<
     return {
       operationId: request.operationId,
       selectedCommandReference: () => coordinator?.selectedCommandReference(),
+      observeCommandCompletion: () => coordinator?.observeCommandCompletion(),
       async advance() {
         if (!coordinator) {
           if (!current() || !getRecipient()) return "protected";
@@ -9058,6 +9072,42 @@ export function createTelegramInboundRouteRuntime<
         if (!(await selectPendingDestination())) return true;
         const operationId = selection.coordinator.operationId;
         if (current()) outcome = await selection.coordinator.advance();
+        const completionTimeoutMs = deps.liveRebindCommandCompletionTimeoutMs ?? 0;
+        if (outcome === "unknown" && !selection.commandCompletionWaited && selection.record.owner?.kind === "leader" &&
+          (selection.helpCommand || selection.menuCommand || selection.abortCommand || selection.nextCommand || selection.stopCommand) &&
+          Number.isFinite(completionTimeoutMs) && completionTimeoutMs > 0 &&
+          selection.coordinator.observeCommandCompletion() !== undefined) {
+          selection.commandCompletionWaited = true;
+          const coordinator = selection.coordinator;
+          const signal = Updates.getTelegramUpdateExecutionFence(query)?.signal;
+          outcome = await new Promise<"unknown" | "released">((resolve) => {
+            let settled = false;
+            const subscriptions: (() => void)[] = [];
+            const finish = (result: "unknown" | "released") => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(timer);
+              for (const unsubscribe of subscriptions) unsubscribe();
+              signal?.removeEventListener("abort", abort);
+              resolve(result);
+            };
+            const abort = () => finish("unknown");
+            const observe = () => {
+              if (settled) return;
+              if (!current()) { finish("unknown"); return; }
+              if (coordinator.observeCommandCompletion() === "released") finish("released");
+            };
+            const timer = setTimeout(abort, completionTimeoutMs);
+            timer.unref?.();
+            for (const message of selection.messages) {
+              const unsubscribe = Updates.subscribeTelegramDeferredSourceCompletion(message, observe);
+              if (unsubscribe) subscriptions.push(unsubscribe);
+            }
+            signal?.addEventListener("abort", abort, { once: true });
+            if (signal?.aborted || !current()) abort();
+            else if (coordinator.observeCommandCompletion() === "released") finish("released");
+          });
+        }
         // Cleanup readiness follows the canonical released row, not source disposal: a detached command ACK may
         // still be pending while every attempt samples current work afresh.
         const row =

package/lib/sync.ts

@@ -18,6 +18,7 @@ import {
   isSameTelegramProcessInstance,
   isTelegramTopicTargetStaleError,
   provisionOwnBusTopic,
+  resetTelegramConnectionProvisioning,
   type TelegramOwnTopicProvisionResult,
   type TelegramTopicTargetStore,
   type TelegramWorkspaceDisplayBinding,
@@ -826,6 +827,15 @@ export async function ensureTelegramLeaderThreadBinding(
     ...(deps.telegramProfile ? { telegramProfile: deps.telegramProfile } : {}),
   };
   const leaderProfileKey = getTelegramThreadOwnerKey(leaderOwner);
+  if (deps.forceFreshUnnamed) {
+    await resetTelegramConnectionProvisioning({
+      store: deps.topicTargetStore, owner: "leader", instanceId: deps.instanceId,
+      profileKey: leaderProfileKey, isCurrent: () => {
+        assertLeaderEpoch("connect-recovery");
+        return true;
+      }, recordEvent: deps.recordEvent,
+    });
+  }
   const legacyLeaderRecord =
     deps.topicTargetStore.getByProfileKey(leaderProfileKey);
   let capacityUnavailable = false;
@@ -836,6 +846,7 @@ export async function ensureTelegramLeaderThreadBinding(
         legacyLeaderRecord?.instanceId,
         {
           sessionId: deps.sessionId,
+          provisionProfileKey: leaderProfileKey,
           onCapacityUnavailable() {
             capacityUnavailable = true;
           },