@llblab/pi-telegram 0.54.4 → 0.55.0

package/lib/bus-leader.ts

@@ -26,6 +26,7 @@ import {
   TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY,
   TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT,
   TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE,
+  TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND,
   TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT,
   TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE,
   TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME,
@@ -158,6 +159,8 @@ export interface TelegramBusLeaderTargetProvisionerDeps<TContext> {
 
 export interface TelegramBusFollowerTargetProvisionerDeps {
   getAllowedUserId: () => number | undefined;
+  getLiveFollowers?: () => readonly TelegramBusFollowerView[];
+  isFollowerProcessAlive?: (pid: number) => boolean;
   topicTargetStore: Threads.TelegramTopicTargetStore;
   callApi: <TResponse>(
     method: string,
@@ -569,12 +572,15 @@ export function createTelegramBusLeaderRuntimeAssembly<TContext>(
       });
     });
   };
-  const beginStartupDisplayStabilization = () => {
+  /** Returns the stabilization this startup owns; a stop or a newer startup meanwhile makes it inert. */
+  const beginStartupDisplayStabilization = (): number => {
     cancelStartupDisplayStabilization();
     startupDisplaySettled = false;
+    return startupDisplayGeneration;
   };
-  const armStartupDisplayReconciliation = () => {
-    const generation = startupDisplayGeneration;
+  const armStartupDisplayReconciliation = (generation: number) => {
+    if (startupDisplayGeneration !== generation) return;
+    if (startupDisplayTimer) clearTimeout(startupDisplayTimer);
     const delayMs =
       deps.runtime.followerStaleAfterMs ?? TELEGRAM_BUS_FOLLOWER_STALE_AFTER_MS;
     startupDisplayTimer = setTimeout(() => {
@@ -673,6 +679,8 @@ export function createTelegramBusLeaderRuntimeAssembly<TContext>(
     });
   const provisionFollowerTarget = createTelegramBusFollowerTargetProvisioner({
     ...provisionerPorts,
+    getLiveFollowers: deps.runtime.followerRegistry.list,
+    isFollowerProcessAlive: deps.runtime.isFollowerProcessAlive,
   });
   const renameLeaderThreadAdmitted = async (
     threadName: string,
@@ -1388,14 +1396,18 @@ export function createTelegramBusLeaderRuntimeAssembly<TContext>(
     resetThreadNameAdmitted,
     captureWorkspaceExternalProtection: deps.captureWorkspaceExternalProtection,
     async startPolling(ctx: TContext) {
-      if (display) beginStartupDisplayStabilization();
+      const stabilization = display
+        ? beginStartupDisplayStabilization()
+        : undefined;
       try {
         await runtime.startPolling(ctx);
       } catch (error) {
-        cancelStartupDisplayStabilization();
+        if (stabilization === startupDisplayGeneration)
+          cancelStartupDisplayStabilization();
         throw error;
       }
-      if (display) armStartupDisplayReconciliation();
+      if (stabilization !== undefined)
+        armStartupDisplayReconciliation(stabilization);
     },
     async stopPolling() {
       cancelStartupDisplayStabilization();
@@ -1535,12 +1547,35 @@ export function createTelegramBusFollowerTargetProvisioner(
     const chatId = deps.getAllowedUserId();
     if (typeof chatId !== "number") return registration.target;
     await deps.topicTargetStore.load();
+    let restoredPredecessor: Threads.TelegramTopicTargetRecord | undefined;
+    if (options?.existingWorkspaceBindingOnly && registration.cwd && registration.sessionId &&
+        !registration.previousInstanceId && deps.getLiveFollowers && deps.isFollowerProcessAlive) {
+      const identity = Threads.createTelegramWorkspaceBindingIdentity(registration.cwd, 0, registration.sessionId);
+      const records = deps.topicTargetStore.list(), liveFollowers = deps.getLiveFollowers();
+      const candidates = deps.topicTargetStore.listWorkspaceBindings()
+        .filter(binding => identity && binding.cwd === identity.cwd && binding.sessionId === identity.sessionId &&
+          (!registration.target || (binding.target.chatId === registration.target.chatId && binding.target.threadId === registration.target.threadId)))
+        .flatMap(binding => {
+          const matches = records.filter(record => record.status === "active" && record.owner?.kind === "manual-follower" &&
+            record.target.chatId === binding.target.chatId && record.target.threadId === binding.target.threadId);
+          return matches.length === 1 ? matches : [];
+        })
+        .filter(record => {
+          if (liveFollowers.some(peer => peer.instanceId === record.instanceId ||
+            (peer.target?.chatId === record.target.chatId && peer.target.threadId === record.target.threadId))) return false;
+          // A retained status is not current execution proof. Only an absent actual runtime PID grants this claim handoff.
+          const match = /^([1-9][0-9]*):[0-9]+$/.exec(record.instanceId ?? ""), pid = match ? Number(match[1]) : undefined;
+          if (pid === undefined || !Number.isSafeInteger(pid)) return false;
+          try { return deps.isFollowerProcessAlive!(pid) === false; } catch { return false; }
+        });
+      if (candidates.length === 1) restoredPredecessor = candidates[0];
+    }
     let capacityUnavailable = false;
     const workspaceIdentity = registration.cwd
       ? deps.topicTargetStore.claimWorkspaceIdentity(
           registration.cwd,
           registration.instanceId,
-          registration.previousInstanceId,
+          registration.previousInstanceId ?? restoredPredecessor?.instanceId,
           {
             existingBindingOnly: options?.existingWorkspaceBindingOnly === true,
             sessionId: registration.sessionId,
@@ -1603,6 +1638,7 @@ export function createTelegramBusFollowerTargetProvisioner(
         record.owner?.kind === "manual-follower" &&
         ((matchesCurrentIdentity && matchesRequestedTarget) ||
           matchesSessionHandoff ||
+          (record.instanceId === restoredPredecessor?.instanceId && matchesRequestedTarget) ||
           matchesWorkspaceRecovery)
       );
     });
@@ -1815,16 +1851,14 @@ export function createTelegramBusFollowerTargetProvisioner(
         crossSessionReuse ||
         probeRequiredRecord ||
         recoverableTarget !== undefined;
+      const retainedDisplayBinding = deps.topicTargetStore.getWorkspaceBindingByTarget(result.target, registration.sessionId);
       let connectedAnnouncement =
         !result.reused || requiresVisibilityProbe
           ? createTelegramBusInstanceLifecycleAnnouncement({
               target: result.target,
               threadName:
                 result.displayTitle ??
-                (workspaceBinding?.target.chatId === result.target.chatId &&
-                workspaceBinding.target.threadId === result.target.threadId
-                  ? workspaceBinding.displayTitle
-                  : undefined) ??
+                (retainedDisplayBinding?.cwd === workspaceIdentity?.cwd ? retainedDisplayBinding?.displayTitle : undefined) ??
                 result.record.threadName,
               slot: result.record.slot,
               state: "connected",
@@ -1972,6 +2006,16 @@ export function createTelegramBusFollowerTargetProvisioner(
             },
           },
         );
+        // Same-target reuse can retain a different slot than the initial claim.
+        if (result.record.slot !== workspaceCommit.slot) {
+          result = {
+            ...result,
+            record: deps.topicTargetStore.upsert({
+              ...result.record,
+              slot: workspaceCommit.slot,
+            }),
+          };
+        }
         if (connectedAnnouncement && workspaceCommit.displayTitle) {
           connectedAnnouncement =
             createTelegramBusInstanceLifecycleAnnouncement({
@@ -2604,8 +2648,7 @@ export function createTelegramBusSelectedMenuDeliveryHandler(deps: {
         .find((value) => value.request.operationId === expected.operationId);
       if (
         !retained ||
-        retained.phase !== "released" ||
-        retained.cleanup ||
+        !Threads.isTelegramLiveRebindInputAuthorized(retained) ||
         retained.request.source.updateIds.length !== 1 ||
         retained.recipient.kind !== "follower" ||
         !isDeepStrictEqual(retained.executor, executor) ||
@@ -2695,8 +2738,13 @@ export function createTelegramBusSelectedMenuDeliveryHandler(deps: {
           resolveJournal.call(workspace, live) !== recipient.journalBindingKey
         )
           throw new Error("Selected-menu authority changed.");
+        const latest = store.listLiveRebindings().find(value => value.request.operationId === intent.request.operationId);
+        if (!latest || !Threads.isTelegramLiveRebindInputAuthorized(latest) ||
+          !isDeepStrictEqual({ ...latest, ...(intent.inputRelease ? { inputRelease: intent.inputRelease } : {}), revision: intent.revision, updatedAtMs: intent.updatedAtMs }, intent) ||
+          (latest.inputRelease !== intent.inputRelease && !(intent.inputRelease === "issued" && latest.inputRelease === "accepted")))
+          throw new Error("Selected-menu input grant changed.");
         let confirmed = false;
-        snapshot.call(threads, intent, (view) => {
+        snapshot.call(threads, latest, (view) => {
           const bindings = (view.workspaceBindings ?? []).filter(
             (value) => value.bindingKey === intent.request.binding.bindingKey,
           );
@@ -2936,6 +2984,7 @@ export interface TelegramBusLeaderEnvelopeHandlerDeps {
     isCurrent: () => boolean,
   ) => Promise<void>;
   getThreadDisplayMode?: () => TelegramThreadDisplayMode;
+  requiresPreDispatchRebindReader?: () => boolean;
   getCurrentLeaderEpoch?: () => number | string | undefined;
   getTelegramProfile?: () => string | undefined;
   getAllowedUserId?: () => number | undefined;
@@ -3385,6 +3434,8 @@ export function createTelegramBusLeaderEnvelopeHandler(
           local: deps.protocolIdentity,
           remote: envelope.registration.protocol,
         });
+        const readerCompatible = () => deps.requiresPreDispatchRebindReader?.() !== true ||
+          hasTelegramBusCapability(envelope.registration.protocol, TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND);
         const displayCompatible = () =>
           (deps.getThreadDisplayMode?.() ?? "names") === "names" ||
           (hasTelegramBusCapability(
@@ -3409,6 +3460,7 @@ export function createTelegramBusLeaderEnvelopeHandler(
         if (
           !compatibility.compatible ||
           !displayCompatible() ||
+          !readerCompatible() ||
           (envelope.registration.cwd !== undefined &&
             envelope.registration.sessionId === undefined) ||
           (restoringWorkspace && !supportsWorkspaceAutoConnect)
@@ -3445,6 +3497,7 @@ export function createTelegramBusLeaderEnvelopeHandler(
               const telegramProfile = deps.getTelegramProfile?.();
               const operatorUserId = deps.getAllowedUserId?.();
               const registrationCurrent = (): boolean =>
+                readerCompatible() &&
                 (!deps.getCurrentLeaderEpoch ||
                   deps.getCurrentLeaderEpoch() === leaderEpoch) &&
                 (!deps.getTelegramProfile ||
@@ -4395,6 +4448,7 @@ export function createTelegramBusLeaderRuntime<TContext>(
     recordRuntimeEvent: deps.recordRuntimeEvent,
     applyThreadDisplayMode: deps.applyThreadDisplayMode,
     getThreadDisplayMode: deps.getThreadDisplayMode,
+    requiresPreDispatchRebindReader: deps.requiresPreDispatchRebindReader,
     getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
     getTelegramProfile: deps.getTelegramProfile,
     getAllowedUserId: deps.getAllowedUserId,
@@ -4489,23 +4543,43 @@ export function createTelegramBusLeaderRuntime<TContext>(
     },
     handleEnvelope,
   });
+  // The start that owns the endpoint and pruning. A stop clears it; a start that loses it mid-await undoes only what
+  // nobody newer owns, so a stop during startup never leaves a stopped leader's endpoint listening.
+  let activeStart: object | undefined;
+  const releaseSupersededStart = async (): Promise<void> => {
+    if (activeStart !== undefined) return;
+    stopPruning();
+    await localServer
+      .stop()
+      .catch((error) =>
+        deps.recordRuntimeEvent?.("bus", error, { phase: "stop" }),
+      );
+  };
   return {
     routeQueueHandoff: (envelope) => routeQueueHandoffEnvelope(envelope),
     startPolling: async (ctx) => {
+      const start = {};
+      activeStart = start;
       // Replay durable cleanup before publishing the follower endpoint so a
       // replacement registration cannot reclaim a target while it is deleted.
       await deps.provisionLeaderTarget?.(ctx);
+      if (activeStart !== start) return;
       await localServer.start();
+      if (activeStart !== start) return releaseSupersededStart();
       startPruning();
       try {
         await deps.startPolling(ctx);
       } catch (error) {
+        if (activeStart !== start) return releaseSupersededStart();
+        activeStart = undefined;
         stopPruning();
         await localServer.stop();
         throw error;
       }
+      if (activeStart !== start) return releaseSupersededStart();
     },
     stopPolling: async () => {
+      activeStart = undefined;
       stopPruning();
       try {
         await deps.stopPolling();

package/lib/bus.ts

@@ -156,6 +156,9 @@ export const TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT =
   "session-replacement-intent-v1" as const;
 export const TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE =
   "workspace-restore-v1" as const;
+/** Shared Workspace readers understand independent pre-dispatch input/cleanup state. */
+export const TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND = "live-rebind-pre-dispatch-reader-v2" as const;
+export const TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION = "live-rebind-pre-dispatch-v1" as const;
 export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE =
   "live-thread-rebind-save-v1" as const;
 export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY =
@@ -665,12 +668,6 @@ function hasTelegramBusDeliveryMarker(
   );
 }
 
-export function markTelegramBusAggregateDelivery<
-  T extends Record<string, unknown>,
->(body: T): T {
-  return { ...body, [TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD]: true };
-}
-
 export function markTelegramBusCrossTargetDelivery<
   T extends Record<string, unknown>,
 >(body: T): T {
@@ -787,7 +784,7 @@ export function isTelegramFollowerApiCallAllowed(input: {
     if (apiMethod === "setMyCommands")
       return isBotCommandRegistration(input.args[1]);
     if (apiMethod === "sendChatAction")
-      return isTargetChatScoped(input.args[1]);
+      return isTargetScoped(input.args[1]);
     if (
       apiMethod === "sendMessage" &&
       hasTelegramBusDeliveryMarker(
@@ -795,8 +792,7 @@ export function isTelegramFollowerApiCallAllowed(input: {
         TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD,
       )
     ) {
-      const body = input.args[1] as Record<string, unknown>;
-      return body.message_thread_id === undefined && isTargetChatScoped(body);
+      return false;
     }
     if (
       (apiMethod === "sendMessage" || apiMethod === "sendRichMessage") &&
@@ -1156,7 +1152,7 @@ export type TelegramBusEnvelope = (
       recipientBindingKey: string;
       operationId: string;
       sourceUpdateIds: number[];
-      mode: "release" | "discard" | "observe" | "observe-command";
+      mode: "release" | "discard" | "observe" | "observe-held" | "observe-command";
       oldTarget?: TelegramTarget & { threadId: number };
       preparedSource?: TelegramBusPreparedCommandSource;
       selectedCommand?: TelegramBusSelectedCommandInput;
@@ -1492,7 +1488,8 @@ export function parseTelegramBusEnvelope(
         ]) ||
         (Object.hasOwn(value, "preparedSource") && !selectedCommand) ||
         (value.mode === "observe-command" &&
-          (!selectedCommand || Object.hasOwn(value, "oldTarget")))
+          (!selectedCommand || Object.hasOwn(value, "oldTarget"))) ||
+        (value.mode === "observe-held" && (parseThreadTarget(value.oldTarget)?.threadId ?? 0) <= 0)
       )
         break;
       if (
@@ -1513,7 +1510,7 @@ export function parseTelegramBusEnvelope(
           : value.mode === "release" ||
             value.mode === "discard" ||
             value.mode === "observe-command" ||
-            (value.mode === "observe" &&
+            ((value.mode === "observe" || value.mode === "observe-held") &&
               !!parseThreadTarget(value.oldTarget))) &&
         isUniqueSourceUpdateIds(value.sourceUpdateIds) &&
         typeof value.sentAtMs === "number" &&
@@ -1530,9 +1527,10 @@ export function parseTelegramBusEnvelope(
             | "release"
             | "discard"
             | "observe"
+            | "observe-held"
             | "observe-command",
           sentAtMs: value.sentAtMs,
-          ...(value.mode === "observe"
+          ...((value.mode === "observe" || value.mode === "observe-held")
             ? { oldTarget: parseThreadTarget(value.oldTarget)! }
             : {}),
           ...(selectedCommand ? { selectedCommand, preparedSource } : {}),
@@ -2417,6 +2415,7 @@ export function createTelegramBusLiveRebindController(deps: {
             | "release"
             | "discard"
             | "observe"
+            | "observe-held"
             | "observe-command";
           sourceUpdateIds: number[];
           slot: string;
@@ -2460,6 +2459,7 @@ export function createTelegramBusLiveRebindController(deps: {
           "release",
           "discard",
           "observe",
+          "observe-held",
           "observe-command",
         ].includes(input.mode) ||
           (input.mode === "observe-command" && !selectedCommand)))
@@ -2505,7 +2505,8 @@ export function createTelegramBusLiveRebindController(deps: {
           }
         : { updates: input.updates }),
     });
-    const observing = "mode" in expected && expected.mode === "observe";
+    const observing = "mode" in expected && (expected.mode === "observe" || expected.mode === "observe-held");
+    const observingHeld = "mode" in expected && expected.mode === "observe-held";
     const commandObserving =
       "mode" in expected && expected.mode === "observe-command";
     const settling =
@@ -2520,6 +2521,7 @@ export function createTelegramBusLiveRebindController(deps: {
         ? [TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY]
         : []),
       ...(settling || held ? [TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE] : []),
+      ...(observingHeld ? [TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION] : []),
       ...(held
         ? [
             TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_COMMAND_SET,
@@ -2635,7 +2637,7 @@ export function createTelegramBusLiveRebindController(deps: {
             ? {
                 kind: "leader.settleLiveRebind" as const,
                 mode: expected.mode as
-                  "release" | "discard" | "observe" | "observe-command",
+                  "release" | "discard" | "observe" | "observe-held" | "observe-command",
                 sourceUpdateIds: expected.sourceUpdateIds!,
                 ...(observing ? { oldTarget: expected.oldTarget } : {}),
               }

package/lib/delivery.ts

@@ -4,7 +4,6 @@
  * Owns the public extension delivery contract, authorized scope resolution, operational rendering adapter, per-target serialization, chunk reconciliation, generation-fenced logical handles, and process-local runtime membrane; composes the established reply renderer with bus-aware Telegram API ports and excludes bot clients, Pi contexts, and consumer-extension policy
  */
 
-import { markTelegramBusAggregateDelivery } from "./bus.ts";
 import {
   assertTelegramInlineKeyboardCallbackData,
   type TelegramInlineKeyboardMarkup,
@@ -134,6 +133,7 @@ export interface TelegramDeliveryTransportOptions {
 /** @internal */
 export interface TelegramDeliveryRuntimeDeps extends TelegramDeliveryTargetResolverDeps {
   generation: string;
+  captureDrain?: () => (() => void) | undefined;
   renderView: (
     view: TelegramDeliveryView,
   ) => readonly TelegramDeliveryRenderedChunk[];
@@ -166,6 +166,7 @@ export interface TelegramDeliveryRuntimeDeps extends TelegramDeliveryTargetResol
 /** @internal */
 export interface TelegramBridgeDeliveryRuntimeDeps {
   generation: string;
+  captureDrain?: () => (() => void) | undefined;
   getTargetPolicyView: () => TelegramDeliveryTargetPolicyView;
   getActiveTurnTarget: () => TelegramDeliveryTarget | undefined;
   isTransportActive?: () => boolean;
@@ -295,6 +296,7 @@ function classifyTelegramDeliveryTransportError(error: unknown): {
 export interface TelegramDeliveryTargetPolicyView {
   canDeliver: boolean;
   ownsDirect: boolean;
+  threaded?: boolean;
   allowedChatId?: number;
   followerTarget?: TelegramDeliveryTarget;
   leaderTarget?: TelegramDeliveryTarget;
@@ -310,6 +312,7 @@ export interface TelegramDeliveryTargetPolicyRuntime {
 /** @internal */
 export function createTelegramDeliveryTargetPolicyRuntime(deps: {
   ownsDirect(): boolean;
+  isThreadedMode?(): boolean;
   isFollowerRegistered(): boolean;
   getAllowedChatId(): number | undefined;
   getFollowerTarget(): TelegramDeliveryTarget | undefined;
@@ -324,6 +327,7 @@ export function createTelegramDeliveryTargetPolicyRuntime(deps: {
       return {
         canDeliver: ownsDirect || deps.isFollowerRegistered(),
         ownsDirect,
+        threaded: deps.isThreadedMode?.() === true,
         allowedChatId: deps.getAllowedChatId(),
         followerTarget: deps.getFollowerTarget(),
         leaderTarget: deps.getLeaderTarget(),
@@ -338,25 +342,25 @@ export function createTelegramDeliveryTargetPolicyRuntime(deps: {
   };
 }
 
+function isThreadedDelivery(view: TelegramDeliveryTargetPolicyView): boolean {
+  return view.threaded === true || view.followerTarget?.threadId !== undefined || view.leaderTarget?.threadId !== undefined;
+}
+
 /** @internal */
 export function resolveTelegramDeliveryInstanceTarget(
   view: TelegramDeliveryTargetPolicyView,
 ): TelegramDeliveryTarget | undefined {
   if (!view.canDeliver) return undefined;
-  return (
-    view.followerTarget ??
-    view.leaderTarget ??
-    (view.allowedChatId === undefined
-      ? undefined
-      : { chatId: view.allowedChatId })
-  );
+  const target = view.followerTarget ?? view.leaderTarget ??
+    (view.allowedChatId === undefined ? undefined : { chatId: view.allowedChatId });
+  return target && (!isThreadedDelivery(view) || target.threadId !== undefined) ? target : undefined;
 }
 
 /** @internal */
 export function resolveTelegramDeliveryAggregateTarget(
   view: TelegramDeliveryTargetPolicyView,
 ): TelegramDeliveryTarget | undefined {
-  return !view.canDeliver || view.allowedChatId === undefined
+  return !view.canDeliver || view.allowedChatId === undefined || isThreadedDelivery(view)
     ? undefined
     : { chatId: view.allowedChatId };
 }
@@ -373,7 +377,7 @@ export function isTelegramDeliveryExplicitTargetAuthorized(
   ) {
     return false;
   }
-  if (candidate.threadId === undefined) return true;
+  if (candidate.threadId === undefined) return !isThreadedDelivery(view);
   if (view.followerTarget) {
     return areDeliveryTargetsEqual(candidate, view.followerTarget);
   }
@@ -427,13 +431,27 @@ function resolveTelegramDeliveryTarget(
   return { ok: true, value: cloneTarget(target) };
 }
 
-function createTelegramDeliveryTargetQueue() {
+/** Observation cannot turn failed delivery into success or borrow a newer queue lifetime. */
+function captureDeliveryDrainObserver(capture?: () => (() => void) | undefined): () => void {
+  try {
+    const notify = capture?.();
+    return () => {
+      try {
+        const emitted: unknown = notify?.();
+        if (emitted) void Promise.resolve(emitted).catch(() => undefined);
+      } catch { /* Observer failure is inert. */ }
+    };
+  } catch { return () => {}; }
+}
+
+function createTelegramDeliveryTargetQueue(captureDrain?: () => (() => void) | undefined) {
   const queues = new Map<string, Promise<void>>();
   async function run<T>(
     target: TelegramDeliveryTarget,
     operation: () => Promise<T>,
   ): Promise<T> {
     const key = targetKey(target);
+    const notifyDrained = captureDeliveryDrainObserver(captureDrain);
     const previous = queues.get(key) ?? Promise.resolve();
     const current = previous.then(operation, operation);
     const settled = current.then(
@@ -444,7 +462,7 @@ function createTelegramDeliveryTargetQueue() {
     try {
       return await current;
     } finally {
-      if (queues.get(key) === settled) queues.delete(key);
+      if (queues.get(key) === settled) { queues.delete(key); notifyDrained(); }
     }
   }
   return {
@@ -482,7 +500,10 @@ export function createTelegramDeliveryRuntime(
     TelegramDeliveryHandle,
     { target: TelegramDeliveryTarget; messageIds: readonly number[] }
   >();
-  const targetQueue = createTelegramDeliveryTargetQueue();
+  const targetQueue = createTelegramDeliveryTargetQueue(() => {
+    const notify = deps.captureDrain?.();
+    return () => active ? notify?.() : undefined;
+  });
   const runForTarget = targetQueue.run;
   const render = (
     view: TelegramDeliveryView,
@@ -735,9 +756,17 @@ export function createTelegramBridgeDeliveryRuntime(
       throw new TelegramDeliveryTransportGenerationError();
     }
   };
+  const assertOutputTarget = (target: TelegramDeliveryTarget): void => {
+    if (isThreadedDelivery(getPolicyView()) && target.threadId === undefined)
+      throw new Error("Telegram All is input-only in Threaded Mode.");
+  };
   return createTelegramDeliveryRuntime({
     generation: deps.generation,
-    getActiveTurnTarget: deps.getActiveTurnTarget,
+    captureDrain: deps.captureDrain,
+    getActiveTurnTarget() {
+      const target = deps.getActiveTurnTarget();
+      return target && (!isThreadedDelivery(getPolicyView()) || target.threadId !== undefined) ? target : undefined;
+    },
     getInstanceTarget() {
       return resolveTelegramDeliveryInstanceTarget(getPolicyView());
     },
@@ -763,6 +792,7 @@ export function createTelegramBridgeDeliveryRuntime(
     },
     async sendChunk(target, chunk, options) {
       assertTransportActive();
+      assertOutputTarget(target);
       const sent = await withTelegramReplyParameters(
         target.chatId,
         options.replyToMessageId,
@@ -780,11 +810,7 @@ export function createTelegramBridgeDeliveryRuntime(
               ? { reply_markup: options.replyMarkup }
               : {}),
           };
-          return deps.api.sendMessage(
-            target.threadId === undefined
-              ? markTelegramBusAggregateDelivery(body)
-              : body,
-          );
+          return deps.api.sendMessage(body);
         },
       );
       assertTransportActive();
@@ -797,6 +823,7 @@ export function createTelegramBridgeDeliveryRuntime(
     },
     async editChunk(target, messageId, chunk, options) {
       assertTransportActive();
+      assertOutputTarget(target);
       await deps.api.editMessageText({
         chat_id: target.chatId,
         message_id: messageId,
@@ -814,6 +841,7 @@ export function createTelegramBridgeDeliveryRuntime(
     },
     async sendChatAction(target, action) {
       assertTransportActive();
+      assertOutputTarget(target);
       await deps.api.sendChatAction(target.chatId, action, {
         message_thread_id: target.threadId,
       });