@llblab/pi-telegram 0.52.2 → 0.53.1

package/lib/bindings.ts

@@ -4,16 +4,21 @@
  * Owns pi-facing tool, command, and lifecycle hook registration for the entrypoint
  */
 
-import * as Activity from "./activity.ts";
 import * as ActivityVerbosity from "./activity-verbosity.ts";
+import * as Activity from "./activity.ts";
+import * as BusApi from "./bus-api.ts";
+import type { TelegramBusFollowerCommandOwner } from "./bus-follower.ts";
+import type { TelegramBusLiveRebindWorkState } from "./bus.ts";
 import * as ChannelPosts from "./channel-posts.ts";
 import * as CommandTemplates from "./command-templates.ts";
 import * as Commands from "./commands.ts";
 import * as Config from "./config.ts";
 import * as Delivery from "./delivery.ts";
+import * as GenerativeApps from "./generative-apps.ts";
 import * as Keyboard from "./keyboard.ts";
 import * as Lifecycle from "./lifecycle.ts";
 import * as Locks from "./locks.ts";
+import * as Menu from "./menu.ts";
 import * as Model from "./model.ts";
 import * as OutboundAttachments from "./outbound-attachments.ts";
 import * as OutboundHandlers from "./outbound.ts";
@@ -26,9 +31,159 @@ import * as Routing from "./routing.ts";
 import * as Runtime from "./runtime.ts";
 import * as Setup from "./setup.ts";
 import * as Status from "./status.ts";
-import * as TelegramApi from "./telegram-api.ts";
 import type { TelegramTarget } from "./target.ts";
-import * as GenerativeApps from "./generative-apps.ts";
+import * as TelegramApi from "./telegram-api.ts";
+
+/** Compose any registered held command over captured recipient effects; no ordinary follower API fallback. */
+export function createTelegramFollowerSelectedCommandBinding<
+  TContext,
+  TModel extends Model.MenuModel = Model.MenuModel,
+>(deps: {
+  ctx: TContext;
+  operationId: string;
+  registrationGeneration: string;
+  name: string;
+  target: TelegramTarget & { threadId: number };
+  recipient: Pick<
+    TelegramBusFollowerCommandOwner<TContext>,
+    "isCurrent" | "assertRecipientCurrent"
+  >;
+  command: Pick<
+    ReturnType<
+      typeof Commands.createTelegramCommandHandlerTargetRuntime<
+        Commands.TelegramCommandRuntimeMessage,
+        TContext
+      >
+    >,
+    "prepareHeldCommand" | "canPrepareHeldCommand"
+  >;
+  menu?: Omit<
+    Menu.TelegramMenuActionRuntimeDeps<TContext, TModel>,
+    "sendTextReply" | "sendInteractiveMessage" | "editInteractiveMessage"
+  >;
+  deliver: Parameters<
+    typeof BusApi.createTelegramSelectedMenuTextApi
+  >[0]["deliver"];
+  recordOwnership: NonNullable<
+    Replies.TelegramRenderedMessageDeliveryRuntimeDeps<Menu.TelegramReplyMarkup>["recordOwnership"]
+  >;
+}): TelegramBusFollowerCommandOwner<TContext> | undefined {
+  const {
+      ctx,
+      operationId,
+      registrationGeneration,
+      name,
+      recipient,
+      command,
+      deliver,
+      recordOwnership,
+    } = deps,
+    target = { ...deps.target };
+  const prepare = command.prepareHeldCommand,
+    canPrepare = command.canPrepareHeldCommand;
+  const isCurrent = recipient.isCurrent,
+    assertRecipientCurrent = recipient.assertRecipientCurrent,
+    menu = deps.menu,
+    menuPorts = menu && { ...menu };
+  if (
+    [
+      prepare,
+      canPrepare,
+      isCurrent,
+      assertRecipientCurrent,
+      deliver,
+      recordOwnership,
+    ].some((port) => typeof port !== "function") ||
+    (menuPorts &&
+      [
+        menuPorts.getModelMenuState,
+        menuPorts.storeModelMenuState,
+        menuPorts.getActiveModel,
+        menuPorts.getThinkingLevel,
+        menuPorts.buildStatusHtml,
+        menuPorts.isIdle,
+        menuPorts.canOfferInFlightModelSwitch,
+      ].some((port) => typeof port !== "function"))
+  )
+    return undefined;
+  const portsCurrent = () =>
+    deps.ctx === ctx &&
+    deps.operationId === operationId &&
+    deps.registrationGeneration === registrationGeneration &&
+    deps.name === name &&
+    deps.recipient === recipient &&
+    recipient.isCurrent === isCurrent &&
+    recipient.assertRecipientCurrent === assertRecipientCurrent &&
+    deps.command === command &&
+    command.prepareHeldCommand === prepare &&
+    command.canPrepareHeldCommand === canPrepare &&
+    deps.deliver === deliver &&
+    deps.recordOwnership === recordOwnership &&
+    deps.menu === menu &&
+    (!menuPorts ||
+      Object.entries(menuPorts).every(
+        ([key, value]) => Reflect.get(menu!, key) === value,
+      ));
+  const current = () =>
+    portsCurrent() && isCurrent.call(recipient) && portsCurrent();
+  if (!current()) return undefined;
+  const api = BusApi.createTelegramSelectedMenuTextApi({
+    operationId,
+    registrationGeneration,
+    target,
+    assertAuthority: assertRecipientCurrent,
+    deliver,
+  });
+  const rendered =
+    Replies.createTelegramRenderedMessageDeliveryRuntime<Menu.TelegramReplyMarkup>(
+      {
+        sendMessage: api.sendMessage,
+        editMessage: api.editMessageText,
+        recordOwnership,
+        async sendRichMessage() {
+          throw new Error(
+            "Selected command has no rich or ordinary API fallback.",
+          );
+        },
+      },
+    );
+  const menus =
+    menuPorts &&
+    Menu.createTelegramMenuActionRuntime({
+      ...menuPorts,
+      sendTextReply: rendered.sendTextReply,
+      sendInteractiveMessage: rendered.sendInteractiveMessage,
+      editInteractiveMessage: rendered.editInteractiveMessage,
+    });
+  const effects = {
+    sendTextReply: rendered.sendTextReply,
+    ...(menus ? { showStatus: menus.sendStatusMessage } : {}),
+  };
+  if (!canPrepare.call(command, name, effects) || !current()) return undefined;
+  return {
+    isCurrent: current,
+    assertRecipientCurrent,
+    prepare(readiness, context, input) {
+      if (
+        !current() ||
+        context !== ctx ||
+        input.target.chatId !== target.chatId ||
+        input.target.threadId !== target.threadId ||
+        input.assertRecipientCurrent !== assertRecipientCurrent
+      )
+        return undefined;
+      const plan = prepare.call(
+        command,
+        name,
+        readiness,
+        context,
+        input,
+        effects,
+      );
+      return current() ? plan : undefined;
+    },
+  };
+}
 
 type ActivePiModel = NonNullable<Pi.ExtensionContext["model"]>;
 
@@ -120,9 +275,7 @@ export function createTelegramQueueBindingRuntime<TContext>(deps: {
     allocateLaneOrder: deps.queue.allocateItemOrder,
     onItemsDiscarded(items, ctx) {
       if (!settleDiscardedItems(items, ctx)) {
-        throw new Error(
-          "Telegram queue items could not be discarded durably.",
-        );
+        throw new Error("Telegram queue items could not be discarded durably.");
       }
     },
     updateStatus: deps.updateStatus,
@@ -188,19 +341,21 @@ export interface TelegramGenerativeAppLiveSurfaceBinding {
     | GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle>
     | undefined;
   set: (
-    runtime: GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle>
+    runtime:
+      | GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle>
       | undefined,
   ) => void;
   shutdown: () => void;
 }
 
-export function createTelegramGenerativeAppLiveSurfaceBinding():
-TelegramGenerativeAppLiveSurfaceBinding {
+export function createTelegramGenerativeAppLiveSurfaceBinding(): TelegramGenerativeAppLiveSurfaceBinding {
   let current:
     | GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle>
     | undefined;
   return {
-    get() { return current; },
+    get() {
+      return current;
+    },
     set(runtime) {
       current?.shutdown();
       current = runtime;
@@ -214,17 +369,25 @@ TelegramGenerativeAppLiveSurfaceBinding {
 
 export function createTelegramGenerativeAppBoundButtonActionInvoker<
   TQuery extends {
-    message?: { chat?: { id?: number }; message_id?: number; message_thread_id?: number };
+    message?: {
+      chat?: { id?: number };
+      message_id?: number;
+      message_thread_id?: number;
+    };
   },
 >(deps: {
   agentDir: string;
   assertExecutionCurrent: (query: TQuery) => void;
-  getExecutionFence: (query: TQuery) => GenerativeApps.GenerativeAppExecutionFence | undefined;
+  getExecutionFence: (
+    query: TQuery,
+  ) => GenerativeApps.GenerativeAppExecutionFence | undefined;
   getActiveProfileName?: () => string | undefined;
   getLiveSurfaceRuntime?: () =>
     | GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle>
     | undefined;
-  planOutput: ReturnType<typeof OutboundHandlers.createTelegramOutboundReplyPlanner>;
+  planOutput: ReturnType<
+    typeof OutboundHandlers.createTelegramOutboundReplyPlanner
+  >;
   sendMarkdownReply: (
     chatId: number,
     replyToMessageId: number,
@@ -258,16 +421,18 @@ export function createTelegramGenerativeAppBoundButtonActionInvoker<
         throw new Error("Generative App callback target is unavailable.");
       }
       const liveSurfaces = deps.getLiveSurfaceRuntime?.();
-      handedOff = liveSurfaces?.take(GenerativeApps.getTelegramBindLiveSurfaceKey(
-        boundAction.app,
-        deps.getActiveProfileName?.() ?? "default",
-        {
-          chatId,
-          ...(query.message?.message_thread_id !== undefined
-            ? { threadId: query.message.message_thread_id }
-            : {}),
-        },
-      ));
+      handedOff = liveSurfaces?.take(
+        GenerativeApps.getTelegramBindLiveSurfaceKey(
+          boundAction.app,
+          deps.getActiveProfileName?.() ?? "default",
+          {
+            chatId,
+            ...(query.message?.message_thread_id !== undefined
+              ? { threadId: query.message.message_thread_id }
+              : {}),
+          },
+        ),
+      );
       const result = await GenerativeApps.invokeGenerativeApp({
         agentDir: deps.agentDir,
         ...(deps.getExecutionFence(query)
@@ -424,7 +589,8 @@ export function createTelegramAssistantOutputBindingRuntime<
     typeof OutboundHandlers.createTelegramAssistantOutputSender<TTransportStamp>
   >[0];
   waitForActivityIdle?: () => Promise<void>;
-  prepareTelegramPreview?: () => Activity.TelegramAssistantOutputPreparation | undefined;
+  prepareTelegramPreview?: () =>
+    Activity.TelegramAssistantOutputPreparation | undefined;
   enqueue?: Activity.TelegramActivityPublicationRuntime["enqueue"];
   recordRuntimeEvent: TelegramRuntimeEventRecorder;
 }): TelegramAssistantOutputBindingRuntime<TTransportStamp> {
@@ -438,7 +604,8 @@ export function createTelegramAssistantOutputBindingRuntime<
   const runtime = Activity.createTelegramAssistantOutputRuntime({
     ...authority,
     enqueue: deps.enqueue,
-    prepareSend: (event) => event.source === "telegram" ? deps.prepareTelegramPreview?.() : undefined,
+    prepareSend: (event) =>
+      event.source === "telegram" ? deps.prepareTelegramPreview?.() : undefined,
     async send(event, authority, isAuthorityActive) {
       await deps.waitForActivityIdle?.();
       if (!isAuthorityActive()) return;
@@ -468,7 +635,13 @@ type TelegramAssistantOutputAuthority<TTransportStamp> = ReturnType<
 export interface TelegramBridgePublicationRuntime {
   enqueue: Activity.TelegramActivityPublicationRuntime["enqueue"];
   reserve: Activity.TelegramActivityPublicationRuntime["reserve"];
-  capture: () => { target?: Queue.TelegramQueueTarget; isCurrent: () => boolean };
+  hasPending: Activity.TelegramActivityPublicationRuntime["hasPending"];
+  beginWork: Activity.TelegramActivityPublicationRuntime["beginWork"];
+  hasUnconfirmed: Activity.TelegramActivityPublicationRuntime["hasUnconfirmed"];
+  capture: () => {
+    target?: Queue.TelegramQueueTarget;
+    isCurrent: () => boolean;
+  };
 }
 
 export interface TelegramActivityBindingRuntime {
@@ -497,11 +670,10 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
   >;
 }): TelegramActivityBindingRuntime {
   const publication = Activity.createTelegramActivityPublicationRuntime();
-  const assistantOutputBinding =
-    createTelegramAssistantOutputBindingRuntime({
-      ...deps.assistantOutput,
-      enqueue: publication.enqueue,
-    });
+  const assistantOutputBinding = createTelegramAssistantOutputBindingRuntime({
+    ...deps.assistantOutput,
+    enqueue: publication.enqueue,
+  });
   const activityVerbosityRuntime =
     ActivityVerbosity.createTelegramActivityVerbosityRuntime({
       ...deps.activityVerbosity,
@@ -547,17 +719,88 @@ export function createTelegramActivityBindingRuntime<TTransportStamp>(deps: {
     publicationRuntime: {
       enqueue: publication.enqueue,
       reserve: publication.reserve,
+      hasPending: publication.hasPending,
+      beginWork: publication.beginWork,
+      hasUnconfirmed: publication.hasUnconfirmed,
       capture() {
         const authority = assistantOutputBinding.authority.captureAuthority();
         return {
           target: authority.target ? { ...authority.target } : undefined,
-          isCurrent: () => assistantOutputBinding.authority.isAuthorityActive(authority),
+          isCurrent: () =>
+            assistantOutputBinding.authority.isAuthorityActive(authority),
         };
       },
     },
   };
 }
 
+/** Fresh current work projection; a snapshot is not a cleanup grant or target-application ACK. */
+export function createTelegramLiveTargetWorkObserver<TContext>(deps: {
+  queue: Pick<Queue.TelegramQueueStateStore<TContext>, "getQueuedItems">;
+  activeTurn: Pick<Queue.TelegramActiveTurnStore, "get">;
+  lifecycle: Pick<
+    Runtime.TelegramBridgeRuntime["lifecycle"],
+    "hasDispatchPending" | "isCompactionInProgress" | "getActiveToolExecutions"
+  >;
+  isIdle(ctx: TContext): boolean;
+  hasPendingMessages(ctx: TContext): boolean;
+  hasPendingControl(): boolean;
+  publication: Pick<
+    TelegramBridgePublicationRuntime,
+    "hasPending" | "hasUnconfirmed"
+  >;
+  activity: Pick<Activity.TelegramActivityRuntime, "hasPending">;
+  delivery: Pick<
+    ReturnType<typeof Delivery.createTelegramDeliveryLifecycleHooks>,
+    "hasPendingTarget"
+  >;
+  api: Pick<TelegramApi.TelegramApiTargetActivityRuntime, "hasPendingTarget">;
+}): (
+  target: TelegramTarget & { threadId: number },
+  ctx: TContext,
+) => TelegramBusLiveRebindWorkState {
+  return (target, ctx) => {
+    const work = Queue.observeTelegramTargetQueueWork(
+      target,
+      deps.activeTurn.get(),
+      deps.queue.getQueuedItems(),
+    );
+    const flags = [
+      deps.isIdle(ctx),
+      deps.hasPendingMessages(ctx),
+      deps.lifecycle.hasDispatchPending(),
+      deps.lifecycle.isCompactionInProgress(),
+      deps.hasPendingControl(),
+    ];
+    const tools = deps.lifecycle.getActiveToolExecutions();
+    const publication = deps.publication.hasPending(),
+      unconfirmed = deps.publication.hasUnconfirmed?.(),
+      activity = deps.activity.hasPending?.(),
+      delivery = deps.delivery.hasPendingTarget(target),
+      api = deps.api.hasPendingTarget(target);
+    const unknown =
+      work.unknown ||
+      flags.some((flag) => typeof flag !== "boolean") ||
+      !Number.isSafeInteger(tools) ||
+      tools < 0 ||
+      unconfirmed !== false ||
+      [publication, activity, delivery, api].some(
+        (flag) => typeof flag !== "boolean",
+      );
+    return {
+      sessionBusy:
+        flags[0] !== true || flags.slice(1).some(Boolean) || tools > 0,
+      targetWork: work.protected,
+      deliveryPending:
+        publication === true ||
+        activity === true ||
+        delivery === true ||
+        api === true,
+      unknown,
+    };
+  };
+}
+
 interface TelegramCommandsAndToolsBindingDeps {
   pi: Pi.ExtensionAPI;
   agentDir: string;
@@ -567,7 +810,6 @@ interface TelegramCommandsAndToolsBindingDeps {
   activeTurnRuntime: Queue.TelegramActiveTurnStore<Queue.PendingTelegramTurn>;
   lockedPollingRuntime: Locks.TelegramLockedPollingRuntime<Pi.ExtensionContext>;
   stopPolling?: () => Promise<void | string>;
-  recoverPollingStart?: Commands.TelegramBridgeCommandRegistrationDeps["recoverPollingStart"];
   getDisconnectThreadName?: () => string | undefined;
   onTransportChanged?: () => Promise<void> | void;
   getStatusLines: (
@@ -590,8 +832,12 @@ interface TelegramCommandsAndToolsBindingDeps {
     OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["sendChannelMediaMessage"]
   >;
   listChannelPosts: ChannelPosts.TelegramChannelPostJournalStore["list"];
-  mutateChannelPost(input: { action: "edit" | "delete"; operationId: string;
-    mutationId: string; markdown?: string }): Promise<ChannelPosts.TelegramChannelPostRecord>;
+  mutateChannelPost(input: {
+    action: "edit" | "delete";
+    operationId: string;
+    mutationId: string;
+    markdown?: string;
+  }): Promise<ChannelPosts.TelegramChannelPostRecord>;
   callMultipart: OutboundHandlers.TelegramVoiceReplySenderDeps["sendMultipart"];
   getDefaultChatId: () => number | undefined;
   getDefaultTarget?: () => OutboundAttachments.TelegramQueuedOutboundAttachmentTurnView["target"];
@@ -599,13 +845,16 @@ interface TelegramCommandsAndToolsBindingDeps {
   routeAgentMessage?: OutboundAttachments.TelegramOutboundMessageToolRegistrationDeps["routeAgentMessage"];
   canSendDirect: () => boolean;
   setGenerativeAppLiveSurfaceRuntime?: (
-    runtime: GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle>
+    runtime:
+      | GenerativeApps.GenerativeAppLiveSurfaceRuntime<GenerativeApps.TelegramBindLiveHandle>
       | undefined,
   ) => void;
   updateStatus: TelegramBridgeStatusUpdater;
   isContextCurrent: (ctx: Pi.ExtensionContext) => boolean;
   getSessionGeneration: () => number;
-  connectionIntent: NonNullable<Commands.TelegramBridgeCommandRegistrationDeps["connectionIntent"]>;
+  connectionIntent: NonNullable<
+    Commands.TelegramBridgeCommandRegistrationDeps["connectionIntent"]
+  >;
   recordRuntimeEvent: TelegramRuntimeEventRecorder;
 }
 
@@ -618,7 +867,6 @@ export function registerTelegramCommandsAndTools({
   activeTurnRuntime,
   lockedPollingRuntime,
   stopPolling,
-  recoverPollingStart,
   getDisconnectThreadName,
   onTransportChanged,
   getStatusLines,
@@ -649,23 +897,27 @@ export function registerTelegramCommandsAndTools({
       ? { setLiveSurfaceRuntime: setGenerativeAppLiveSurfaceRuntime }
       : {}),
     isDeliveryHandleCurrent: Delivery.isTelegramDeliveryHandleCurrent,
-    editView: (handle, view) => Delivery.editTelegramView(
-      handle as Delivery.TelegramDeliveryHandle,
-      view as Delivery.TelegramDeliveryView,
-    ),
+    editView: (handle, view) =>
+      Delivery.editTelegramView(
+        handle as Delivery.TelegramDeliveryHandle,
+        view as Delivery.TelegramDeliveryView,
+      ),
     planOutput: OutboundHandlers.createTelegramOutboundReplyPlanner(
       buttonActionStore,
-      Config.createTelegramConfigControls(configStore).getAssistantRenderingMode,
+      Config.createTelegramConfigControls(configStore)
+        .getAssistantRenderingMode,
     ),
     sendMarkdownReply,
-    sendView: (view, options) => Delivery.sendTelegramView(
-      view as Delivery.TelegramDeliveryView,
-      options,
-    ),
+    sendView: (view, options) =>
+      Delivery.sendTelegramView(view as Delivery.TelegramDeliveryView, options),
     recordRuntimeEvent,
   });
-  ChannelPosts.registerTelegramChannelPostMutationTool(pi, { mutate: mutateChannelPost });
-  ChannelPosts.registerTelegramChannelPostListTool(pi, { list: listChannelPosts });
+  ChannelPosts.registerTelegramChannelPostMutationTool(pi, {
+    mutate: mutateChannelPost,
+  });
+  ChannelPosts.registerTelegramChannelPostListTool(pi, {
+    list: listChannelPosts,
+  });
   OutboundAttachments.registerTelegramOutboundAttachmentTool(pi, {
     getActiveTurn: activeTurnRuntime.get,
     getDefaultChatId,
@@ -681,11 +933,11 @@ export function registerTelegramCommandsAndTools({
     resolveAgentTarget,
     routeAgentMessage,
     canSendDirect,
-    planMessage:
-      OutboundHandlers.createTelegramOutboundReplyPlanner(
-        buttonActionStore,
-        Config.createTelegramConfigControls(configStore).getAssistantRenderingMode,
-      ),
+    planMessage: OutboundHandlers.createTelegramOutboundReplyPlanner(
+      buttonActionStore,
+      Config.createTelegramConfigControls(configStore)
+        .getAssistantRenderingMode,
+    ),
     sendMarkdownMessage: (chatId, markdown, options) =>
       sendMarkdownReply(chatId, undefined, markdown, options),
     sendChannelMarkdownMessage,
@@ -748,7 +1000,8 @@ export function registerTelegramCommandsAndTools({
               );
             }
             await configStore.load();
-            const latestProfile = configStore.getStoredConfig().profiles?.[profileName];
+            const latestProfile =
+              configStore.getStoredConfig().profiles?.[profileName];
             configStore.setProfile(profileName, {
               ...profile,
               threadDisplayMode: latestProfile?.threadDisplayMode,
@@ -782,7 +1035,10 @@ export function registerTelegramCommandsAndTools({
       if (completion.status === "success") {
         queueAgentConnectionContext(true);
         if (profileName) {
-          ctx.ui.notify(`Profile "${profileName}" saved and connected.`, "info");
+          ctx.ui.notify(
+            `Profile "${profileName}" saved and connected.`,
+            "info",
+          );
         }
       }
     },
@@ -791,9 +1047,9 @@ export function registerTelegramCommandsAndTools({
     hasBotToken: configStore.hasBotToken,
     getBotTokenDiagnostic: configStore.getBotTokenDiagnostic,
     startPolling: lockedPollingRuntime.start,
-    recordConnectionEvent: (error, phase) => recordRuntimeEvent("connection", error, { phase }),
+    recordConnectionEvent: (error, phase) =>
+      recordRuntimeEvent("connection", error, { phase }),
     stopPolling: stopPolling ?? lockedPollingRuntime.stop,
-    recoverPollingStart,
     getDisconnectThreadName,
     queueAgentConnectionContext,
     updateStatus,
@@ -839,7 +1095,11 @@ interface TelegramLifecycleBindingDeps {
   diagnostics?: { onSessionStart(): void; onSessionShutdown(): Promise<void> };
   assistantOutputRuntime: Pick<
     Activity.TelegramAssistantOutputRuntime,
-    "start" | "beginTurn" | "hasAdmittedTelegramIntermediate" | "waitForIdle" | "stop"
+    | "start"
+    | "beginTurn"
+    | "hasAdmittedTelegramIntermediate"
+    | "waitForIdle"
+    | "stop"
   >;
   sessionLifecycleRuntime: Pick<
     Lifecycle.TelegramLifecycleRegistrationDeps,
@@ -866,7 +1126,10 @@ interface TelegramLifecycleBindingDeps {
   deferredQueueDispatchRuntime: Queue.TelegramDeferredQueueDispatchRuntime<Pi.ExtensionContext>;
   modelContextAvailabilityRuntime: Prompts.TelegramModelContextAvailabilityRuntime;
   disconnectOnQuit?: () => Promise<unknown>;
-  onSessionStarted?: (event: Pi.SessionStartEvent, ctx: Pi.ExtensionContext) => void;
+  onSessionStarted?: (
+    event: Pi.SessionStartEvent,
+    ctx: Pi.ExtensionContext,
+  ) => void;
   shutdownGenerativeAppLiveSurfaces?: () => void;
   resolveAutomaticThreadCleanupEnabled?: () => boolean | Promise<boolean>;
   buttonActionStore: OutboundHandlers.TelegramButtonActionStore;
@@ -1113,16 +1376,20 @@ export function registerTelegramLifecycleRuntimeHooks({
       { replyToPrompt: false },
     );
   };
-  let pendingFinalPublication: {
-    turn: Queue.PendingTelegramTurn;
-    reservation: Activity.TelegramActivityPublicationReservation;
-  } | undefined;
+  let pendingFinalPublication:
+    | {
+        turn: Queue.PendingTelegramTurn;
+        reservation: Activity.TelegramActivityPublicationReservation;
+      }
+    | undefined;
   const cancelPendingFinalPublication = (): void => {
     pendingFinalPublication?.reservation.cancel();
     pendingFinalPublication = undefined;
   };
   const recordPublicationFailure = (error: unknown): void => {
-    recordRuntimeEvent("delivery", error, { phase: "agent-end-background-delivery" });
+    recordRuntimeEvent("delivery", error, {
+      phase: "agent-end-background-delivery",
+    });
   };
   const scheduleActiveTurnDelivery = (task: () => Promise<void>): void => {
     void publicationRuntime.enqueue(task).catch(recordPublicationFailure);
@@ -1159,7 +1426,8 @@ export function registerTelegramLifecycleRuntimeHooks({
     loadConfig: configStore.load,
     extractAssistant: Replies.extractRunAssistantMessage,
     isAssistantAlreadyPublished: (assistant) =>
-      !!assistant.text && assistantOutputRuntime.hasAdmittedTelegramIntermediate(assistant.text),
+      !!assistant.text &&
+      assistantOutputRuntime.hasAdmittedTelegramIntermediate(assistant.text),
     getFoldQueuedPromptsIntoHistory:
       lifecycle.shouldFoldQueuedPromptsIntoHistory,
     resetRuntimeState: agentEndResetter,
@@ -1175,9 +1443,12 @@ export function registerTelegramLifecycleRuntimeHooks({
       pendingFinalPublication = undefined;
       const matches = pending?.turn === activeTurnRuntime.get();
       if (!matches) pending?.reservation.cancel();
-      const reservation = matches && pending ? pending.reservation : publicationRuntime.reserve();
+      const reservation =
+        matches && pending ? pending.reservation : publicationRuntime.reserve();
       return {
-        schedule: (task) => { void reservation.publish(task).catch(recordPublicationFailure); },
+        schedule: (task) => {
+          void reservation.publish(task).catch(recordPublicationFailure);
+        },
         cancel: reservation.cancel,
       };
     },
@@ -1203,9 +1474,9 @@ export function registerTelegramLifecycleRuntimeHooks({
     setActiveToolExecutions: lifecycle.setActiveToolExecutions,
     triggerPendingModelSwitchAbort: modelSwitchController.triggerPendingAbort,
   });
-  Lifecycle.setResetTransportReplyDedup(Replies.resetTransportReplyDedup);
   const agentStartWithDedupReset = Lifecycle.createAgentStartDedupHook(
     agentLifecycleHooks.onAgentStart,
+    Replies.resetTransportReplyDedup,
     scheduleActiveTurnDelivery,
   );
   let uiPromptActive = false;
@@ -1230,23 +1501,32 @@ export function registerTelegramLifecycleRuntimeHooks({
   };
   let observedAutomaticCompaction = false;
   let agentWorkActive = false;
-  const prepareCompactionNotice = (text: string, ctx: Pi.ExtensionContext): (() => Promise<void>) => {
+  const prepareCompactionNotice = (
+    text: string,
+    ctx: Pi.ExtensionContext,
+  ): (() => Promise<void>) => {
     const authority = publicationRuntime.capture();
     const turn = activeTurnRuntime.get();
     const selectedTarget = turn?.target ?? authority.target;
     const target = selectedTarget ? { ...selectedTarget } : undefined;
     const replyToMessageId = turn?.replyToMessageId;
     return async () => {
-      if (!target || !isSessionContextActive(ctx) || !authority.isCurrent()) return;
+      if (!target || !isSessionContextActive(ctx) || !authority.isCurrent())
+        return;
       if (turn && isTurnTransportActive?.(turn) === false) return;
       try {
-        await sendMarkdownReply(target.chatId, replyToMessageId, text, { target });
+        await sendMarkdownReply(target.chatId, replyToMessageId, text, {
+          target,
+        });
       } catch (error) {
         recordRuntimeEvent("delivery", error, { phase: "compaction-notice" });
       }
     };
   };
-  const sendCompactionNotice = (text: string, ctx: Pi.ExtensionContext): void => {
+  const sendCompactionNotice = (
+    text: string,
+    ctx: Pi.ExtensionContext,
+  ): void => {
     scheduleActiveTurnDelivery(prepareCompactionNotice(text, ctx));
   };
   const compactionObserver = Lifecycle.createTelegramCompactionObserverRuntime({
@@ -1325,7 +1605,11 @@ export function registerTelegramLifecycleRuntimeHooks({
       if (shouldNotify) observedAutomaticCompaction = true;
       activityRuntime.onCompactionStart(Pi.getSessionCompactionReason(event));
       compactionObserver.onSessionBeforeCompact(event, ctx);
-      if (shouldNotify) sendCompactionNotice(Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN, ctx);
+      if (shouldNotify)
+        sendCompactionNotice(
+          Commands.TELEGRAM_COMPACTION_STARTED_MARKDOWN,
+          ctx,
+        );
     },
     async onSessionCompact(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
@@ -1333,7 +1617,10 @@ export function registerTelegramLifecycleRuntimeHooks({
       compactionObserver.onSessionCompact(event, ctx);
       if (observedAutomaticCompaction) {
         observedAutomaticCompaction = false;
-        sendCompactionNotice(Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN, ctx);
+        sendCompactionNotice(
+          Commands.TELEGRAM_COMPACTION_COMPLETED_MARKDOWN,
+          ctx,
+        );
       }
     },
     async onSessionCompactFailed(event, ctx) {
@@ -1401,13 +1688,29 @@ export function registerTelegramLifecycleRuntimeHooks({
         previewRuntime.seal();
         activityRuntime.onAssistantMessageEnd(event.message.stopReason);
       }
-      if (event.message.role !== "assistant" || event.message.stopReason === "toolUse" || event.message.stopReason === "aborted") return;
+      if (
+        event.message.role !== "assistant" ||
+        event.message.stopReason === "toolUse" ||
+        event.message.stopReason === "aborted"
+      )
+        return;
       const turn = activeTurnRuntime.get();
-      if (!turn || turn.guestQueryId || pendingFinalPublication?.turn === turn) return;
+      if (!turn || turn.guestQueryId || pendingFinalPublication?.turn === turn)
+        return;
       cancelPendingFinalPublication();
-      const assistant = Replies.extractLatestAssistantMessageText([event.message]);
-      if (!assistant.text && assistant.stopReason !== "error" && turn.queuedAttachments.length === 0) return;
-      pendingFinalPublication = { turn, reservation: publicationRuntime.reserve() };
+      const assistant = Replies.extractLatestAssistantMessageText([
+        event.message,
+      ]);
+      if (
+        !assistant.text &&
+        assistant.stopReason !== "error" &&
+        turn.queuedAttachments.length === 0
+      )
+        return;
+      pendingFinalPublication = {
+        turn,
+        reservation: publicationRuntime.reserve(),
+      };
     },
     onUiPromptStart(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
@@ -1427,7 +1730,10 @@ export function registerTelegramLifecycleRuntimeHooks({
     },
     async onAgentEnd(event, ctx) {
       if (!isSessionContextActive(ctx)) return;
-      if (pendingFinalPublication && pendingFinalPublication.turn !== activeTurnRuntime.get()) {
+      if (
+        pendingFinalPublication &&
+        pendingFinalPublication.turn !== activeTurnRuntime.get()
+      ) {
         cancelPendingFinalPublication();
         return;
       }
@@ -1440,7 +1746,8 @@ export function registerTelegramLifecycleRuntimeHooks({
       try {
         await agentLifecycleHooks.onAgentSettled(event, ctx);
       } finally {
-        if (pendingFinalPublication === pending) cancelPendingFinalPublication();
+        if (pendingFinalPublication === pending)
+          cancelPendingFinalPublication();
       }
       if (!isSessionContextActive(ctx)) return;
       agentWorkActive = false;