@llblab/pi-kit 0.1.0

package/node_modules/@llblab/pi-telegram/index.ts

@@ -0,0 +1,1336 @@
+/**
+ * Telegram bridge extension entrypoint and orchestration layer
+ * Zones: telegram, pi agent, orchestration
+ * Keeps the runtime wiring in one place while delegating reusable domain logic to /lib modules
+ */
+
+import * as AgentMessages from "./lib/agent-messages.ts";
+import * as Bindings from "./lib/bindings.ts";
+import * as BusApi from "./lib/bus-api.ts";
+import * as BusFollower from "./lib/bus-follower.ts";
+import * as BusLeader from "./lib/bus-leader.ts";
+import * as BusTransport from "./lib/bus-transport.ts";
+import * as Bus from "./lib/bus.ts";
+import * as CommandTemplates from "./lib/command-templates.ts";
+import * as Commands from "./lib/commands.ts";
+import * as Config from "./lib/config.ts";
+import * as Delivery from "./lib/delivery.ts";
+import * as Inbound from "./lib/inbound.ts";
+import * as Journal from "./lib/journal.ts";
+import * as Lifecycle from "./lib/lifecycle.ts";
+import * as Locks from "./lib/locks.ts";
+import * as Logs from "./lib/logs.ts";
+import * as Media from "./lib/media.ts";
+import * as MenuQueue from "./lib/menu-queue.ts";
+import * as MenuSettings from "./lib/menu-settings.ts";
+import * as Menu from "./lib/menu.ts";
+import * as Model from "./lib/model.ts";
+import * as Outbound from "./lib/outbound.ts";
+import * as Ownership from "./lib/ownership.ts";
+import * as Paths from "./lib/paths.ts";
+import * as Pi from "./lib/pi.ts";
+import * as Polling from "./lib/polling.ts";
+import * as Preview from "./lib/preview.ts";
+import * as PromptTemplates from "./lib/prompt-templates.ts";
+import * as Prompts from "./lib/prompts.ts";
+import * as Queue from "./lib/queue.ts";
+import * as Recovery from "./lib/recovery.ts";
+import * as Replies from "./lib/replies.ts";
+import * as Routing from "./lib/routing.ts";
+import * as Runtime from "./lib/runtime.ts";
+import * as Sections from "./lib/sections.ts";
+import * as Skills from "./lib/skills.ts";
+import * as Status from "./lib/status.ts";
+import * as Sync from "./lib/sync.ts";
+import * as TelegramApi from "./lib/telegram-api.ts";
+import * as TextGroups from "./lib/text-groups.ts";
+import * as ThreadReconciler from "./lib/thread-reconciler.ts";
+import * as Threads from "./lib/threads.ts";
+import * as TimeInjection from "./lib/time-injection.ts";
+import * as Updates from "./lib/updates.ts";
+import * as Voice from "./lib/voice.ts";
+
+type ActivePiModel = NonNullable<Pi.ExtensionContext["model"]>;
+
+const telegramBusProtocolIdentity =
+  Bus.createTelegramCurrentBusProtocolIdentity([
+    Bus.TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION,
+    Bus.TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF,
+  ]);
+
+// --- Extension Runtime ---
+
+export default function (pi: Pi.ExtensionAPI) {
+  Skills.registerTelegramSkillDiscovery(pi);
+  const piRuntime = Pi.createExtensionApiRuntimePorts(pi);
+  const {
+    getActiveTools,
+    getCommands,
+    getThinkingLevel,
+    sendUserMessage,
+    setActiveTools,
+    setModel,
+    setThinkingLevel,
+  } = piRuntime;
+  const bridgeRuntime = Runtime.createTelegramBridgeRuntime();
+  const runtimeDiagnostics =
+    Logs.createTelegramRuntimeDiagnosticsRuntime<Pi.ExtensionContext>();
+  const runtimeEvents = runtimeDiagnostics.events;
+  const recordRuntimeEvent = runtimeDiagnostics.recordRuntimeEvent;
+  const configStore = Config.createTelegramConfigStore({ recordRuntimeEvent });
+  const busProcessRuntime = Bus.createCurrentTelegramBusProcessRuntime({
+    getActiveProfileName: configStore.getActiveProfileName,
+  });
+  const {
+    instanceId: telegramInstanceId,
+    processId: telegramProcessId,
+    processBirthId: telegramQueueProcessBirthId,
+    manualFollowerOwnerId: telegramManualFollowerOwnerId,
+    getLeaderSocketPath: getTelegramBusSocketPath,
+    getFollowerSocketPath: getTelegramBusFollowerSocketPath,
+  } = busProcessRuntime;
+  const getTelegramBotId = Config.createTelegramConfigBotIdGetter(configStore);
+  const getTelegramActiveProfileKey =
+    Config.createTelegramActiveProfileKeyGetter(configStore);
+  const getTelegramManualFollowerProfileKey =
+    BusFollower.createTelegramManualFollowerProfileKeyResolver({
+      getActiveProfileName: configStore.getActiveProfileName,
+      manualFollowerOwnerId: telegramManualFollowerOwnerId,
+    });
+  const telegramBusAuthSecret = Bus.createTelegramBusAuthSecret();
+  const telegramBusFollowerControlState =
+    BusFollower.createTelegramBusFollowerControlState();
+  const telegramBusFollowerRegistry = Bus.createTelegramBusFollowerRegistry();
+  const modelContextAvailabilityBinding =
+    Prompts.createTelegramModelContextAvailabilityBinding();
+  const telegramBusFollowerRegistrationState =
+    BusFollower.createTelegramBusFollowerRegistrationState({
+      onAvailabilityChanged: modelContextAvailabilityBinding.reconcile,
+    });
+  const telegramBusLeaderState =
+    Threads.createTelegramLeaderThreadStateRuntime();
+  const telegramThreadCapabilityState =
+    Polling.createTelegramThreadCapabilityStateRuntime();
+  const telegramProvisioningActivity =
+    Sync.createTelegramProvisioningActivityRuntime();
+  const messageOwnershipRuntime =
+    Ownership.createTelegramBusMessageOwnershipRuntime({
+      instanceId: telegramInstanceId,
+      getProfileKey: getTelegramActiveProfileKey,
+      listFollowers: telegramBusFollowerRegistry.list,
+    });
+  const { abort, lifecycle, queue, setup, typing } = bridgeRuntime;
+  const getTelegramUpdateAdmissionScope =
+    Journal.createTelegramUpdateJournalReceiptScopeResolver({
+      getProfileName: configStore.getActiveProfileName,
+      getBotToken: configStore.getBotToken,
+      getBotId: getTelegramBotId,
+    });
+  const telegramJournalBindingRuntime =
+    Journal.createTelegramUpdateJournalBindingRuntime({
+      base: {
+        getProfileName: configStore.getActiveProfileName,
+        getBotToken: configStore.getBotToken,
+        getBotId: getTelegramBotId,
+        getQueueRuntimeIdentity() {
+          return {
+            instanceId: telegramInstanceId,
+            processId: telegramProcessId,
+            processBirthId: telegramQueueProcessBirthId,
+          };
+        },
+      },
+      getLeaderJournalPath: Paths.resolveTelegramUpdateJournalPath,
+      getFollowerJournalPath(bindingKey, profileName) {
+        return Paths.resolveTelegramFollowerJournalPath(
+          bindingKey,
+          undefined,
+          profileName,
+        );
+      },
+      getActiveFollowerBindingKey: getTelegramManualFollowerProfileKey,
+      isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+    });
+  const resolveTelegramUpdateJournalBinding =
+    telegramJournalBindingRuntime.resolveLeader;
+  const resolveTelegramFollowerJournalBinding =
+    telegramJournalBindingRuntime.resolveFollower;
+  const getTelegramQueueJournalBinding =
+    telegramJournalBindingRuntime.getActiveRecoveryKey;
+  const isTelegramBusRuntimeEnabled =
+    telegramThreadCapabilityState.isBusRuntimeEnabled;
+  Config.bindGlobalTelegramConfigRuntime(configStore);
+  const configControls = Config.createTelegramConfigControls(configStore);
+  const lockRuntime = Locks.createTelegramLockRuntime<Pi.ExtensionContext>({
+    key: Locks.createTelegramLockKeyResolver(configStore),
+    instanceId: telegramInstanceId,
+    busSecret: telegramBusAuthSecret,
+    staleHeartbeatMs: Locks.TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS,
+  });
+  const threadStore = Threads.createTelegramTopicTargetStore({
+    path: function () {
+      return Threads.getTelegramTopicTargetsPath(
+        undefined,
+        configStore.getActiveProfileName(),
+      );
+    },
+    canPersist: lockRuntime.owns,
+    commitPersist: lockRuntime.commitIfOwned,
+  });
+  runtimeDiagnostics.bindStorage({
+    getBotToken: configStore.getBotToken,
+    getProfileName: configStore.getActiveProfileName,
+    canReset: lockRuntime.owns,
+    commitReset: lockRuntime.commitIfOwned,
+  });
+  const lockOwnershipGuard =
+    Locks.createTelegramLockOwnershipGuard(lockRuntime);
+  const getCurrentLeaderEpoch = lockRuntime.getOwnedLeaderEpoch;
+  const telegramSessionContextStore =
+    Lifecycle.createTelegramSessionContextStore<Pi.ExtensionContext>({
+      getIdentity(ctx) {
+        return ctx.sessionManager ?? ctx.cwd;
+      },
+    });
+  const ownsTelegramDirectDelivery =
+    Locks.createTelegramDirectDeliveryOwnershipChecker({
+      lock: lockRuntime,
+      contextStore: telegramSessionContextStore,
+    });
+  const modelContextAvailabilityRuntime =
+    Prompts.createTelegramModelContextAvailabilityRuntime({
+      getActiveTools,
+      setActiveTools,
+      isAvailable() {
+        return (
+          ownsTelegramDirectDelivery() ||
+          telegramBusFollowerRegistrationState.isRegistered()
+        );
+      },
+      canReconcile() {
+        const ctx = telegramSessionContextStore.get();
+        return !ctx || Pi.isExtensionContextIdle(ctx);
+      },
+    });
+  modelContextAvailabilityBinding.bind(modelContextAvailabilityRuntime);
+  const activeTurnRuntime = Queue.createTelegramActiveTurnStore();
+  const proactivePushTargetGetter =
+    Config.createTelegramProactivePushTargetGetter({
+      getActiveTurnTarget: activeTurnRuntime.getTarget,
+      getAssignedTarget() {
+        return (
+          telegramBusFollowerRegistrationState.getTarget() ??
+          telegramBusLeaderState.getTarget()
+        );
+      },
+      getAllowedUserId: configStore.getAllowedUserId,
+    });
+  const proactivePushChatIdGetter =
+    Config.createTelegramProactivePushChatIdGetter(proactivePushTargetGetter);
+  const buttonActionStore = Outbound.createTelegramButtonActionStore();
+  const planGenerativeAppOutput =
+    Outbound.createTelegramOutboundReplyPlanner(buttonActionStore);
+  const pendingModelSwitchStore =
+    Model.createPendingModelSwitchStore<
+      Model.ScopedTelegramModel<ActivePiModel>
+    >();
+  const modelMenuRuntime = Menu.createTelegramModelMenuRuntime<ActivePiModel>();
+  const sectionRegistry = Sections.createAndBindTelegramSectionRegistry();
+
+  const timeInjectionRuntime = TimeInjection.createTimeInjectionRuntime({
+    getConfig: Config.createTelegramTimeConfigGetter(configStore),
+    recordRuntimeEvent,
+  });
+  Outbound.bindTelegramRuntimeEventRecorder(recordRuntimeEvent);
+  const getContextModel = Pi.getExtensionContextModel;
+  const isIdle = Pi.isExtensionContextIdle;
+  const hasPendingMessages = Pi.hasExtensionContextPendingMessages;
+  const compact = Pi.compactExtensionContext;
+  const mediaGroupRuntime = Media.createTelegramMediaGroupController<
+    TelegramApi.TelegramMessage,
+    Pi.ExtensionContext
+  >();
+  const textGroupRuntime = TextGroups.createTelegramTextGroupController<
+    TelegramApi.TelegramMessage,
+    Pi.ExtensionContext
+  >();
+  const rawTelegramQueueStore =
+    Queue.createTelegramQueueStore<Pi.ExtensionContext>();
+  const telegramTransportStampRuntime =
+    Queue.createTelegramTransportStampRuntime({
+      getProfileName: configStore.getActiveProfileName,
+      getBotToken: configStore.getBotToken,
+    });
+  const telegramQueueStore = Queue.createTelegramTransportStampedQueueStore(
+    rawTelegramQueueStore,
+    telegramTransportStampRuntime.getStamp,
+  );
+  const updateAdmissionRuntimeBinding =
+    Updates.createTelegramUpdateAdmissionRuntimeBinding<Pi.ExtensionContext>({
+      isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+    });
+  const deferredQueueDispatchRuntime =
+    Queue.createTelegramDeferredQueueDispatchRuntime<Pi.ExtensionContext>({
+      recordRuntimeEvent,
+    });
+  const pollingControllerState = Polling.createTelegramPollingControllerState();
+  const telegramSyncStateRuntime = Sync.createTelegramSyncStateRuntime();
+  const threadReconciliationRuntime =
+    ThreadReconciler.createThreadReconciliationRuntime({
+      recordRuntimeEvent,
+      scheduleSnapshotPersist: runtimeDiagnostics.scheduleSnapshotPersist,
+    });
+  const recordThreadReconciliationPlan = threadReconciliationRuntime.recordPlan;
+  const persistTelegramConfigWithSync =
+    Sync.createTelegramConfigSyncPersister<Config.TelegramConfig>({
+      persist: configStore.persist,
+      markConfigChange: telegramSyncStateRuntime.markConfigChange,
+    });
+  const persistTelegramPollingOffset =
+    Config.createTelegramPollingOffsetPersister(
+      configStore,
+      persistTelegramConfigWithSync,
+    );
+  const {
+    current: currentInstanceThreadRuntime,
+    status: threadStatusProjectionRuntime,
+  } = Threads.createTelegramCurrentThreadAssembly({
+    instanceId: telegramInstanceId,
+    listRecords: threadStore.list,
+    getActiveTurnTarget: activeTurnRuntime.getTarget,
+    getFollowerTarget: telegramBusFollowerRegistrationState.getTarget,
+    isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+    getFollowerSlot: telegramBusFollowerRegistrationState.getSlot,
+    getFollowerThreadName: telegramBusFollowerRegistrationState.getThreadName,
+    getLeaderIdentity: telegramBusLeaderState.getIdentity,
+    getLeaderTarget: telegramBusLeaderState.getTarget,
+    getLeaderProtocol: telegramBusFollowerRegistrationState.getLeaderProtocol,
+    status: {
+      getThreadMode: function () {
+        return threadStore.getBotState().threadMode;
+      },
+      isBusPollingStarted: telegramThreadCapabilityState.isBusPollingStarted,
+      listFollowers: telegramBusFollowerRegistry.list,
+      listReservations: threadStore.listReservations,
+      listSyncObservations: threadStore.listSyncObservations,
+      getLeaderSocketPath: getTelegramBusSocketPath,
+      getFollowerSocketPath: getTelegramBusFollowerSocketPath,
+      getTransportKind: BusTransport.getTelegramBusTransportKind,
+    },
+  });
+  const findCurrentThreadRecord = currentInstanceThreadRuntime.findRecord;
+  const getCurrentInstanceThreadIdentity =
+    currentInstanceThreadRuntime.getIdentity;
+  const statusRuntime = Status.createTelegramBridgeStatusRuntime<
+    Pi.ExtensionContext,
+    Queue.TelegramQueueItem<Pi.ExtensionContext>
+  >({
+    getConfig: configStore.get,
+    getActiveProfileName: configStore.getActiveProfileName,
+    getDiagnosticPaths: Paths.getTelegramDiagnosticsDisplayPaths,
+    isPollingActive: Polling.createTelegramPollingActivityReader(
+      pollingControllerState,
+    ),
+    getPollingState: Polling.createTelegramPollingStateReader(
+      pollingControllerState,
+    ),
+    getInboundWorkerState() {
+      return updateAdmissionRuntimeBinding.getActive()?.getState();
+    },
+    getActiveSourceMessageIds: activeTurnRuntime.getSourceMessageIds,
+    hasActiveTurn: activeTurnRuntime.has,
+    hasDispatchPending: lifecycle.hasDispatchPending,
+    isCompactionInProgress: lifecycle.isCompactionInProgress,
+    getActiveToolExecutions: lifecycle.getActiveToolExecutions,
+    hasPendingModelSwitch: pendingModelSwitchStore.has,
+    getQueuedItems: telegramQueueStore.getQueuedItems,
+    formatQueuedStatus: Queue.formatQueuedTelegramItemsStatus,
+    getRecentRuntimeEvents: runtimeEvents.getEvents,
+    getRuntimeLockState: lockRuntime.getStatusLabel,
+    ...threadStatusProjectionRuntime,
+    getBusProtocol() {
+      return telegramBusProtocolIdentity;
+    },
+    getBusLifecyclePhase: telegramBusFollowerControlState.getLifecyclePhase,
+    getBotThreadMode() {
+      return threadStore.getBotState();
+    },
+    getSyncState: telegramSyncStateRuntime.getState,
+    getThreadReconciliationState() {
+      return threadReconciliationRuntime.getState();
+    },
+  });
+  runtimeDiagnostics.bindStatus({
+    instanceId: telegramInstanceId,
+    updateStatus: statusRuntime.updateStatus,
+    getStatusState: statusRuntime.getStatusState,
+    async persistSnapshot(snapshot) {
+      threadStore.setStatusSnapshot(snapshot);
+      await threadStore.persist();
+    },
+  });
+  const updateStatus = runtimeDiagnostics.updateStatus;
+  const getStatusLines = runtimeDiagnostics.getStatusLines;
+  const inboundHandlerRuntime = Inbound.createTelegramInboundHandlerRuntime({
+    getHandlers: configStore.getInboundHandlers,
+    execCommand: CommandTemplates.execCommandTemplate,
+    getCwd: Pi.getExtensionContextCwd,
+    recordRuntimeEvent,
+  });
+
+  // --- Telegram API ---
+
+  const directTelegramApiRuntime =
+    TelegramApi.createDefaultTelegramBridgeApiRuntime({
+      getBotToken: configStore.getBotToken,
+      recordRuntimeEvent,
+    });
+  const telegramBusFollowerClients =
+    BusFollower.createTelegramBusFollowerClientRuntime<
+      Pi.ExtensionContext,
+      Updates.TelegramMessageReactionUpdated,
+      Routing.TelegramRoutedCallbackQuery,
+      Routing.TelegramRoutedMessage
+    >({
+      socketPath: getTelegramBusSocketPath,
+      instanceId: telegramInstanceId,
+      getApiAuthSecret: telegramBusFollowerControlState.getActiveAuthSecret,
+      getForwardingAuthSecret() {
+        return telegramBusAuthSecret;
+      },
+      getRegistrationGeneration:
+        telegramBusFollowerRegistrationState.getGeneration,
+      getForwardCommentBatchPosition:
+        textGroupRuntime.getPreparedForwardingPosition,
+      recordRuntimeEvent,
+    });
+  const telegramApiRuntime = BusApi.createTelegramBusAwareApiRuntime({
+    directRuntime: directTelegramApiRuntime,
+    ownsDirect() {
+      return lockRuntime.owns();
+    },
+    getDefaultTarget: proactivePushTargetGetter,
+    callFollowerApi: telegramBusFollowerClients.callApi,
+  });
+  const {
+    call: callTelegramApi,
+    callMultipart,
+    deleteWebhook,
+    getUpdates,
+    setMyCommands,
+    sendTypingAction,
+    sendChatAction,
+    sendRecordVoiceAction,
+    sendMessageDraft,
+    sendMessage,
+    sendRichMessage,
+    sendRichMessageDraft,
+    downloadFile: downloadTelegramBridgeFile,
+    editMessageText: editTelegramMessageText,
+    editMessageReplyMarkup: editTelegramMessageReplyMarkup,
+    answerCallbackQuery,
+    answerGuestQuery,
+    deleteMessage: deleteTelegramMessage,
+    prepareTempDir,
+  } = telegramApiRuntime;
+
+  // --- Message Delivery ---
+
+  const sendGuestReply = Replies.createGuestMarkdownReplySender({
+    answerGuestQuery,
+  });
+
+  const promptDispatchRuntime = Runtime.createTelegramPromptDispatchRuntime({
+    lifecycle,
+    typing,
+    getDefaultChatId: proactivePushChatIdGetter,
+    sendTypingAction,
+    sendAggregateTypingAction:
+      BusApi.createTelegramAggregateTypingActionSender(telegramApiRuntime),
+    updateStatus,
+    isContextActive: telegramSessionContextStore.isCurrent,
+    recordRuntimeEvent,
+  });
+  const currentModelRuntime = Model.createCurrentModelRuntime({
+    getContextModel,
+    updateStatus,
+  });
+
+  // --- Reply Runtime & Preview ---
+
+  const replyRuntime = Replies.createTelegramRenderedMessageDeliveryRuntime({
+    recordOwnership: messageOwnershipRuntime.recordLocal,
+    sendMessage,
+    sendRichMessage,
+    getAssistantRenderingMode: configControls.getAssistantRenderingMode,
+    editMessage: editTelegramMessageText,
+  });
+  const { replyTransport, editInteractiveMessage, sendInteractiveMessage } =
+    replyRuntime;
+  const deliveryTargetPolicyRuntime =
+    Delivery.createTelegramDeliveryTargetPolicyRuntime({
+      ownsDirect: lockRuntime.owns,
+      isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+      getAllowedChatId: configStore.getAllowedUserId,
+      getFollowerTarget: telegramBusFollowerRegistrationState.getTarget,
+      getLeaderTarget: telegramBusLeaderState.getTarget,
+      listThreadRecords: threadStore.list,
+      getActiveTurnTarget: activeTurnRuntime.getTarget,
+      getActiveGuestQueryId: activeTurnRuntime.getGuestQueryId,
+    });
+  const deliveryGenerationSeed =
+    Delivery.createTelegramDeliveryGenerationSeed(telegramInstanceId);
+  const deliveryLifecycleRuntime =
+    Delivery.createTelegramBridgeDeliveryLifecycleHooks({
+      generationSeed: deliveryGenerationSeed,
+      getTargetPolicyView: deliveryTargetPolicyRuntime.getTargetPolicyView,
+      getTransportStamp: telegramTransportStampRuntime.getStamp,
+      isTransportStampActive: telegramTransportStampRuntime.isActive,
+      getActiveTurnTarget: deliveryTargetPolicyRuntime.getActiveTurnTarget,
+      api: telegramApiRuntime,
+      recordOwnership: messageOwnershipRuntime.recordLocal,
+      recordFailure(operation, error, target) {
+        recordRuntimeEvent("delivery", error, {
+          operation,
+          scope: target?.threadId === undefined ? "aggregate" : "thread",
+        });
+      },
+    });
+  const { sendTextReply, sendMarkdownReply } =
+    Outbound.createTelegramOutboundTextReplyRuntime({
+      sendTextReply: replyRuntime.sendTextReply,
+      sendMarkdownReply: replyRuntime.sendMarkdownReply,
+      execCommand: CommandTemplates.execCommandTemplate,
+      getHandlers: configStore.getOutboundHandlers,
+      recordRuntimeEvent,
+    });
+  const invokeGenerativeAppBoundButtonAction =
+    Bindings.createTelegramGenerativeAppBoundButtonActionInvoker({
+      agentDir: Paths.resolveAgentDir(),
+      assertExecutionCurrent: Updates.assertTelegramUpdateExecutionCurrent,
+      getExecutionFence: Updates.getTelegramUpdateExecutionFence,
+      planOutput: planGenerativeAppOutput,
+      sendMarkdownReply,
+      editInteractiveMessage,
+      recordRuntimeEvent,
+    });
+  const {
+    activityRuntime,
+    activityVerbosityRuntime,
+    assistantOutputRuntime,
+  } = Bindings.createTelegramActivityBindingRuntime({
+    generation: deliveryGenerationSeed,
+    assistantOutput: {
+      isEnabled: configControls.isProactivePushEnabled,
+      authority: {
+        getPreferredTarget: proactivePushTargetGetter,
+        getFallbackChatId: proactivePushChatIdGetter,
+        getTransportStamp: telegramTransportStampRuntime.getStamp,
+        isTransportStampActive: telegramTransportStampRuntime.isActive,
+        ownsDirect: lockRuntime.owns,
+        getDirectEpoch: lockRuntime.getOwnedLeaderEpoch,
+        isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+        getFollowerGeneration:
+          telegramBusFollowerRegistrationState.getGeneration,
+      },
+      sender: {
+        recordOwnership: messageOwnershipRuntime.recordLocal,
+        sendMessage,
+        sendRichMessage,
+        editMessage: editTelegramMessageText,
+        getAssistantRenderingMode: configControls.getAssistantRenderingMode,
+        execCommand: CommandTemplates.execCommandTemplate,
+        getHandlers: configStore.getOutboundHandlers,
+        recordRuntimeEvent,
+      },
+      recordRuntimeEvent,
+    },
+    activityVerbosity: {
+      getActivityMode: configControls.getActivityVerbosity,
+      refreshActivityMode: configControls.refreshActivityVerbosity,
+      resolveTarget(event) {
+        return event.target ?? proactivePushTargetGetter();
+      },
+      sendMessage,
+      sendRichMessage,
+      editMessageText: editTelegramMessageText,
+    },
+  });
+  const {
+    mutation: queueMutationRuntime,
+    dispatchNext: dispatchNextQueuedTelegramTurn,
+    watchdog: queueDispatchWatchdogRuntime,
+  } = Bindings.createTelegramQueueBindingRuntime({
+    store: telegramQueueStore,
+    queue,
+    lifecycle,
+    activeTurn: activeTurnRuntime,
+    admission: updateAdmissionRuntimeBinding,
+    transportStamp: telegramTransportStampRuntime,
+    deferredDispatch: deferredQueueDispatchRuntime,
+    promptDispatch: promptDispatchRuntime,
+    isIdle,
+    hasPendingMessages,
+    updateStatus,
+    sendTextReply,
+    sendUserMessage,
+    recordRuntimeEvent,
+  });
+  const nativeMarkdownDraftSender =
+    TelegramApi.createTelegramAssistantDraftSender({
+      getAssistantRenderingMode: configControls.getAssistantRenderingMode,
+      renderMarkdownToHtmlDraft: Replies.renderTelegramMarkdownToHtmlDraft,
+      sendMessageDraft,
+      sendRichMessageDraft,
+    });
+  const previewRuntime = Preview.createTelegramAssistantPreviewRuntime({
+    getActiveTurn: activeTurnRuntime.get,
+    isAssistantMessage: Replies.isAssistantAgentMessage,
+    getMessageText: Replies.getAgentMessageText,
+    getDefaultReplyToMessageId: activeTurnRuntime.getReplyToMessageId,
+    sendDraft: nativeMarkdownDraftSender,
+    canSend: configControls.areDraftPreviewsEnabled,
+    sendMarkdownReply,
+    recordRuntimeEvent,
+    ...replyTransport,
+  });
+  const { finalizeMarkdownPreview } =
+    Outbound.createTelegramOutboundTextPreviewRuntime({
+      finalizeMarkdownPreview: previewRuntime.finalizeMarkdown,
+      execCommand: CommandTemplates.execCommandTemplate,
+      getHandlers: configStore.getOutboundHandlers,
+      recordRuntimeEvent,
+    });
+
+  // --- Model And Menu Setup ---
+
+  const modelSwitchController =
+    Model.createTelegramModelSwitchControllerRuntime({
+      isIdle,
+      getPendingModelSwitch: pendingModelSwitchStore.get,
+      setPendingModelSwitch: pendingModelSwitchStore.set,
+      getActiveTurn: activeTurnRuntime.get,
+      getAbortHandler: abort.getHandler,
+      hasAbortHandler: abort.hasHandler,
+      getActiveToolExecutions: lifecycle.getActiveToolExecutions,
+      allocateItemOrder: queue.allocateItemOrder,
+      allocateControlOrder: queue.allocateControlOrder,
+      appendQueuedItem: queueMutationRuntime.append,
+      updateStatus,
+    });
+  const getQueueItemCount =
+    Queue.createTelegramQueueItemCountGetter(telegramQueueStore);
+  const getPromptTemplateCommands =
+    PromptTemplates.createTelegramPromptTemplateCommandGetter({
+      getCommands,
+      getReservedCommandNames: Commands.getTelegramReservedCommandNames,
+    });
+  const menuActions = Menu.createTelegramMenuActionRuntimeWithStateBuilder({
+    runtime: modelMenuRuntime,
+    createSettingsManager: Pi.createSettingsManager,
+    getActiveModel: currentModelRuntime.get,
+    getThinkingLevel,
+    getQueueItemCount,
+    buildStatusHtml: Commands.createTelegramAppMenuHtmlBuilder({
+      buildStatusHtml: Status.createTelegramStatusHtmlBuilder({
+        getActiveModel: currentModelRuntime.get,
+        isCompactionInProgress: lifecycle.isCompactionInProgress,
+        getBridgeStatusLineState: statusRuntime.getStatusState,
+      }),
+      getPromptTemplateCommands,
+    }),
+    storeModelMenuState: modelMenuRuntime.storeState,
+    isIdle,
+    canOfferInFlightModelSwitch: modelSwitchController.canOfferInFlightSwitch,
+    sendTextReply,
+    editInteractiveMessage,
+    sendInteractiveMessage,
+    sectionRegistry,
+
+    // Menu/status UI uses this to reflect whether the active Telegram turn expects voice delivery.
+    isVoiceReplyActive: function () {
+      const turn = activeTurnRuntime.get();
+      return Voice.isVoiceTurn(turn);
+    },
+  });
+
+  // --- Queue And Settings Menus ---
+
+  const getQueueMenuState = Menu.createTelegramModelMenuStateBuilder({
+    runtime: modelMenuRuntime,
+    createSettingsManager: Pi.createSettingsManager,
+    getActiveModel: currentModelRuntime.get,
+  });
+  const queueMenuRuntime = MenuQueue.createTelegramQueueMenuRuntime({
+    telegramQueueStore,
+    queueMutationRuntime,
+    sendInteractiveMessage,
+    editInteractiveMessage,
+    answerCallbackQuery,
+    getModelMenuState: getQueueMenuState,
+    getStoredModelMenuState: modelMenuRuntime.getState,
+    storeModelMenuState: modelMenuRuntime.storeState,
+    updateStatusMessage: menuActions.updateStatusMessage,
+    updateStatus,
+  });
+  const settingsMenuRuntime = MenuSettings.createTelegramSettingsMenuRuntime(
+    {
+      reloadConfig: configStore.load,
+      getModelMenuState: getQueueMenuState,
+      getStoredModelMenuState: modelMenuRuntime.getState,
+      storeModelMenuState: modelMenuRuntime.storeState,
+      editInteractiveMessage,
+      sendInteractiveMessage,
+      answerCallbackQuery,
+      ...configControls,
+    },
+    sectionRegistry,
+  );
+
+  // --- Polling ---
+
+  const foreignOwnedUpdateForwarder =
+    telegramBusFollowerClients.foreignOwnedUpdateForwarder;
+  const followerTargetController = telegramBusFollowerClients.targetController;
+  const restoreFollowerThreadTarget =
+    Bus.createTelegramBusFollowerThreadRestoreHandler({
+      followerRegistry: telegramBusFollowerRegistry,
+      followerTargetController,
+      onRestored() {
+        telegramSyncStateRuntime.markSliceFresh(
+          Sync.TELEGRAM_SYNC_SLICE_TARGET_BINDINGS,
+          {
+            nowMs: Date.now(),
+            action: "follower-thread-restore",
+          },
+        );
+      },
+    });
+  const observedThreadTargetBinding =
+    Polling.createTelegramThreadTargetObservationBinding<Pi.ExtensionContext>();
+  const topicLifecycleSync =
+    Sync.createTelegramObservedTopicLifecycleSyncHandler({
+      topicTargetStore: threadStore,
+      isBusEnabled: isTelegramBusRuntimeEnabled,
+      callApi: callTelegramApi,
+      isTopicProvisioningActive: telegramProvisioningActivity.isActive,
+      getCurrentLeaderEpoch,
+      getThreadReconciliationMachineState: threadReconciliationRuntime.getState,
+      recordThreadReconciliationPlan,
+      assertExecutionCurrent(message) {
+        Updates.assertTelegramUpdateExecutionCurrent(message);
+      },
+      getSyncState: telegramSyncStateRuntime.getState,
+      setSyncState: telegramSyncStateRuntime.setState,
+      recordEvent: recordRuntimeEvent,
+    });
+  const inboundBusProjectionRuntime =
+    Routing.createTelegramInboundBusProjectionRuntime({
+      instanceId: telegramInstanceId,
+      listFollowers: telegramBusFollowerRegistry.list,
+      listThreadRecords: threadStore.list,
+      getLeaderTarget: telegramBusLeaderState.getTarget,
+      isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+      getFollowerTarget: telegramBusFollowerRegistrationState.getTarget,
+      getCurrentIdentity: getCurrentInstanceThreadIdentity,
+    });
+  const inboundRouteRuntime = Routing.createTelegramInboundRouteRuntime({
+    configStore,
+    callApi: callTelegramApi,
+    getCurrentInstanceId() {
+      return telegramInstanceId;
+    },
+    getAdmissionScope: getTelegramUpdateAdmissionScope,
+    getAdmissionJournalBinding: getTelegramQueueJournalBinding,
+    getMessageOwnership: messageOwnershipRuntime.store.get,
+    recordMessageOwnership: messageOwnershipRuntime.recordRouted,
+    ...inboundBusProjectionRuntime,
+    getCurrentLeaderEpoch,
+    setCurrentLeaderIdentity: telegramBusLeaderState.set,
+    getThreadReconciliationMachineState: threadReconciliationRuntime.getState,
+    recordThreadReconciliationPlan,
+    handleTelegramTopicLifecycleUpdate: topicLifecycleSync,
+    handleTelegramThreadTargetObserved(_target, ctx) {
+      return observedThreadTargetBinding.handle(ctx);
+    },
+    foreignOwnedUpdateForwarder,
+    replaceFollowerThreadTarget: restoreFollowerThreadTarget,
+    bridgeRuntime,
+    activeTurnRuntime,
+    mediaGroupRuntime,
+    textGroupRuntime,
+    telegramQueueStore,
+    queueMutationRuntime,
+    modelMenuRuntime,
+    currentModelRuntime,
+    modelSwitchController,
+    menuActions,
+    updateSettingsMenuMessage: settingsMenuRuntime.updateSettingsMenuMessage,
+    openQueueMenu: queueMenuRuntime.openQueueMenu,
+    queueMenuCallbackHandler: queueMenuRuntime.handleCallbackQuery,
+    openSettingsMenu: settingsMenuRuntime.openSettingsMenu,
+    settingsMenuCallbackHandler: settingsMenuRuntime.handleCallbackQuery,
+    sectionRegistry,
+    buttonActionStore,
+    invokeBoundButtonAction: invokeGenerativeAppBoundButtonAction,
+    inboundHandlerRuntime,
+    threadStore,
+    updateStatus,
+    isContextActive: telegramSessionContextStore.isCurrent,
+    dispatchNextQueuedTelegramTurn,
+    requestDeferredDispatchNextQueuedTelegramTurn:
+      deferredQueueDispatchRuntime.request,
+    hasDeferredDispatchContext: deferredQueueDispatchRuntime.isBound,
+    startTypingLoop: promptDispatchRuntime.startTypingLoop,
+    stopTypingLoop: typing.stop,
+    answerCallbackQuery,
+    editInteractiveMessage,
+    editMessageReplyMarkup: editTelegramMessageReplyMarkup,
+    sendInteractiveMessage,
+    deleteMessage: deleteTelegramMessage,
+    answerGuestQuery,
+    sendTextReply,
+    setMyCommands,
+    getCommands,
+    downloadFile: downloadTelegramBridgeFile,
+    resolveTimeLine: timeInjectionRuntime.resolveLine,
+    getThinkingLevel,
+    setThinkingLevel,
+    persistScopedModelPatterns: Pi.createScopedModelPatternPersister({
+      createSettingsManager: Pi.createSettingsManager,
+      clearCachedModelMenuInputs: modelMenuRuntime.clearCachedInputs,
+    }),
+    setModel,
+    sendUserMessage,
+    isIdle,
+    hasPendingMessages,
+    compact,
+    recordRuntimeEvent,
+  });
+  const queueHandoffReconciliationBinding =
+    Updates.createTelegramQueueHandoffReconciliationBinding<Pi.ExtensionContext>(
+      function (error) {
+        recordRuntimeEvent("inbound-worker", error, {
+          phase: "queue-handoff-reconcile",
+        });
+      },
+    );
+  const {
+    owner: updateWorkerOwnerRuntime,
+    leader: updateAdmissionLifecycleRuntime,
+    follower: followerAdmissionLifecycleRuntime,
+  } = Updates.createTelegramUpdateAdmissionRuntimeAssembly<
+    Parameters<typeof inboundRouteRuntime.handleUpdate>[0] &
+      Journal.TelegramJournaledUpdate,
+    Pi.ExtensionContext
+  >({
+    runtimeBinding: updateAdmissionRuntimeBinding,
+    owner: {
+      instanceId: telegramInstanceId,
+      processId: telegramProcessId,
+      processBirthId: telegramQueueProcessBirthId,
+      getSessionGeneration: telegramSessionContextStore.getGeneration,
+      isContextCurrent: telegramSessionContextStore.isCurrent,
+      dispatchNext: dispatchNextQueuedTelegramTurn,
+      requestQueueHandoffReconciliation:
+        queueHandoffReconciliationBinding.request,
+    },
+    worker: {
+      defaultHandle: inboundRouteRuntime.handleUpdate,
+      onStateChange: runtimeDiagnostics.scheduleSnapshotPersist,
+    },
+    leader: {
+      resolveBinding: resolveTelegramUpdateJournalBinding,
+      hasAuthority: lockRuntime.owns,
+    },
+    follower: {
+      resolveBinding: resolveTelegramFollowerJournalBinding,
+      isRegistered: telegramBusFollowerRegistrationState.isRegistered,
+      getGeneration: telegramBusFollowerRegistrationState.getGeneration,
+      prepareUpdateForExecution(update) {
+        return BusFollower.prepareTelegramBusFollowerJournaledUpdateForExecution(
+          update,
+          textGroupRuntime.prepareForwardedMessage,
+        );
+      },
+    },
+    recordRuntimeEvent,
+  });
+  const queueHandoffStagingRuntime =
+    Queue.createTelegramQueueHandoffStagingRuntime({
+      liveStore: telegramQueueStore,
+      createControlExecution:
+        Updates.createTelegramQueueHandoffControlExecutionFactory({
+          isContextCurrent: telegramSessionContextStore.isCurrent,
+          showStatus: menuActions.sendStatusMessage,
+          openModelMenu: menuActions.openModelMenu,
+        }),
+    });
+  const acceptStagedQueueHandoff =
+    Updates.createTelegramQueueHandoffRecipientRuntime({
+      staging: queueHandoffStagingRuntime,
+      getRecipientOwner: updateWorkerOwnerRuntime.getQueueOwnerIdentity,
+      getLifecycleForBinding:
+        updateAdmissionRuntimeBinding.getLifecycleForJournalBinding,
+      isTransportStampActive: telegramTransportStampRuntime.isActive,
+      dispatchNext: dispatchNextQueuedTelegramTurn,
+    });
+  const followerDurableAdmissionRuntime =
+    BusFollower.createTelegramBusFollowerDurableAdmissionRuntime({
+      journal: {
+        appendBatch(updates) {
+          return followerAdmissionLifecycleRuntime.appendBatch(updates);
+        },
+      },
+      signalWorker() {
+        followerAdmissionLifecycleRuntime.signal();
+      },
+    });
+  const promoteTelegramBusFollowerToLeader: BusFollower.TelegramBusFollowerPromotionHandler<Pi.ExtensionContext> =
+    BusFollower.createTelegramBusFollowerPromotionHandler<Pi.ExtensionContext>({
+      topicTargetStore: threadStore,
+      instanceId: telegramInstanceId,
+      getActiveProfileName: configStore.getActiveProfileName,
+      async startLeader(ctx, election, onAcquired): Promise<boolean> {
+        const result = await lockedPollingRuntime.start(ctx, {
+          election,
+          onAcquired,
+        });
+        return result.ok;
+      },
+      recordRuntimeEvent,
+    });
+  const agentMessageRuntime = AgentMessages.createTelegramAgentMessageRuntime({
+    instanceId: telegramInstanceId,
+    getAllowedChatId: configStore.getAllowedUserId,
+    getLeaderTarget: telegramBusLeaderState.getTarget,
+    getLeaderThreadName() {
+      return findCurrentThreadRecord()?.threadName;
+    },
+    followerRegistry: telegramBusFollowerRegistry,
+    getContext: telegramSessionContextStore.get,
+    handleUpdate: inboundRouteRuntime.handleUpdate,
+  });
+  const agentMessageToolRoutingRuntime =
+    Bindings.createTelegramAgentMessageToolRoutingRuntime({
+      ownsLeader: lockRuntime.owns,
+      ownsDirectDelivery: ownsTelegramDirectDelivery,
+      isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+      getSourceTarget: proactivePushTargetGetter,
+      getSourceThreadName() {
+        return findCurrentThreadRecord()?.threadName;
+      },
+      local: agentMessageRuntime,
+      follower: telegramBusFollowerClients.agentMessages,
+    });
+  const telegramBusFollowerAssembly: BusFollower.TelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext> =
+    BusFollower.createTelegramBusFollowerRuntimeAssembly<Pi.ExtensionContext>({
+      instanceId: telegramInstanceId,
+      registrationState: telegramBusFollowerRegistrationState,
+      recordRuntimeEvent,
+      receiver: {
+        socketPath: getTelegramBusFollowerSocketPath,
+        getContext: telegramSessionContextStore.get,
+        getAuthSecret: telegramBusFollowerControlState.getActiveAuthSecret,
+        getRecipientBindingKey: getTelegramManualFollowerProfileKey,
+        durableAdmission: followerDurableAdmissionRuntime,
+        handleQueueHandoff: acceptStagedQueueHandoff,
+      },
+      targetReplacement: {
+        topicTargetStore: threadStore,
+        getManualFollowerProfileKey: getTelegramManualFollowerProfileKey,
+        manualFollowerOwnerId: telegramManualFollowerOwnerId,
+        getSyncState: telegramSyncStateRuntime.getState,
+        setSyncState: telegramSyncStateRuntime.setState,
+        updateStatus,
+      },
+      recovery: {
+        getLeaderState: lockRuntime.getState,
+        setLifecyclePhase: telegramBusFollowerControlState.setLifecyclePhase,
+        updateStatus,
+        promoteToLeader: promoteTelegramBusFollowerToLeader,
+        getActiveContext: telegramSessionContextStore.get,
+      },
+      registration: {
+        protocolIdentity: telegramBusProtocolIdentity,
+        getFollowerBusSocketPath: getTelegramBusFollowerSocketPath,
+        getLeaderSocketPath: getTelegramBusSocketPath,
+        isContextActive: telegramSessionContextStore.isCurrent,
+        createRequestId: telegramBusFollowerClients.createRequestId,
+        setActiveAuthSecret:
+          telegramBusFollowerControlState.setActiveAuthSecret,
+        getProfileKey: getTelegramManualFollowerProfileKey,
+        getProcessBirthId() {
+          return telegramQueueProcessBirthId;
+        },
+        getSessionGeneration: telegramSessionContextStore.getGeneration,
+        async onRegistered(ctx) {
+          await followerAdmissionLifecycleRuntime.onTransportChanged(ctx);
+          queueHandoffReconciliationBinding.request(ctx);
+        },
+      },
+    });
+  const telegramBusFollowerRegistration =
+    telegramBusFollowerAssembly.registration;
+  const { admission: pollingAdmissionRuntime } =
+    Polling.createTelegramDurablePollingRuntimeAssembly<
+      TelegramApi.TelegramUpdate,
+      Pi.ExtensionContext
+    >({
+      state: pollingControllerState,
+      getConfig: configStore.get,
+      hasBotToken: configStore.hasBotToken,
+      deleteWebhook,
+      getUpdates,
+      persistConfig: persistTelegramPollingOffset,
+      prepareUpdateBatch: textGroupRuntime.prepareUpdateBatch,
+      journal: {
+        appendBatch(updates) {
+          return updateAdmissionLifecycleRuntime.appendBatch(
+            updates as Journal.TelegramJournaledUpdate[],
+          );
+        },
+        getEntryCount: updateAdmissionLifecycleRuntime.getJournalEntryCount,
+        signalWorker: updateAdmissionLifecycleRuntime.signal,
+        getBootstrapEntryCount() {
+          return (
+            resolveTelegramUpdateJournalBinding()?.journal.read().entries
+              .length ?? 0
+          );
+        },
+        onSessionStart: updateAdmissionLifecycleRuntime.onSessionStart,
+      },
+      stopTypingLoop: typing.stop,
+      updateStatus,
+      onPollingStateChange: runtimeDiagnostics.scheduleSnapshotPersist,
+      recordRuntimeEvent,
+    });
+  const recoverStaleTelegramTopicApiError =
+    Sync.createTelegramStaleTopicApiErrorRecoveryRuntime({
+      topicTargetStore: threadStore,
+      getSyncState: telegramSyncStateRuntime.getState,
+      setSyncState: telegramSyncStateRuntime.setState,
+      recordEvent: recordRuntimeEvent,
+    });
+  const authorizeFollowerApiCall = Bus.createTelegramFollowerApiCallAuthorizer({
+    isMessageOwned: messageOwnershipRuntime.isOwnedByFollower,
+  });
+  const telegramBusLeaderRuntime =
+    BusLeader.createTelegramBusLeaderRuntimeAssembly<Pi.ExtensionContext>({
+      runtime: {
+        socketPath: getTelegramBusSocketPath,
+        commitEndpointPublication(commit) {
+          return lockRuntime.commitIfOwned(commit);
+        },
+        followerRegistry: telegramBusFollowerRegistry,
+        authSecret: telegramBusAuthSecret,
+        protocolIdentity: telegramBusProtocolIdentity,
+        startPolling: pollingAdmissionRuntime.start,
+        stopPolling: pollingAdmissionRuntime.stop,
+        authorizeFollowerApiCall,
+        resolveAgentTarget(follower, selector) {
+          return agentMessageRuntime.resolveTarget(selector, follower.target);
+        },
+        routeAgentMessage(follower, message) {
+          return agentMessageRuntime.route({
+            sourceTarget: follower.target,
+            sourceThreadName: follower.threadName,
+            message,
+          });
+        },
+        isFollowerProcessAlive: Locks.isProcessAlive,
+        shouldCleanupConfirmedDeadFollower:
+          configControls.resolveAutomaticThreadCleanupEnabled,
+        recordFollowerMessageOwnership(record) {
+          messageOwnershipRuntime.recordFollower(record);
+        },
+      },
+      getAllowedUserId: configStore.getAllowedUserId,
+      instanceId: telegramInstanceId,
+      getCwd: Pi.getExtensionContextCwd,
+      getTelegramProfile: configStore.getActiveProfileName,
+      shouldForceFreshUnnamed:
+        telegramThreadCapabilityState.shouldForceFreshLeaderThread,
+      topicTargetStore: threadStore,
+      callApi(method, body) {
+        return directTelegramApiRuntime.call(method, body);
+      },
+      callMultipart: directTelegramApiRuntime.callMultipart,
+      downloadFile: directTelegramApiRuntime.downloadFile,
+      recoverStaleTargetError: recoverStaleTelegramTopicApiError,
+      getCurrentLeaderEpoch,
+      getThreadReconciliationMachineState: threadReconciliationRuntime.getState,
+      recordThreadReconciliationPlan,
+      getSyncState: telegramSyncStateRuntime.getState,
+      setSyncState: telegramSyncStateRuntime.setState,
+      setLeaderTarget: telegramBusLeaderState.set,
+      onProvisioningStart: telegramProvisioningActivity.start,
+      onProvisioningEnd: telegramProvisioningActivity.end,
+      recordRuntimeEvent,
+    });
+  queueHandoffReconciliationBinding.set(
+    Updates.createTelegramQueueHandoffReconciliationRuntimeAssembly({
+      ownsDirect: lockRuntime.owns,
+      isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+      isBusEnabled: isTelegramBusRuntimeEnabled,
+      canHandoffWithLeader() {
+        return Bus.hasTelegramBusCapability(
+          telegramBusFollowerRegistrationState.getLeaderProtocol(),
+          Bus.TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF,
+        );
+      },
+      listFollowers: telegramBusFollowerRegistry.list,
+      createRecipientJournalResolver:
+        telegramJournalBindingRuntime.createRecipientResolver,
+      queueStore: telegramQueueStore,
+      admission: updateAdmissionRuntimeBinding,
+      createHandoffToken: Journal.createTelegramUpdateQueueHandoffToken,
+      createRequestId: telegramBusFollowerClients.createRequestId,
+      donorInstanceId: telegramInstanceId,
+      authSecret: telegramBusAuthSecret,
+      stageThroughFollower: telegramBusFollowerClients.queueHandoff,
+      routeThroughLeader: telegramBusLeaderRuntime.routeQueueHandoff,
+      recordRuntimeEvent,
+    }),
+  );
+  const telegramLeaderHealthRuntime = Sync.createTelegramLeaderHealthRuntime({
+    callGetMe() {
+      return directTelegramApiRuntime.call("getMe", {});
+    },
+    getSyncState: telegramSyncStateRuntime.getState,
+    setSyncState: telegramSyncStateRuntime.setState,
+    recordEvent: recordRuntimeEvent,
+  });
+  const telegramThreadCapabilityRuntime =
+    Polling.createTelegramThreadCapabilityOrchestration<
+      Pi.ExtensionContext,
+      Locks.TelegramLockEntry
+    >({
+      state: telegramThreadCapabilityState,
+      getAllowedUserId: configStore.getAllowedUserId,
+      callApi: callTelegramApi,
+      topicTargetStore: threadStore,
+      isBusRuntimeEnabled: isTelegramBusRuntimeEnabled,
+      ownsLock: lockRuntime.owns,
+      isFollowerRegistered: telegramBusFollowerRegistrationState.isRegistered,
+      startClassicPolling: pollingAdmissionRuntime.start,
+      stopClassicPolling: pollingAdmissionRuntime.stop,
+      startBusLeaderPolling: telegramBusLeaderRuntime.startPolling,
+      stopBusLeaderPolling: telegramBusLeaderRuntime.stopPolling,
+      startLeaderHealth: telegramLeaderHealthRuntime.start,
+      stopLeaderHealth: telegramLeaderHealthRuntime.stop,
+      registerFollowerWithLeader:
+        telegramBusFollowerRegistration.registerWithLeader,
+      stopFollowerRegistration: telegramBusFollowerRegistration.stop,
+      isTopicModeUnavailableError: Threads.isTelegramTopicModeUnavailableError,
+      updateStatus,
+      recordEvent: recordRuntimeEvent,
+    });
+  const telegramThreadCapabilityMonitor =
+    telegramThreadCapabilityRuntime.monitor;
+  observedThreadTargetBinding.set(
+    telegramThreadCapabilityRuntime.observeTarget,
+  );
+  const threadAwarePollingPorts = telegramThreadCapabilityRuntime.pollingPorts;
+  const lockedPollingRuntime = Locks.createTelegramLockedPollingRuntime({
+    lock: lockRuntime,
+    hasBotToken: configStore.hasBotToken,
+    canStartPolling: Pi.canStartPollingInExtensionContext,
+    formatStartBlockedMessage: Pi.formatPollingStartBlockedByRunMode,
+    startPolling: threadAwarePollingPorts.startPolling,
+    stopPolling: threadAwarePollingPorts.stopPolling,
+    registerFollowerWithOwner:
+      threadAwarePollingPorts.registerFollowerWithOwner,
+    stopFollowerRegistration: threadAwarePollingPorts.stopFollowerRegistration,
+    onTransportAvailabilityChanged() {
+      modelContextAvailabilityRuntime.reconcile();
+      const ctx = telegramSessionContextStore.get();
+      if (ctx) queueHandoffReconciliationBinding.request(ctx);
+    },
+    updateStatus,
+    recordRuntimeEvent,
+  });
+  const {
+    disconnect: disconnectTelegramAndDeleteCurrentThread,
+    cleanupForSessionRestart: cleanupTelegramThreadForSessionRestart,
+  } = Sync.createTelegramThreadDisconnectAssembly({
+    instanceId: telegramInstanceId,
+    getCurrentThreadRecord: findCurrentThreadRecord,
+    topicTargetStore: threadStore,
+    callApi: callTelegramApi,
+    getCurrentLeaderEpoch,
+    getLeaderTarget: telegramBusLeaderState.getTarget,
+    clearLeaderTarget: telegramBusLeaderState.clear,
+    disconnectFollowerThread:
+      telegramBusFollowerRegistration.disconnectFromLeader,
+    getSyncState: telegramSyncStateRuntime.getState,
+    setSyncState: telegramSyncStateRuntime.setState,
+    stopPolling: lockedPollingRuntime.stop,
+    suspendPolling: lockedPollingRuntime.suspend,
+    recordRuntimeEvent,
+  });
+  const telegramBridgeSessionLifecycleDeps =
+    Lifecycle.createTelegramBridgeSessionLifecycleDeps({
+      contextStore: telegramSessionContextStore,
+      queue: {
+        getCurrentModel: getContextModel,
+        loadConfig: configStore.load,
+        setQueuedItems: telegramQueueStore.setQueuedItems,
+        setCurrentModel: currentModelRuntime.set,
+        setPendingModelSwitch: pendingModelSwitchStore.set,
+        syncCounters: queue.syncCounters,
+        syncFlags: lifecycle.syncFlags,
+        bindDeferredDispatchContext: deferredQueueDispatchRuntime.bind,
+        prepareTempDir,
+        updateStatus,
+        unbindDeferredDispatchContext: deferredQueueDispatchRuntime.unbind,
+        clearModelMenuState: modelMenuRuntime.clear,
+        getActiveTurnChatId: activeTurnRuntime.getChatId,
+        getActiveTurnTarget: activeTurnRuntime.getTarget,
+        clearPreview: previewRuntime.clear,
+        clearActiveTurn: activeTurnRuntime.clear,
+        clearAbort: abort.clearHandler,
+        recordRuntimeEvent,
+      },
+      follower: {
+        registrationState: telegramBusFollowerRegistrationState,
+        registrationRuntime: telegramBusFollowerRegistration,
+        instanceId: telegramInstanceId,
+        suspendPolling: lockedPollingRuntime.suspend,
+        isLeader: lockRuntime.owns,
+        getLeaderBinding: currentInstanceThreadRuntime.getRestorationIdentity,
+        getActiveContext: telegramSessionContextStore.get,
+        getActiveProfileName: configStore.getActiveProfileName,
+        getLeaderState: lockRuntime.getState,
+        updateStatus,
+        recordRuntimeEvent,
+      },
+      services: {
+        mediaGroup: {
+          resume: mediaGroupRuntime.resume,
+          suspend: mediaGroupRuntime.suspend,
+        },
+        textGroup: {
+          resume: textGroupRuntime.resume,
+          suspend: textGroupRuntime.suspend,
+        },
+        delivery: deliveryLifecycleRuntime,
+        polling: lockedPollingRuntime,
+        inboundWorker: {
+          onSessionShutdown: updateAdmissionRuntimeBinding.onSessionShutdown,
+        },
+        capabilityMonitor: telegramThreadCapabilityMonitor,
+        queueWatchdog: queueDispatchWatchdogRuntime,
+      },
+    });
+  const sessionLifecycleRuntime =
+    Lifecycle.createTelegramBridgeSessionLifecycleAssembly(
+      telegramBridgeSessionLifecycleDeps,
+    );
+
+  // --- Extension API Bindings ---
+
+  Bindings.registerTelegramCommandsAndTools({
+    pi,
+    agentDir: Paths.resolveAgentDir(),
+    configStore,
+    persistConfig: persistTelegramConfigWithSync,
+    setup,
+    activeTurnRuntime,
+    lockedPollingRuntime,
+    stopPolling: disconnectTelegramAndDeleteCurrentThread,
+    recoverPollingStart: Recovery.createTelegramPollingStartRecoveryHandler({
+      getOwnersPath: Paths.resolveTelegramOwnersPath,
+      getStatePaths() {
+        return [
+          Threads.getTelegramTopicTargetsPath(
+            undefined,
+            configStore.getActiveProfileName(),
+          ),
+        ];
+      },
+      suspendPolling: lockedPollingRuntime.suspend,
+      releaseOwnership: lockRuntime.release,
+      recordRuntimeEvent,
+    }),
+    getDisconnectThreadName() {
+      const record = findCurrentThreadRecord();
+      if (!record?.target.threadId) return undefined;
+      return record.threadName ?? "current Telegram thread";
+    },
+    onTransportChanged() {
+      deliveryLifecycleRuntime.onSessionStart();
+      activityVerbosityRuntime.reset();
+      modelContextAvailabilityRuntime.reconcile();
+    },
+    getStatusLines,
+    buttonActionStore,
+    sendMarkdownReply,
+    callMultipart,
+    getDefaultChatId: proactivePushChatIdGetter,
+    getDefaultTarget: proactivePushTargetGetter,
+    ...agentMessageToolRoutingRuntime,
+    updateStatus,
+    recordRuntimeEvent,
+  });
+
+  // --- Lifecycle Hooks ---
+
+  Bindings.registerTelegramLifecycleRuntimeHooks({
+    pi,
+    sessionLifecycleRuntime: {
+      ...sessionLifecycleRuntime,
+      onModelSelect: currentModelRuntime.onModelSelect,
+    },
+    activityRuntime,
+    activityVerbosityRuntime,
+    assistantOutputRuntime,
+    configStore,
+    abort,
+    typing,
+    lifecycle,
+    activeTurnRuntime,
+    telegramQueueStore,
+    modelSwitchController,
+    previewRuntime,
+    promptDispatchRuntime,
+    deferredQueueDispatchRuntime,
+    modelContextAvailabilityRuntime,
+    disconnectOnQuit: cleanupTelegramThreadForSessionRestart,
+    resolveAutomaticThreadCleanupEnabled:
+      configControls.resolveAutomaticThreadCleanupEnabled,
+    buttonActionStore,
+    callMultipart,
+    sendChatAction,
+    sendRecordVoiceAction,
+    sendMarkdownReply,
+    sendTextReply,
+    dispatchNextQueuedTelegramTurn,
+    onPromptHandedOff(turn, ctx) {
+      updateAdmissionRuntimeBinding
+        .getSettlement()
+        ?.onPromptHandedOff(turn, ctx);
+    },
+    answerGuestQuery,
+    deleteMessage: deleteTelegramMessage,
+    sendGuestReply,
+    finalizeMarkdownPreview,
+    proactivePushTargetGetter,
+    getAssistantRenderingMode: configControls.getAssistantRenderingMode,
+    recordMessageOwnership: messageOwnershipRuntime.recordLocal,
+    canSendAgentActivity(ctx) {
+      return (
+        lockOwnershipGuard.ownsContext(ctx) ||
+        telegramBusFollowerRegistrationState.isRegistered()
+      );
+    },
+    isSessionContextActive(ctx) {
+      return telegramSessionContextStore.isCurrent(ctx);
+    },
+    isTurnTransportActive(turn) {
+      return telegramTransportStampRuntime.isActive(turn.transportStamp);
+    },
+    updateStatus,
+    recordRuntimeEvent,
+  });
+}