@llblab/pi-kit 0.33.0 → 0.34.0

package/node_modules/@llblab/pi-telegram/lib/bus-follower.ts

@@ -35,13 +35,13 @@ import {
   getTelegramBusProtocolCompatibility,
   getTelegramBusSocketPath,
   hasTelegramBusCapability,
+  hasTelegramBusSteerQueueHandoffCapability,
   isTelegramBusEnvelopeAuthorized,
   parseTelegramBusEnvelope,
   resolveTelegramBusSocketPath,
   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,
@@ -51,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,
@@ -177,6 +178,7 @@ export interface TelegramBusFollowerRegistrationRuntime<TContext> {
       target?: TelegramTarget;
       previousInstanceId?: string;
       restoreWorkspace?: boolean;
+      recoverConnection?: boolean;
     },
   ) => Promise<boolean>;
   setContext: (ctx: TContext) => void | Promise<void>;
@@ -2929,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(
@@ -2945,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?.() ??
@@ -2967,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
@@ -4545,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),
               ]
             : []),
         ];
@@ -4752,6 +4756,10 @@ export function createTelegramBusForwardedUpdateReceiverRuntime<TContext>(
             result: receipt,
           };
         }
+        if (envelope.payload.queueLane === "steer" &&
+            ![deps.getLocalProtocol?.(), deps.getLeaderProtocol?.()].every(hasTelegramBusSteerQueueHandoffCapability)) {
+          throw new Error("Steer queue handoff capability was not negotiated.");
+        }
         if (!deps.handleQueueHandoff) {
           throw new Error(
             "Telegram bus receiver cannot accept queue handoff payloads.",

package/node_modules/@llblab/pi-telegram/lib/bus-leader.ts

@@ -23,6 +23,8 @@ 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,
   TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE,
@@ -1528,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
 > {
@@ -1547,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) {
@@ -1579,6 +1591,7 @@ export function createTelegramBusFollowerTargetProvisioner(
           {
             existingBindingOnly: options?.existingWorkspaceBindingOnly === true,
             sessionId: registration.sessionId,
+            provisionProfileKey: registration.profileKey ?? `manual:${registration.instanceId}`,
             onCapacityUnavailable() {
               capacityUnavailable = true;
             },
@@ -1841,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 ||
@@ -1868,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) {
@@ -2943,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
@@ -3273,6 +3275,10 @@ export function createTelegramBusLeaderEnvelopeHandler(
         "Telegram queue handoff capability was not negotiated.",
       );
     }
+    if (envelope.payload.queueLane === "steer" &&
+        ![deps.protocolIdentity, donor.protocol, recipient?.protocol].every(hasTelegramBusSteerQueueHandoffCapability)) {
+      return rejectTelegramBusRequest(envelope.requestId, "Steer queue handoff capability was not negotiated.");
+    }
     if (
       !recipient?.registrationGeneration ||
       envelope.recipientRegistrationGeneration !==
@@ -3448,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,
@@ -3463,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,
@@ -3521,7 +3531,7 @@ export function createTelegramBusLeaderEnvelopeHandler(
                 );
               const target = await deps.provisionFollowerTarget?.(
                 envelope.registration,
-                { existingWorkspaceBindingOnly: restoringWorkspace },
+                { existingWorkspaceBindingOnly: restoringWorkspace, ...(recoverConnection ? { recoverConnection: true } : {}) },
               );
               if (restoringWorkspace && !target) {
                 return {
@@ -4477,6 +4487,10 @@ export function createTelegramBusLeaderRuntime<TContext>(
         "Telegram queue handoff capability was not negotiated.",
       );
     }
+    if (input.payload.queueLane === "steer" &&
+        ![deps.protocolIdentity, recipient?.protocol].every(hasTelegramBusSteerQueueHandoffCapability)) {
+      return rejectTelegramBusRequest(input.requestId, "Steer queue handoff capability was not negotiated.");
+    }
     if (
       !recipient?.registrationGeneration ||
       input.recipientRegistrationGeneration !== recipient.registrationGeneration

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

@@ -142,6 +142,9 @@ export const TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION =
   "durable-follower-admission-v1" as const;
 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 =
@@ -182,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 };
@@ -461,6 +472,11 @@ export function hasTelegramBusCapability(
   return identity?.capabilities.includes(capability) ?? false;
 }
 
+export function hasTelegramBusSteerQueueHandoffCapability(identity: TelegramBusProtocolIdentity | undefined): boolean {
+  return hasTelegramBusCapability(identity, TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF) &&
+    hasTelegramBusCapability(identity, TELEGRAM_BUS_CAPABILITY_QUEUE_STEER);
+}
+
 export function getTelegramInputCustodyPeerReadiness(
   followers: readonly Pick<
     TelegramBusFollowerView,
@@ -1002,6 +1018,7 @@ export type TelegramBusEnvelope = (
   | {
       kind: "follower.register";
       requestId: string;
+      recoverConnection?: true;
       registration: TelegramBusInstanceRegistration;
     }
   | {
@@ -1926,6 +1943,8 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
     message: TMessage;
     ownership: TelegramBusForwardOwnership;
     ctx: TContext;
+    /** Process-local source/recipient lifetime; never part of the wire envelope. */
+    assertAuthority?: () => void;
   }) => Promise<TelegramBusForeignUpdateSettlement>;
   forwardEditedMessage: (input: {
     message: TMessage;
@@ -2057,6 +2076,7 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
   const send = async (
     envelope: TelegramBusDurableForwardEnvelope,
     ownership: TelegramBusForwardOwnership,
+    assertAuthority?: () => void,
   ): Promise<TelegramBusForeignUpdateSettlement> => {
     if (
       deps.validateForwardOwnership &&
@@ -2078,10 +2098,15 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
         socketPath,
         envelope,
         timeoutMs: deps.timeoutMs ?? TELEGRAM_BUS_FOLLOWER_CONTROL_TIMEOUT_MS,
-        retry: getTelegramBusTransportRetryPolicy({
+        retry: assertAuthority ? { attempts: 1, delayMs: 0 } : getTelegramBusTransportRetryPolicy({
           endpoint: socketPath,
           operation: "operation",
         }),
+        ...(assertAuthority || deps.validateForwardOwnership ? { assertAuthority() {
+          assertAuthority?.();
+          if (deps.validateForwardOwnership && !deps.validateForwardOwnership(ownership))
+            throw new Error("Telegram follower forwarding ownership changed.");
+        } } : {}),
       });
     } catch (error) {
       return reject({
@@ -2178,6 +2203,7 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
       base: ForwardBase,
       sentAtMs: number,
     ) => TelegramBusDurableForwardEnvelope,
+    assertAuthority?: () => void,
   ): Promise<TelegramBusForeignUpdateSettlement> => {
     const prepared = prepare(kind, value, ownership);
     if ("settlement" in prepared) return Promise.resolve(prepared.settlement);
@@ -2192,6 +2218,7 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
         ? { kind: "leader.wakeInputCustody", ...base, sentAtMs: getNowMs() }
         : build(base, getNowMs()),
       ownership,
+      assertAuthority,
     );
   };
   return {
@@ -2214,7 +2241,7 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
           sentAtMs,
         }),
       ),
-    forwardMessage: ({ message, ownership }) =>
+    forwardMessage: ({ message, ownership, assertAuthority }) =>
       forward("leader.forwardMessage", message, ownership, (base, sentAtMs) => {
         const forwardCommentBatchPosition =
           deps.getForwardCommentBatchPosition?.(message);
@@ -2227,7 +2254,7 @@ export function createTelegramBusForeignOwnedUpdateForwarder<
             : {}),
           sentAtMs,
         };
-      }),
+      }, assertAuthority),
     forwardEditedMessage: ({ message, ownership }) =>
       forward(
         "leader.forwardEditedMessage",
@@ -2522,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();
@@ -3528,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/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/lib/extension.ts

@@ -64,6 +64,9 @@ const telegramBusProtocolIdentity =
   Bus.createTelegramCurrentBusProtocolIdentity([
     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,
@@ -717,7 +720,6 @@ export default function (pi: Pi.ExtensionAPI) {
     },
     getQueuedItems: telegramQueueStore.getQueuedItems,
     getQueuedItemCount: Queue.countExecutableTelegramQueueItems,
-    formatQueuedStatus: Queue.formatQueuedTelegramItemsStatus,
     getRecentRuntimeEvents: runtimeEvents.getEvents,
     getRuntimeLockState: lockRuntime.getStatusLabel,
     ...threadStatusProjectionRuntime,
@@ -1026,6 +1028,7 @@ export default function (pi: Pi.ExtensionAPI) {
     requestNextDispatchAnnouncement,
     cancelNextDispatchAnnouncement,
     watchdog: queueDispatchWatchdogRuntime,
+    onTurnEnd: onSteerTurnEnd,
   } = Bindings.createTelegramQueueBindingRuntime({
     store: telegramQueueStore,
     queue,
@@ -1037,6 +1040,8 @@ export default function (pi: Pi.ExtensionAPI) {
     promptDispatch: promptDispatchRuntime,
     isIdle,
     hasPendingMessages,
+    isContextCurrent: telegramSessionContextStore.isCurrent,
+    isContextAborted: Pi.isExtensionContextAbortRequested,
     updateStatus,
     sendTextReply,
     sendUserMessage,
@@ -1123,6 +1128,7 @@ export default function (pi: Pi.ExtensionAPI) {
 
   // --- Queue And Settings Menus ---
   const queueMenuRuntime = MenuQueue.createTelegramQueueMenuRuntime({
+    hasPendingDispatch: lifecycle.hasDispatchPending,
     telegramQueueStore,
     queueMutationRuntime,
     sendInteractiveMessage,
@@ -1234,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" &&
@@ -1555,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,
@@ -2331,6 +2338,14 @@ export default function (pi: Pi.ExtensionAPI) {
     });
   queueHandoffReconciliationBinding.set(
     Updates.createTelegramQueueHandoffReconciliationRuntimeAssembly({
+      hasPendingDispatch: lifecycle.hasDispatchPending,
+      canHandoffSteerWithRecipient(recipient) {
+        const live = telegramBusFollowerRegistry.get(recipient.instanceId);
+        return live?.registrationGeneration === recipient.registrationGeneration &&
+          [telegramBusProtocolIdentity, live?.protocol,
+            ...(telegramBusFollowerRegistrationState.isRegistered() ? [telegramBusFollowerRegistrationState.getLeaderProtocol()] : [])]
+            .every(Bus.hasTelegramBusSteerQueueHandoffCapability);
+      },
       ownsDirect: lockRuntime.owns,
       isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
       isBusEnabled: isTelegramBusRuntimeEnabled,
@@ -3046,6 +3061,7 @@ export default function (pi: Pi.ExtensionAPI) {
     sendMarkdownReply,
     sendTextReply,
     dispatchNextQueuedTelegramTurn,
+    onSteerTurnEnd,
     onPromptHandedOff(turn, ctx) {
       updateAdmissionRuntimeBinding
         .getSettlement()