@llblab/pi-telegram 0.55.1 → 0.56.1

package/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/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;
     }
   | {
@@ -2532,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();
@@ -3538,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

@@ -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()

package/lib/lifecycle.ts

@@ -26,6 +26,8 @@ import type {
   ToolExecutionEndEvent,
   ToolExecutionStartEvent,
   ToolExecutionUpdateEvent,
+  TurnEndEvent,
+  TurnEndEventResult,
   UIPromptEndEvent,
   UIPromptStartEvent,
 } from "./pi.ts";
@@ -100,6 +102,7 @@ export interface TelegramLifecycleRegistrationDeps {
     event: { model: TelegramLifecycleModel },
     ctx: ExtensionContext,
   ) => Promise<void> | void;
+  onTurnEnd?: (event: TurnEndEvent, ctx: ExtensionContext) => TurnEndEventResult | undefined;
   onAgentStart: (
     event: AgentStartEvent,
     ctx: ExtensionContext,
@@ -575,7 +578,6 @@ export function createTelegramBridgeSessionLifecycleAssembly<
 >(
   deps: TelegramBridgeSessionLifecycleAssemblyDeps<TQueueItem, TModel>,
 ): TelegramSessionLifecycleHooks {
-  const isSessionActive = deps.contextStore.isCurrent;
   const suspendForReplacement =
     BusFollower.createTelegramBusFollowerSessionReplacementSuspender({
       registrationState: deps.follower.registrationState,
@@ -583,32 +585,44 @@ export function createTelegramBridgeSessionLifecycleAssembly<
       suspendPolling: deps.follower.suspendPolling,
       recordRuntimeEvent: deps.follower.recordRuntimeEvent,
     });
-  let preserveTarget = true;
-  const queueLifecycle = Queue.createTelegramSessionLifecycleRuntime({
-    ...deps.queue,
-    isSessionActive,
-    stopPolling: () => suspendForReplacement(preserveTarget),
-    clearPendingMediaGroups: deps.services.suspendGroupedInput,
-  });
+  // A reused context can be current for a successor; inner awaits need this invocation's generation too.
+  const queueLifecycle = (ctx: ExtensionContext, generation: number, preserveTarget = true) =>
+    Queue.createTelegramSessionLifecycleRuntime({
+      ...deps.queue,
+      isSessionActive: () => deps.contextStore.isCurrent(ctx, generation),
+      stopPolling: () => suspendForReplacement(preserveTarget),
+      clearPendingMediaGroups: deps.services.suspendGroupedInput,
+    });
   const servicesLifecycle: TelegramSessionLifecycleHooks = {
     async onSessionStart(event, ctx) {
+      const generation = deps.contextStore.getGeneration();
+      const isCurrent = () => deps.contextStore.isCurrent(ctx, generation);
       const resumeConnection = deps.services.connection?.prepare(event, ctx);
-      await queueLifecycle.onSessionStart(event, ctx);
-      if (!isSessionActive(ctx)) return;
+      await queueLifecycle(ctx, generation).onSessionStart(event, ctx);
+      if (!isCurrent()) return;
       deps.services.resumeGroupedInput(ctx);
       await deps.services.delivery.onSessionStart();
-      if (!isSessionActive(ctx)) return;
+      if (!isCurrent()) return;
       if (resumeConnection) resumeConnection();
       else await deps.services.polling.onSessionStart(event, ctx);
+      if (!isCurrent()) return;
       deps.services.capabilityMonitor.start(ctx);
       deps.services.queueWatchdog.start(ctx);
+      await BusFollower.createTelegramBusFollowerSessionRefreshHook({
+        registrationState: deps.follower.registrationState,
+        registrationRuntime: deps.follower.registrationRuntime,
+        getLeaderState: deps.follower.getLeaderState,
+        isSessionActive: isCurrent,
+        updateStatus: deps.follower.updateStatus,
+        recordRuntimeEvent: deps.follower.recordRuntimeEvent,
+      })(event, ctx);
     },
     async onSessionShutdown(event, ctx) {
       const generation = deps.contextStore.getGeneration();
       const isCurrent = () => deps.contextStore.isCurrent(ctx, generation);
       if (!isCurrent()) return;
       deps.services.connection?.onSessionShutdown(event, ctx);
-      preserveTarget = event.reason !== "resume";
+      const preserveTarget = event.reason !== "resume";
       let preserveThread: (() => Promise<void>) | undefined;
       if (event.reason === "quit") {
         try {
@@ -625,7 +639,7 @@ export function createTelegramBridgeSessionLifecycleAssembly<
       if (!isCurrent()) return;
       deps.services.queueWatchdog.stop();
       deps.services.capabilityMonitor.stop();
-      await queueLifecycle.onSessionShutdown(event, ctx);
+      await queueLifecycle(ctx, generation, preserveTarget).onSessionShutdown(event, ctx);
       if (!isCurrent()) return;
       await deps.services.inboundWorker.onSessionShutdown();
       if (!isCurrent()) return;
@@ -638,23 +652,9 @@ export function createTelegramBridgeSessionLifecycleAssembly<
       }
     },
   };
-  const followerLifecycle = appendTelegramLifecycleHooks(
-    servicesLifecycle,
-    {
-      onSessionStart: BusFollower.createTelegramBusFollowerSessionRefreshHook({
-        registrationState: deps.follower.registrationState,
-        registrationRuntime: deps.follower.registrationRuntime,
-        getLeaderState: deps.follower.getLeaderState,
-        isSessionActive,
-        updateStatus: deps.follower.updateStatus,
-        recordRuntimeEvent: deps.follower.recordRuntimeEvent,
-      }),
-    },
-    isSessionActive,
-  );
   return createTelegramSessionGenerationFence(
     deps.contextStore,
-    followerLifecycle,
+    servicesLifecycle,
   );
 }
 
@@ -1042,6 +1042,12 @@ export function registerTelegramLifecycleHooks(
     if (!isActive(ctx)) return;
     await deps.onAgentStart(event, ctx);
   });
+  if (deps.onTurnEnd) {
+    pi.on("turn_end", (event, ctx) => {
+      if (!isActive(ctx)) return;
+      return deps.onTurnEnd?.(event, ctx);
+    });
+  }
   pi.on("tool_execution_start", async (event, ctx) => {
     if (!isActive(ctx)) return;
     await deps.onToolExecutionStart(event, ctx);

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;
         }