@llblab/pi-telegram 0.54.3 → 0.55.0

package/dist/lib/bus-leader.d.ts

@@ -63,6 +63,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, body: Record<string, unknown>) => Promise<TResponse>;
     getCurrentLeaderEpoch?: () => number | string | undefined;
@@ -276,6 +278,7 @@ export interface TelegramBusLeaderEnvelopeHandlerDeps {
     recordRuntimeEvent?: (category: string, error: unknown, details?: Record<string, unknown>) => void;
     applyThreadDisplayMode?: (mode: TelegramThreadDisplayMode, isCurrent: () => boolean) => Promise<void>;
     getThreadDisplayMode?: () => TelegramThreadDisplayMode;
+    requiresPreDispatchRebindReader?: () => boolean;
     getCurrentLeaderEpoch?: () => number | string | undefined;
     getTelegramProfile?: () => string | undefined;
     getAllowedUserId?: () => number | undefined;

package/dist/lib/bus-leader.js

@@ -6,7 +6,7 @@
  */
 import { isDeepStrictEqual } from "node:util";
 import { getTelegramBusTransportRetryPolicy } from "./bus-transport.js";
-import { createTelegramBusLocalServer, createUnauthorizedBusAck, rejectTelegramBusRequest, getTelegramBusEnvelopeTrafficClass, getTelegramBusFollowerSocketPath, getTelegramBusProtocolCompatibility, hasTelegramBusCapability, isTelegramBusEnvelopeAuthorized, parseTelegramBusEnvelope, sendTelegramBusLocalEnvelope, stripTelegramBusApiMetadata, TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT, TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION, TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF, TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY, TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT, TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE, TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT, TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE, TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME, } from "./bus.js";
+import { createTelegramBusLocalServer, createUnauthorizedBusAck, rejectTelegramBusRequest, getTelegramBusEnvelopeTrafficClass, getTelegramBusFollowerSocketPath, getTelegramBusProtocolCompatibility, hasTelegramBusCapability, isTelegramBusEnvelopeAuthorized, parseTelegramBusEnvelope, sendTelegramBusLocalEnvelope, stripTelegramBusApiMetadata, TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT, TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION, TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF, 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, } from "./bus.js";
 import { escapeHtml } from "./rendering.js";
 import * as Sync from "./sync.js";
 import { parseTelegramIntegerId as asInteger, } from "./target.js";
@@ -223,12 +223,17 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
             });
         });
     };
+    /** Returns the stabilization this startup owns; a stop or a newer startup meanwhile makes it inert. */
     const beginStartupDisplayStabilization = () => {
         cancelStartupDisplayStabilization();
         startupDisplaySettled = false;
+        return startupDisplayGeneration;
     };
-    const armStartupDisplayReconciliation = () => {
-        const generation = startupDisplayGeneration;
+    const armStartupDisplayReconciliation = (generation) => {
+        if (startupDisplayGeneration !== generation)
+            return;
+        if (startupDisplayTimer)
+            clearTimeout(startupDisplayTimer);
         const delayMs = deps.runtime.followerStaleAfterMs ?? TELEGRAM_BUS_FOLLOWER_STALE_AFTER_MS;
         startupDisplayTimer = setTimeout(() => {
             if (startupDisplayGeneration !== generation)
@@ -299,6 +304,8 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
     });
     const provisionFollowerTarget = createTelegramBusFollowerTargetProvisioner({
         ...provisionerPorts,
+        getLiveFollowers: deps.runtime.followerRegistry.list,
+        isFollowerProcessAlive: deps.runtime.isFollowerProcessAlive,
     });
     const renameLeaderThreadAdmitted = async (threadName, expectedTarget, assertRecipientAuthority) => {
         const store = deps.topicTargetStore, callApi = deps.callApi;
@@ -802,17 +809,19 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
         resetThreadNameAdmitted,
         captureWorkspaceExternalProtection: deps.captureWorkspaceExternalProtection,
         async startPolling(ctx) {
-            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();
@@ -872,9 +881,40 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
         if (typeof chatId !== "number")
             return registration.target;
         await deps.topicTargetStore.load();
+        let restoredPredecessor;
+        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, {
+            ? deps.topicTargetStore.claimWorkspaceIdentity(registration.cwd, registration.instanceId, registration.previousInstanceId ?? restoredPredecessor?.instanceId, {
                 existingBindingOnly: options?.existingWorkspaceBindingOnly === true,
                 sessionId: registration.sessionId,
                 onCapacityUnavailable() {
@@ -925,6 +965,7 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
             return (record.owner?.kind === "manual-follower" &&
                 ((matchesCurrentIdentity && matchesRequestedTarget) ||
                     matchesSessionHandoff ||
+                    (record.instanceId === restoredPredecessor?.instanceId && matchesRequestedTarget) ||
                     matchesWorkspaceRecovery));
         });
         const followerOwner = Threads.getTelegramThreadOwnerFromProfileKey(followerProfileKey);
@@ -1096,14 +1137,12 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
             const requiresVisibilityProbe = 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",
@@ -1242,6 +1281,16 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
                         updatedAtMs: getNowMs(),
                     },
                 });
+                // 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({
@@ -1712,8 +1761,7 @@ export function createTelegramBusSelectedMenuDeliveryHandler(deps) {
                 .listLiveRebindings()
                 .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) ||
@@ -1792,8 +1840,13 @@ export function createTelegramBusSelectedMenuDeliveryHandler(deps) {
                     live.target.threadId !== recipient.target.threadId ||
                     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);
                     const owners = view.threads.filter((value) => value.status === "active" &&
                         (value.slot === intent.request.binding.slot ||
@@ -2198,6 +2251,8 @@ export function createTelegramBusLeaderEnvelopeHandler(deps) {
                     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(deps.protocolIdentity, TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE) &&
                         hasTelegramBusCapability(envelope.registration.protocol, TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE));
@@ -2206,6 +2261,7 @@ export function createTelegramBusLeaderEnvelopeHandler(deps) {
                     hasTelegramBusCapability(envelope.registration.protocol, TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT);
                 if (!compatibility.compatible ||
                     !displayCompatible() ||
+                    !readerCompatible() ||
                     (envelope.registration.cwd !== undefined &&
                         envelope.registration.sessionId === undefined) ||
                     (restoringWorkspace && !supportsWorkspaceAutoConnect)) {
@@ -2236,8 +2292,9 @@ export function createTelegramBusLeaderEnvelopeHandler(deps) {
                         const leaderEpoch = deps.getCurrentLeaderEpoch?.();
                         const telegramProfile = deps.getTelegramProfile?.();
                         const operatorUserId = deps.getAllowedUserId?.();
-                        const registrationCurrent = () => (!deps.getCurrentLeaderEpoch ||
-                            deps.getCurrentLeaderEpoch() === leaderEpoch) &&
+                        const registrationCurrent = () => readerCompatible() &&
+                            (!deps.getCurrentLeaderEpoch ||
+                                deps.getCurrentLeaderEpoch() === leaderEpoch) &&
                             (!deps.getTelegramProfile ||
                                 deps.getTelegramProfile() === telegramProfile) &&
                             (!deps.getAllowedUserId ||
@@ -2955,6 +3012,7 @@ export function createTelegramBusLeaderRuntime(deps) {
         recordRuntimeEvent: deps.recordRuntimeEvent,
         applyThreadDisplayMode: deps.applyThreadDisplayMode,
         getThreadDisplayMode: deps.getThreadDisplayMode,
+        requiresPreDispatchRebindReader: deps.requiresPreDispatchRebindReader,
         getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
         getTelegramProfile: deps.getTelegramProfile,
         getAllowedUserId: deps.getAllowedUserId,
@@ -3027,24 +3085,47 @@ export function createTelegramBusLeaderRuntime(deps) {
         },
         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;
+    const releaseSupersededStart = async () => {
+        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/dist/lib/bus.d.ts

@@ -43,6 +43,9 @@ export declare const TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT: "director
 export declare const TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT: "workspace-follower-auto-connect-v1";
 export declare const TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT: "session-replacement-intent-v1";
 export declare const TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE: "workspace-restore-v1";
+/** Shared Workspace readers understand independent pre-dispatch input/cleanup state. */
+export declare const TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND: "live-rebind-pre-dispatch-reader-v2";
+export declare const TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION: "live-rebind-pre-dispatch-v1";
 export declare const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE: "live-thread-rebind-save-v1";
 export declare const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY: "live-thread-rebind-apply-v1";
 export declare const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE: "live-thread-rebind-settle-v1";
@@ -239,7 +242,6 @@ export declare function getTelegramFollowerTargetOwnership(input: {
     recipientBindingKey: string;
     protocolIdentity: TelegramBusProtocolIdentity;
 } | undefined;
-export declare function markTelegramBusAggregateDelivery<T extends Record<string, unknown>>(body: T): T;
 export declare function markTelegramBusCrossTargetDelivery<T extends Record<string, unknown>>(body: T): T;
 export declare function stripTelegramBusApiMetadata<T extends Record<string, unknown>>(body: T): T;
 export declare function isTelegramFollowerApiCallAllowed(input: {
@@ -460,7 +462,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;
     };
@@ -720,7 +722,7 @@ export declare function createTelegramBusLiveRebindController(deps: {
         update_id: number;
     } & Record<string, unknown>)[];
 } | {
-    mode: "apply" | "inspect" | "release" | "discard" | "observe" | "observe-command";
+    mode: "apply" | "inspect" | "release" | "discard" | "observe" | "observe-held" | "observe-command";
     sourceUpdateIds: number[];
     slot: string;
     target: TelegramTarget & {

package/dist/lib/bus.js

@@ -57,6 +57,9 @@ export const TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT = "directory-displ
 export const TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT = "workspace-follower-auto-connect-v1";
 export const TELEGRAM_BUS_CAPABILITY_SESSION_REPLACEMENT_INTENT = "session-replacement-intent-v1";
 export const TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE = "workspace-restore-v1";
+/** Shared Workspace readers understand independent pre-dispatch input/cleanup state. */
+export const TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND = "live-rebind-pre-dispatch-reader-v2";
+export const TELEGRAM_BUS_CAPABILITY_PRE_DISPATCH_REBIND_EXECUTION = "live-rebind-pre-dispatch-v1";
 export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SAVE = "live-thread-rebind-save-v1";
 export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY = "live-thread-rebind-apply-v1";
 export const TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_SETTLE = "live-thread-rebind-settle-v1";
@@ -270,9 +273,6 @@ function hasTelegramBusDeliveryMarker(body, marker) {
         !Array.isArray(body) &&
         body[marker] === true);
 }
-export function markTelegramBusAggregateDelivery(body) {
-    return { ...body, [TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD]: true };
-}
 export function markTelegramBusCrossTargetDelivery(body) {
     return { ...body, [TELEGRAM_BUS_CROSS_TARGET_DELIVERY_FIELD]: true };
 }
@@ -375,11 +375,10 @@ 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(input.args[1], TELEGRAM_BUS_AGGREGATE_DELIVERY_FIELD)) {
-            const body = input.args[1];
-            return body.message_thread_id === undefined && isTargetChatScoped(body);
+            return false;
         }
         if ((apiMethod === "sendMessage" || apiMethod === "sendRichMessage") &&
             hasTelegramBusDeliveryMarker(input.args[1], TELEGRAM_BUS_CROSS_TARGET_DELIVERY_FIELD)) {
@@ -643,7 +642,8 @@ export function parseTelegramBusEnvelope(line) {
             ]) ||
                 (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 (Object.hasOwn(value, "selectedCommand") &&
                 (!selectedCommand ||
@@ -660,7 +660,7 @@ export function parseTelegramBusEnvelope(line) {
                     : 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" &&
@@ -672,7 +672,7 @@ export function parseTelegramBusEnvelope(line) {
                     sourceUpdateIds: value.sourceUpdateIds,
                     mode: value.mode,
                     sentAtMs: value.sentAtMs,
-                    ...(value.mode === "observe"
+                    ...((value.mode === "observe" || value.mode === "observe-held")
                         ? { oldTarget: parseThreadTarget(value.oldTarget) }
                         : {}),
                     ...(selectedCommand ? { selectedCommand, preparedSource } : {}),
@@ -1249,6 +1249,7 @@ export function createTelegramBusLiveRebindController(deps) {
                     "release",
                     "discard",
                     "observe",
+                    "observe-held",
                     "observe-command",
                 ].includes(input.mode) ||
                     (input.mode === "observe-command" && !selectedCommand))))
@@ -1289,7 +1290,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 = "mode" in expected &&
             (expected.mode === "release" ||
@@ -1302,6 +1304,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,

package/dist/lib/delivery.d.ts

@@ -76,6 +76,7 @@ export interface TelegramDeliveryTransportOptions {
 /** @internal */
 export interface TelegramDeliveryRuntimeDeps extends TelegramDeliveryTargetResolverDeps {
     generation: string;
+    captureDrain?: () => (() => void) | undefined;
     renderView: (view: TelegramDeliveryView) => readonly TelegramDeliveryRenderedChunk[];
     sendChunk: (target: TelegramDeliveryTarget, chunk: TelegramDeliveryRenderedChunk, options: TelegramDeliveryTransportOptions) => Promise<number>;
     editChunk: (target: TelegramDeliveryTarget, messageId: number, chunk: TelegramDeliveryRenderedChunk, options: TelegramDeliveryTransportOptions) => Promise<void>;
@@ -86,6 +87,7 @@ export interface TelegramDeliveryRuntimeDeps extends TelegramDeliveryTargetResol
 /** @internal */
 export interface TelegramBridgeDeliveryRuntimeDeps {
     generation: string;
+    captureDrain?: () => (() => void) | undefined;
     getTargetPolicyView: () => TelegramDeliveryTargetPolicyView;
     getActiveTurnTarget: () => TelegramDeliveryTarget | undefined;
     isTransportActive?: () => boolean;
@@ -114,6 +116,7 @@ export declare function createTelegramBridgeDeliveryLifecycleHooks<TTransportSta
 export interface TelegramDeliveryTargetPolicyView {
     canDeliver: boolean;
     ownsDirect: boolean;
+    threaded?: boolean;
     allowedChatId?: number;
     followerTarget?: TelegramDeliveryTarget;
     leaderTarget?: TelegramDeliveryTarget;
@@ -127,6 +130,7 @@ export interface TelegramDeliveryTargetPolicyRuntime {
 /** @internal */
 export declare function createTelegramDeliveryTargetPolicyRuntime(deps: {
     ownsDirect(): boolean;
+    isThreadedMode?(): boolean;
     isFollowerRegistered(): boolean;
     getAllowedChatId(): number | undefined;
     getFollowerTarget(): TelegramDeliveryTarget | undefined;

package/dist/lib/delivery.js

@@ -3,7 +3,6 @@
  * Zones: telegram delivery, extension API, runtime binding
  * 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.js";
 import { assertTelegramInlineKeyboardCallbackData, } from "./keyboard.js";
 import { renderTelegramMessage, withTelegramReplyParameters, } from "./replies.js";
 import { areTelegramTargetsEqual as areDeliveryTargetsEqual, getTelegramTargetThreadParams, } from "./target.js";
@@ -90,6 +89,7 @@ export function createTelegramDeliveryTargetPolicyRuntime(deps) {
             return {
                 canDeliver: ownsDirect || deps.isFollowerRegistered(),
                 ownsDirect,
+                threaded: deps.isThreadedMode?.() === true,
                 allowedChatId: deps.getAllowedChatId(),
                 followerTarget: deps.getFollowerTarget(),
                 leaderTarget: deps.getLeaderTarget(),
@@ -103,19 +103,20 @@ export function createTelegramDeliveryTargetPolicyRuntime(deps) {
         },
     };
 }
+function isThreadedDelivery(view) {
+    return view.threaded === true || view.followerTarget?.threadId !== undefined || view.leaderTarget?.threadId !== undefined;
+}
 /** @internal */
 export function resolveTelegramDeliveryInstanceTarget(view) {
     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) {
-    return !view.canDeliver || view.allowedChatId === undefined
+    return !view.canDeliver || view.allowedChatId === undefined || isThreadedDelivery(view)
         ? undefined
         : { chatId: view.allowedChatId };
 }
@@ -127,7 +128,7 @@ export function isTelegramDeliveryExplicitTargetAuthorized(candidate, view) {
         return false;
     }
     if (candidate.threadId === undefined)
-        return true;
+        return !isThreadedDelivery(view);
     if (view.followerTarget) {
         return areDeliveryTargetsEqual(candidate, view.followerTarget);
     }
@@ -166,10 +167,28 @@ function resolveTelegramDeliveryTarget(scope, deps) {
     }
     return { ok: true, value: cloneTarget(target) };
 }
-function createTelegramDeliveryTargetQueue() {
+/** Observation cannot turn failed delivery into success or borrow a newer queue lifetime. */
+function captureDeliveryDrainObserver(capture) {
+    try {
+        const notify = capture?.();
+        return () => {
+            try {
+                const emitted = notify?.();
+                if (emitted)
+                    void Promise.resolve(emitted).catch(() => undefined);
+            }
+            catch { /* Observer failure is inert. */ }
+        };
+    }
+    catch {
+        return () => { };
+    }
+}
+function createTelegramDeliveryTargetQueue(captureDrain) {
     const queues = new Map();
     async function run(target, operation) {
         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(() => { }, () => { });
@@ -178,8 +197,10 @@ function createTelegramDeliveryTargetQueue() {
             return await current;
         }
         finally {
-            if (queues.get(key) === settled)
+            if (queues.get(key) === settled) {
                 queues.delete(key);
+                notifyDrained();
+            }
         }
     }
     return {
@@ -203,7 +224,10 @@ function getChunkTransportOptions(view, index, chunkCount, replyToMessageId, edi
 export function createTelegramDeliveryRuntime(deps) {
     let active = true;
     const handleBindings = new WeakMap();
-    const targetQueue = createTelegramDeliveryTargetQueue();
+    const targetQueue = createTelegramDeliveryTargetQueue(() => {
+        const notify = deps.captureDrain?.();
+        return () => active ? notify?.() : undefined;
+    });
     const runForTarget = targetQueue.run;
     const render = (view) => {
         const chunks = deps.renderView(view);
@@ -398,9 +422,17 @@ export function createTelegramBridgeDeliveryRuntime(deps) {
             throw new TelegramDeliveryTransportGenerationError();
         }
     };
+    const assertOutputTarget = (target) => {
+        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());
         },
@@ -423,6 +455,7 @@ export function createTelegramBridgeDeliveryRuntime(deps) {
         },
         async sendChunk(target, chunk, options) {
             assertTransportActive();
+            assertOutputTarget(target);
             const sent = await withTelegramReplyParameters(target.chatId, options.replyToMessageId, target, (replyParameters) => {
                 const body = {
                     chat_id: target.chatId,
@@ -436,9 +469,7 @@ export function createTelegramBridgeDeliveryRuntime(deps) {
                         ? { reply_markup: options.replyMarkup }
                         : {}),
                 };
-                return deps.api.sendMessage(target.threadId === undefined
-                    ? markTelegramBusAggregateDelivery(body)
-                    : body);
+                return deps.api.sendMessage(body);
             });
             assertTransportActive();
             deps.recordOwnership({
@@ -450,6 +481,7 @@ export function createTelegramBridgeDeliveryRuntime(deps) {
         },
         async editChunk(target, messageId, chunk, options) {
             assertTransportActive();
+            assertOutputTarget(target);
             await deps.api.editMessageText({
                 chat_id: target.chatId,
                 message_id: messageId,
@@ -466,6 +498,7 @@ export function createTelegramBridgeDeliveryRuntime(deps) {
         },
         async sendChatAction(target, action) {
             assertTransportActive();
+            assertOutputTarget(target);
             await deps.api.sendChatAction(target.chatId, action, {
                 message_thread_id: target.threadId,
             });