@llblab/pi-telegram 0.55.0 → 0.56.0

package/dist/lib/routing.d.ts

@@ -209,7 +209,7 @@ export interface TelegramInboundRouteRuntimeDeps<TMessage extends TelegramRouted
     canUsePreDispatchRebind?: (recipient?: Threads.TelegramWorkspaceRestoreRecipient) => boolean;
     /** Strict complete namespace plus exact current/historical references; only an empty result clears journal protection. */
     inspectTemporaryThreadSources?: (target: Queue.TelegramQueueTarget, requiredJournalBindingKeys: readonly string[], ownInputs?: readonly Threads.TelegramTemporaryThreadInput[]) => readonly number[] | undefined;
-    /** Quiet period after the last cancelled input before one cleanup attempt; defaults to 1000 ms. */
+    /** Quiet period after the last cancelled input before one cleanup attempt; defaults to 0 ms. */
     temporaryThreadCleanupDelayMs?: number;
     /** Live-rebind cleanup attempt pacing; the bounded window ends in `not-issued`, never a time-based deletion. */
     liveRebindCleanupSchedule?: {

package/dist/lib/routing.js

@@ -1331,13 +1331,20 @@ export function createTelegramInboundRouteRuntime(deps) {
             requestDispatchNextQueuedTelegramTurn(ctx);
         },
     });
-    const cloneTelegramMessagesForThread = (messages, threadId) => {
-        return messages.map((message) => Updates.carryTelegramUpdateExecutionFence(message, {
-            ...message,
-            message_id: 0,
-            message_thread_id: threadId,
-            reply_to_message: undefined,
-        }));
+    const cloneTelegramMessagesForThread = (messages, threadId, copies) => {
+        return messages.map((message) => {
+            const ids = Updates.collectTelegramAdmissionSourceUpdateIds([message]);
+            const copyId = copies && ids.length === 1 ? copies.get(ids[0]) : undefined;
+            if (copies && (!Number.isSafeInteger(copyId) || copyId <= 0))
+                throw new Error("Reroute destination copy identity is unavailable.");
+            const routed = {
+                ...message,
+                message_id: copyId ?? 0,
+                message_thread_id: threadId,
+                reply_to_message: undefined,
+            };
+            return Updates.carryTelegramUpdateExecutionFence(message, copies ? Turns.withTelegramTurnReplyAnchor(routed) : routed);
+        });
     };
     /** Whether a chooser is still pending in this Thread, ignoring the ones the caller itself owns. */
     const hasPendingRerouteForTarget = (target, own) => [...pendingUnboundReroutes.values()].some((pending) => pending.sourceTarget.chatId === target.chatId &&
@@ -1603,10 +1610,12 @@ export function createTelegramInboundRouteRuntime(deps) {
         return !acceptedWorkClear;
     };
     /** Best-effort, once consumed: All keeps no copy of an input whose routing tab carried it; failure is only recorded. */
-    const deleteAllTabMessages = async (chatId, messageIds) => {
+    const deleteAllTabMessages = async (chatId, messageIds, isCurrent) => {
         if (!deps.deleteMessage)
             return;
         for (const messageId of messageIds) {
+            if (isCurrent?.() === false)
+                return;
             try {
                 await deps.deleteMessage(chatId, messageId);
             }
@@ -1620,13 +1629,14 @@ export function createTelegramInboundRouteRuntime(deps) {
         }
     };
     /** One-shot per chooser: the copies are taken before deletion, so a later consuming path finds none. */
-    const deleteAllTabCopies = (pending) => deleteAllTabMessages(pending.sourceTarget.chatId, pending.allTabCopies?.splice(0) ?? []);
+    const deleteAllTabCopies = (pending, isCurrent) => deleteAllTabMessages(pending.sourceTarget.chatId, pending.allTabCopies?.splice(0) ?? [], isCurrent);
     /**
      * Restore keeps the tab as the Thread, so the input must stay visible there: the All original goes only when the tab
      * holds its forwarded copy. Without one it stays where the operator can still read it.
      */
     const releaseAllTabCopiesIntoSurvivingTab = (pending) => {
-        if (pending.allTabCopiesForwarded)
+        if (pending.allTabCopiesForwarded &&
+            isDeepStrictEqual(pending.allTabCopiesForwarded.target, pending.sourceTarget))
             return deleteAllTabCopies(pending);
         pending.allTabCopies?.splice(0);
         return Promise.resolve();
@@ -1640,39 +1650,109 @@ export function createTelegramInboundRouteRuntime(deps) {
         const messageIds = [...(pending.allTabCopies ?? [])].sort((a, b) => a - b);
         if (messageIds.length === 0 || !deps.callApi || !isCurrent())
             return;
+        const copyTarget = { ...target };
         const route = {
-            chat_id: target.chatId,
-            message_thread_id: target.threadId,
+            chat_id: copyTarget.chatId,
+            message_thread_id: copyTarget.threadId,
             from_chat_id: pending.sourceTarget.chatId,
             disable_notification: true,
         };
+        const options = {
+            maxAttempts: 1,
+            retrySafety: "non-idempotent",
+            assertAuthority() {
+                if (!isCurrent())
+                    throw new Error("Temporary Thread source forwarding authority changed.");
+            },
+        };
         try {
             // An album moves as one album; forwardMessages skips what it cannot forward, so a short reply is not a move.
             const copies = messageIds.length === 1
                 ? [
-                    await deps.callApi("forwardMessage", {
-                        ...route,
-                        message_id: messageIds[0],
-                    }),
+                    await deps.callApi("forwardMessage", { ...route, message_id: messageIds[0] }, options),
                 ]
-                : await deps.callApi("forwardMessages", { ...route, message_ids: messageIds });
+                : await deps.callApi("forwardMessages", { ...route, message_ids: messageIds }, options);
+            if (!isCurrent())
+                return;
             const copyIds = Array.isArray(copies)
                 ? copies.map((copy) => copy?.message_id)
                 : [];
             if (copyIds.length !== messageIds.length ||
-                !copyIds.every((id) => typeof id === "number" && Number.isSafeInteger(id)))
+                !copyIds.every((id) => typeof id === "number" && Number.isSafeInteger(id) && id > 0) ||
+                new Set(copyIds).size !== copyIds.length)
                 return;
-            pending.allTabCopiesForwarded = true;
-            await deleteAllTabCopies(pending);
-            return copyIds[0];
+            pending.allTabCopiesForwarded = {
+                target: copyTarget,
+                sourceMessageIds: messageIds,
+                messageIds: copyIds,
+            };
+            await deleteAllTabCopies(pending, isCurrent);
+            if (!isCurrent())
+                return;
+            return pending.allTabCopiesForwarded.messageIds[0];
         }
         catch (error) {
-            deps.recordRuntimeEvent?.("routing", error, {
-                phase: "temporary-thread-source-forward",
-            });
+            if (isCurrent())
+                deps.recordRuntimeEvent?.("routing", error, {
+                    phase: "temporary-thread-source-forward",
+                });
             return;
         }
     };
+    /** Read original source addresses, not warm target rewrites; unknown copy provenance never grants a Reroute. */
+    const resolvePendingRerouteForwardSource = (pending) => {
+        try {
+            const originals = pending.messages.map((message) => {
+                const snapshot = Updates.inspectTelegramDeferredSourceSnapshot(message);
+                const ids = Updates.collectTelegramAdmissionSourceUpdateIds([message]);
+                const original = snapshot?.update.message;
+                if (!snapshot ||
+                    ids.length !== 1 ||
+                    snapshot.source.updateId !== ids[0] ||
+                    snapshot.update.update_id !== ids[0] ||
+                    Object.keys(snapshot.update).some((key) => key !== "update_id" && key !== "message") ||
+                    snapshot.source.journalBindingKey !== deps.getAdmissionJournalBinding?.() ||
+                    !original ||
+                    original.chat?.type !== "private" ||
+                    original.chat.id !== pending.sourceTarget.chatId ||
+                    original.from?.id !== deps.configStore.getAllowedUserId() ||
+                    original.from?.is_bot !== false ||
+                    !Number.isSafeInteger(original.message_id) ||
+                    original.message_id <= 0)
+                    return undefined;
+                return { message: original, updateId: ids[0] };
+            });
+            if (originals.length === 0 || originals.some((source) => !source))
+                return;
+            originals.sort((a, b) => a.message.message_id - b.message.message_id);
+            const sourceMessageIds = originals.map((source) => source.message.message_id);
+            const sourceUpdateIds = originals.map((source) => source.updateId);
+            if (new Set(sourceMessageIds).size !== sourceMessageIds.length ||
+                new Set(sourceUpdateIds).size !== sourceUpdateIds.length)
+                return;
+            const copied = pending.allTabCopiesForwarded;
+            if (copied) {
+                if (!isDeepStrictEqual(copied.target, pending.sourceTarget) ||
+                    !isDeepStrictEqual(copied.sourceMessageIds, sourceMessageIds) ||
+                    copied.messageIds.length !== sourceMessageIds.length ||
+                    !copied.messageIds.every((id) => Number.isSafeInteger(id) && id > 0) ||
+                    new Set(copied.messageIds).size !== copied.messageIds.length)
+                    return;
+                return { chatId: copied.target.chatId, sourceUpdateIds, sourceMessageIds, messageIds: [...copied.messageIds] };
+            }
+            const nativeOriginals = originals.every((source) => typeof pending.sourceTarget.threadId === "number" &&
+                source.message.message_thread_id === pending.sourceTarget.threadId);
+            const retainedAllOriginals = pending.allTabSourceRetained === true &&
+                originals.every((source) => source.message.message_thread_id === undefined) &&
+                isDeepStrictEqual([...(pending.allTabCopies ?? [])].sort((a, b) => a - b), sourceMessageIds);
+            if (nativeOriginals || retainedAllOriginals)
+                return { chatId: pending.sourceTarget.chatId, sourceUpdateIds, sourceMessageIds, messageIds: [...sourceMessageIds] };
+        }
+        catch (error) {
+            deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-source-proof" });
+        }
+        return undefined;
+    };
     const dismissRerouteChooserMessage = async (query, assertExecutionCurrent) => {
         const chatId = query.message?.chat?.id;
         const messageId = query.message?.message_id;
@@ -4076,7 +4156,24 @@ export function createTelegramInboundRouteRuntime(deps) {
             wake(reason);
     };
     const onSessionSettled = (ctx) => wakeLiveRebindCleanup(ctx, "session-settled");
-    const onDeliverySettled = (ctx) => wakeLiveRebindCleanup(ctx, "delivery-drained");
+    const onDeliverySettled = (ctx) => {
+        wakeLiveRebindCleanup(ctx, "delivery-drained");
+        const cap = captureTemporaryThreadAuthority(ctx);
+        if (!cap?.isCurrent())
+            return;
+        try {
+            for (const entry of cap.store.listTemporaryThreads()) {
+                if (!cap.isCurrent())
+                    return;
+                if (entry.phase === "created" && entry.target && !entry.cleanupIssued &&
+                    Threads.isTelegramTemporaryThreadFullyResolved(entry))
+                    scheduleTemporaryThreadCleanup(entry.target, ctx);
+            }
+        }
+        catch (error) {
+            deps.recordRuntimeEvent?.("routing", error, { phase: "temporary-thread-cleanup-drain" });
+        }
+    };
     const restoreWorkspace = deps.workspaceRestoreRecipient
         ? async (input) => {
             const ports = deps.workspaceRestoreRecipient;
@@ -4532,6 +4629,92 @@ export function createTelegramInboundRouteRuntime(deps) {
             return false;
         }
     };
+    /** Publish display copies under the native one-shot grant; positive output is not input/source settlement. */
+    const publishPendingRerouteCopies = async (pending, record, ctx, assertExecutionCurrent, foreign) => {
+        const source = resolvePendingRerouteForwardSource(pending);
+        const target = { ...record.target };
+        const recordIdentity = (value) => value && ({
+            target: value.target, profileKey: value.profileKey, owner: value.owner,
+            instanceId: value.instanceId, slot: value.slot, createdAtMs: value.createdAtMs,
+        });
+        const bindingIdentity = () => deps.threadStore.listWorkspaceBindings()
+            .filter((value) => isDeepStrictEqual(value.target, target))
+            .map((value) => ({ bindingKey: value.bindingKey, sessionId: value.sessionId, sessionKey: value.sessionKey,
+            cwd: value.cwd, workspaceKey: value.workspaceKey, instanceSlot: value.instanceSlot, slot: value.slot,
+            target: value.target }));
+        const expectedRecord = structuredClone(recordIdentity(record));
+        const expectedBindings = structuredClone(bindingIdentity());
+        const ownership = deps.getTargetOwnership?.(target);
+        if (!source || !deps.callApi || expectedBindings.length > 1 ||
+            (foreign && (!ownership || ownership.instanceId !== record.instanceId ||
+                !ownership.ownerGeneration || !ownership.recipientBindingKey)))
+            return;
+        const expectedOwnership = ownership && structuredClone(ownership);
+        const cap = captureTemporaryThreadAuthority(ctx, () => {
+            try {
+                assertExecutionCurrent();
+                const current = getTelegramRoutableThreadRecords(deps.threadStore.list(), deps.getLiveThreadTargets?.())
+                    .find((value) => isDeepStrictEqual(value.target, target));
+                return isDeepStrictEqual(recordIdentity(current), expectedRecord) &&
+                    isDeepStrictEqual(bindingIdentity(), expectedBindings) &&
+                    (!foreign || Bus.isTelegramBusForwardOwnershipCurrent(expectedOwnership, deps.getTargetOwnership?.(target)));
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!cap?.isCurrent())
+            return;
+        const temporary = pending.temporaryThread ?? findCreatedTemporaryThread(pending.sourceTarget);
+        if (!temporary || !issueTemporaryThreadForward(pending, ctx))
+            return;
+        pending.phase = { kind: "forward-unknown" };
+        const assertRecipientCurrent = () => {
+            assertExecutionCurrent();
+            if (!cap.isCurrent())
+                throw new Error("Reroute publication recipient authority changed.");
+        };
+        const assertPublicationCurrent = () => {
+            assertRecipientCurrent();
+            const entry = cap.store.listTemporaryThreads().find((value) => value.token === temporary.token);
+            const ids = [...source.sourceUpdateIds].sort((a, b) => a - b);
+            if (!entry || entry.phase !== "created" || entry.cleanupIssued ||
+                entry.operatorUserId !== cap.operatorUserId ||
+                !isDeepStrictEqual(entry.executor, cap.authority.executor) ||
+                !isDeepStrictEqual(entry.target, pending.sourceTarget) ||
+                !entry.forwardedInputs?.some((input) => input.journalBindingKey === cap.journalBindingKey &&
+                    isDeepStrictEqual(input.updateIds, ids)) ||
+                !isDeepStrictEqual(resolvePendingRerouteForwardSource(pending), source))
+                throw new Error("Reroute publication source authority changed.");
+        };
+        try {
+            assertPublicationCurrent();
+            // Bot API requires ascending source IDs. Preserve the source-UID association even if copy IDs reorder them.
+            const order = source.messageIds.map((_, index) => index)
+                .sort((a, b) => source.messageIds[a] - source.messageIds[b]);
+            const messageIds = order.map((index) => source.messageIds[index]);
+            const body = { chat_id: target.chatId, message_thread_id: target.threadId,
+                from_chat_id: source.chatId, disable_notification: true };
+            const options = { maxAttempts: 1, retrySafety: "non-idempotent", assertAuthority: assertPublicationCurrent };
+            const copies = messageIds.length === 1
+                ? [await deps.callApi("forwardMessage", { ...body, message_id: messageIds[0] }, options)]
+                : await deps.callApi("forwardMessages", { ...body, message_ids: messageIds }, options);
+            assertPublicationCurrent();
+            const copyIds = Array.isArray(copies) ? copies.map((copy) => copy?.message_id) : [];
+            if (copyIds.length !== messageIds.length ||
+                !copyIds.every((id) => typeof id === "number" && Number.isSafeInteger(id) && id > 0) ||
+                new Set(copyIds).size !== copyIds.length)
+                return;
+            pending.rerouteCopies = { target, bySourceUpdateId: new Map(order.map((index, position) => [source.sourceUpdateIds[index], copyIds[position]])) };
+            pending.phase = { kind: "selected" };
+            return assertRecipientCurrent;
+        }
+        catch (error) {
+            if (cap.isCurrent())
+                deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-destination-forward" });
+            return;
+        }
+    };
     const forwardPendingRerouteMessages = async (pending, instanceId, threadId, ctx, assertExecutionCurrent, recordForwardAcceptance) => {
         assertExecutionCurrent?.();
         const forwardMessage = deps.foreignOwnedUpdateForwarder?.forwardMessage;
@@ -4545,11 +4728,14 @@ export function createTelegramInboundRouteRuntime(deps) {
             !liveOwnership.recipientBindingKey)
             return false;
         const ownership = structuredClone(liveOwnership);
-        const messages = cloneTelegramMessagesForThread(pending.messages, threadId);
+        const copies = pending.rerouteCopies;
+        const published = !!copies && isDeepStrictEqual(copies.target, target);
+        const messages = cloneTelegramMessagesForThread(pending.messages, threadId, published ? copies.bySourceUpdateId : undefined);
         // Issuance is durable before the RPC: an unacknowledged temporary-tab Forward never becomes another dispatch grant,
         // even after restart. Any refusal or publication failure sends nothing and keeps the input held.
         if (!recordForwardAcceptance &&
             isTemporaryReroute(pending) &&
+            !published &&
             !issueTemporaryThreadForward(pending, ctx)) {
             if (isTemporaryThreadForwardIssued(pending))
                 pending.phase = { kind: "forward-unknown" };
@@ -4561,6 +4747,10 @@ export function createTelegramInboundRouteRuntime(deps) {
             message,
             ownership,
             ctx,
+            assertAuthority() {
+                assertExecutionCurrent?.();
+                Updates.assertTelegramUpdateExecutionCurrent(message);
+            },
         })));
         assertExecutionCurrent?.();
         if (!isDeepStrictEqual(deps.getTargetOwnership?.(target), ownership))
@@ -4719,6 +4909,17 @@ export function createTelegramInboundRouteRuntime(deps) {
             if (retry)
                 restoreSettlementTasks.add(task);
             runTemporaryThreadCleanup(token, cap, reconcileExpiry)
+                .then(() => {
+                if (!cap.isCurrent())
+                    return;
+                const retained = cap.store.listTemporaryThreads().find(value => value.token === token);
+                // A follower ACK can precede recipient receipt disposal. Reobserve a protected, unissued tab;
+                // elapsed time never grants deletion, and an issued/unknown delete can never enter this path.
+                if (retained?.phase === "created" && !retained.cleanupIssued &&
+                    Threads.isTelegramTemporaryThreadFullyResolved(retained) &&
+                    cap.store.inspectTemporaryThreadTarget(retained, cap.authority)?.kind === "temporary" && cap.isCurrent())
+                    queueTemporaryThreadCleanup(token, cap, 1000, reconcileExpiry, true);
+            })
                 .catch((error) => {
                 deps.recordRuntimeEvent?.("routing", error, {
                     phase: "temporary-thread-cleanup",
@@ -5244,7 +5445,7 @@ export function createTelegramInboundRouteRuntime(deps) {
             for (const [id, pending] of pendingUnboundReroutes) {
                 if (!Updates.collectTelegramAdmissionSourceUpdateIds(pending.messages).includes(source.original.updateId))
                     continue;
-                movedIntoTab ||= pending.allTabCopiesForwarded === true;
+                movedIntoTab ||= pending.allTabCopiesForwarded !== undefined;
                 removePendingReroute(id);
                 if (signal.aborted ||
                     deps.isContextActive?.(ctx) !== true ||
@@ -6047,6 +6248,12 @@ export function createTelegramInboundRouteRuntime(deps) {
                                                     : "Input queued in the rebound Thread; old-Thread cleanup is scheduled, not confirmed", assertExecutionCurrent, true);
             return true;
         }
+        if (!parsed.useNewSlot &&
+            isTemporaryReroute(pending) &&
+            !resolvePendingRerouteForwardSource(pending)) {
+            await deps.answerCallbackQuery(query.id, "Source copy unavailable; not routing");
+            return true;
+        }
         if (!(await selectPendingDestination()))
             return true;
         if (parsed.useNewSlot && sourceTarget && restoreWorkspace) {
@@ -6130,10 +6337,22 @@ export function createTelegramInboundRouteRuntime(deps) {
             await deps.answerCallbackQuery(query.id, delivered ? "Restored" : "Restore unconfirmed; not resending");
             return true;
         }
+        let assertRerouteCurrent = assertExecutionCurrent;
+        if (isTemporaryReroute(pending)) {
+            const confirmed = await publishPendingRerouteCopies(pending, record, ctx, assertExecutionCurrent, !!record.instanceId && record.instanceId !== currentInstanceId && !isCurrentLeaderRecord);
+            if (!confirmed) {
+                await deps.answerCallbackQuery(query.id, pending.phase.kind === "forward-unknown"
+                    ? "Publication unconfirmed; not resending"
+                    : "Publication unavailable; input kept");
+                return true;
+            }
+            assertRerouteCurrent = confirmed;
+        }
+        assertRerouteCurrent();
         if (record.instanceId &&
             record.instanceId !== currentInstanceId &&
             !isCurrentLeaderRecord) {
-            const allForwarded = await forwardPendingRerouteMessages(pending, record.instanceId, parsed.threadId, ctx, assertExecutionCurrent);
+            const allForwarded = await forwardPendingRerouteMessages(pending, record.instanceId, parsed.threadId, ctx, assertRerouteCurrent);
             if (!allForwarded) {
                 await deps.answerCallbackQuery(query.id, pending.phase.kind === "forward-unknown"
                     ? "Delivery unconfirmed; not resending"
@@ -6144,11 +6363,16 @@ export function createTelegramInboundRouteRuntime(deps) {
         }
         // Local handlers and queue admission consume the same one-time group grant as follower forwarding.
         if (isTemporaryReroute(pending) &&
+            !pending.rerouteCopies &&
             !issueTemporaryThreadForward(pending, ctx)) {
             await deps.answerCallbackQuery(query.id, "Delivery unconfirmed; not resending");
             return true;
         }
-        await dispatchPendingRerouteMessages(pending, reroutedMessages, ctx);
+        const localMessages = pending.rerouteCopies
+            ? cloneTelegramMessagesForThread(pending.messages, parsed.threadId, pending.rerouteCopies.bySourceUpdateId)
+            : reroutedMessages;
+        await dispatchPendingRerouteMessages(pending, localMessages, ctx);
+        assertRerouteCurrent();
         pending.messages = [];
         return completeRoutedReroute();
     };
@@ -7325,6 +7549,14 @@ export function createTelegramInboundRouteRuntime(deps) {
         const tabCopyId = openedNow
             ? await moveAllTabSourceIntoTab(pending, target, current)
             : undefined;
+        if (!current()) {
+            removePendingReroute(rerouteId);
+            throw new Error("Temporary Thread source presentation authority changed.");
+        }
+        if (openedNow &&
+            !pending.allTabCopiesForwarded &&
+            pending.allTabCopies.length === held.length)
+            pending.allTabSourceRetained = true;
         try {
             if (!deps.sendInteractiveMessage)
                 throw new Error("Temporary Thread chooser publication is unavailable.");

package/dist/lib/status.d.ts

@@ -6,7 +6,7 @@
  */
 /** UI copy is allowlisted; raw exception text belongs only in redacted diagnostics. */
 export declare function formatTelegramConnectionFailure(error: unknown): string;
-export type TelegramStatusQueueLane = "control" | "priority" | "default";
+export type TelegramStatusQueueLane = "control" | "steer" | "priority" | "default";
 export interface TelegramUsageStats {
     totalInput: number;
     totalOutput: number;
@@ -345,7 +345,6 @@ export interface TelegramBridgeStatusRuntimeDeps<TQueueItem extends {
     hasPendingModelSwitch: () => boolean;
     getQueuedItems: () => TQueueItem[];
     getQueuedItemCount?: (items: TQueueItem[]) => number;
-    formatQueuedStatus: (items: TQueueItem[]) => string;
     getRecentRuntimeEvents: () => TelegramRuntimeEvent[];
     getRuntimeLockState?: () => string;
     getBusRole?: () => TelegramBridgeBusRole | undefined;

package/dist/lib/status.js

@@ -605,9 +605,7 @@ function getTelegramStatusBarLabel(state) {
 }
 export function buildTelegramStatusBarText(theme, state) {
     const label = theme.fg("accent", getTelegramStatusBarLabel(state));
-    const queued = state.queuedStatus
-        ? theme.fg("warning", state.queuedStatus)
-        : "";
+    const queued = state.queuedStatus ? theme.fg("warning", state.queuedStatus) : "";
     if (!state.hasBotToken)
         return `${label} ${theme.fg("muted", "not configured")}${queued}`;
     if (state.pollingStopReason === "persistent-conflict" &&
@@ -949,6 +947,7 @@ function buildTelegramInboundWorkerDiagnosticLines(worker) {
 function countTelegramQueueLanes(items) {
     const counts = {
         control: 0,
+        steer: 0,
         priority: 0,
         default: 0,
     };
@@ -957,9 +956,9 @@ function countTelegramQueueLanes(items) {
     return counts;
 }
 function buildTelegramBridgeCompactStatusLines(state) {
-    const { control: controlQueueCount, priority: priorityQueueCount, default: defaultQueueCount, } = countTelegramQueueLanes(state.queuedItems);
+    const { control: controlQueueCount, priority: priorityQueueCount, default: defaultQueueCount, steer: steerQueueCount, } = countTelegramQueueLanes(state.queuedItems);
     const queueLine = `- queued turns: ${state.queuedItems.length}${state.queuedItems.length > 0
-        ? ` (control=${controlQueueCount}, priority=${priorityQueueCount}, default=${defaultQueueCount})`
+        ? ` (control=${controlQueueCount}${steerQueueCount > 0 ? `, steer=${steerQueueCount}` : ""}, priority=${priorityQueueCount}, default=${defaultQueueCount})`
         : ""}`;
     const executionState = state.pendingDispatch
         ? "pending dispatch"
@@ -1017,7 +1016,7 @@ export function buildTelegramBridgeStatusLines(state, options = {}) {
     return buildTelegramBridgeCompactStatusLines(state);
 }
 function buildTelegramBridgeDiagnosticStatusLines(state) {
-    const { control: controlQueueCount, priority: priorityQueueCount, default: defaultQueueCount, } = countTelegramQueueLanes(state.queuedItems);
+    const { control: controlQueueCount, priority: priorityQueueCount, default: defaultQueueCount, steer: steerQueueCount, } = countTelegramQueueLanes(state.queuedItems);
     return [
         "connection:",
         `- bot: ${formatTelegramBridgeBotStatus(state)}`,
@@ -1063,7 +1062,7 @@ function buildTelegramBridgeDiagnosticStatusLines(state) {
         "",
         "queue:",
         `- queued turns: ${state.queuedItems.length}`,
-        `- lanes: control=${controlQueueCount}, priority=${priorityQueueCount}, default=${defaultQueueCount}`,
+        `- lanes: control=${controlQueueCount}${steerQueueCount > 0 ? `, steer=${steerQueueCount}` : ""}, priority=${priorityQueueCount}, default=${defaultQueueCount}`,
         ...buildTelegramBusFollowerLines(state),
         ...buildTelegramLocalBusLines(state, { verbose: true }),
         ...buildTelegramTopicTargetDiagnosticLines(state),

package/dist/lib/turns.d.ts

@@ -9,6 +9,10 @@ import { type TelegramVoiceReplyMode } from "./voice.ts";
 export declare const TELEGRAM_PREFIX = "[telegram]";
 /** A routed source keeps its unique message/file/group identity, but cannot quote an anchor in its former tab. */
 export declare function withoutTelegramTurnReplyAnchor<TMessage extends object>(message: TMessage): TMessage;
+/** A confirmed same-target copy may replace the former-tab suppression on a warm input projection. */
+export declare function withTelegramTurnReplyAnchor<TMessage extends {
+    message_id: number;
+}>(message: TMessage): TMessage;
 export declare const TELEGRAM_GUEST_TURN_NOTE = "[guest] delivery: answer quickly with one concise, self-contained reply";
 export interface TelegramTurnTarget {
     chatId: number;

package/dist/lib/turns.js

@@ -14,6 +14,12 @@ const REPLY_ANCHOR_SUPPRESSED = Symbol.for("@llblab/pi-telegram:reply-anchor-sup
 export function withoutTelegramTurnReplyAnchor(message) {
     return { ...message, [REPLY_ANCHOR_SUPPRESSED]: true };
 }
+/** A confirmed same-target copy may replace the former-tab suppression on a warm input projection. */
+export function withTelegramTurnReplyAnchor(message) {
+    if (!Number.isSafeInteger(message.message_id) || message.message_id <= 0)
+        throw new Error("Telegram reply anchor requires a positive message ID.");
+    return { ...message, [REPLY_ANCHOR_SUPPRESSED]: false };
+}
 export const TELEGRAM_GUEST_TURN_NOTE = "[guest] delivery: answer quickly with one concise, self-contained reply";
 function getTelegramTurnTarget(message) {
     return Number.isInteger(message.message_thread_id)

package/dist/lib/updates.d.ts

@@ -22,10 +22,6 @@ export declare const TELEGRAM_PRIORITY_REACTIONS: readonly [{
     readonly id: 10;
     readonly name: "like";
     readonly emoji: "👍";
-}, {
-    readonly id: 11;
-    readonly name: "lightning";
-    readonly emoji: "⚡";
 }, {
     readonly id: 12;
     readonly name: "heart";
@@ -34,7 +30,8 @@ export declare const TELEGRAM_PRIORITY_REACTIONS: readonly [{
     readonly id: 13;
     readonly name: "dove";
     readonly emoji: "🕊";
-}, {
+}];
+export declare const TELEGRAM_STEER_REACTIONS: readonly [{
     readonly id: 14;
     readonly name: "fire";
     readonly emoji: "🔥";
@@ -60,7 +57,7 @@ export declare const TELEGRAM_REMOVAL_REACTIONS: readonly [{
     readonly name: "wastebasket";
     readonly emoji: "🗑";
 }];
-export declare const TELEGRAM_PRIORITY_REACTION_EMOJIS: ("👍" | "⚡" | "❤" | "🕊" | "🔥")[];
+export declare const TELEGRAM_PRIORITY_REACTION_EMOJIS: ("👍" | "❤" | "🕊")[];
 export declare const TELEGRAM_REMOVAL_REACTION_EMOJIS: ("👎" | "👻" | "💔" | "💩" | "🗑")[];
 export interface TelegramUpdateDeletion {
     deleted_business_messages?: {
@@ -141,6 +138,8 @@ export interface TelegramForeignOwnedUpdateForwarder<TContext, TReactionUpdate e
         message: TMessage;
         ownership: TelegramTargetOwnershipView;
         ctx: TContext;
+        /** Local issuance/ACK fence; implementations must not serialize it into payloads. */
+        assertAuthority?: () => void;
     }) => Promise<TelegramBusForeignUpdateSettlement> | TelegramBusForeignUpdateSettlement;
     forwardEditedMessage?: (input: {
         message: TMessage;
@@ -1317,6 +1316,7 @@ export interface TelegramQueueHandoffControlExecutionDeps<TContext> {
 export declare function createTelegramQueueHandoffControlExecutionFactory<TContext>(deps: TelegramQueueHandoffControlExecutionDeps<TContext>): (payload: TelegramControlQueueHandoffPayload) => PendingTelegramControlItem<TContext>["execute"];
 export interface TelegramQueueHandoffCoordinatorInput<TContext> {
     item: TelegramQueueItem<TContext>;
+    steerSupported?: boolean;
     expectedOwner: TelegramUpdateJournalQueueOwner;
     recipientOwner: TelegramUpdateJournalQueueOwnerIdentity;
     handoffToken: string;
@@ -1356,6 +1356,8 @@ export declare function createTelegramQueueHandoffRecipientRuntime<TContext>(dep
     kind: "leader.offerQueueHandoff";
 }>, ctx: TContext) => Promise<TelegramQueueHandoffStageResult>;
 export interface TelegramQueueHandoffReconcilerDeps<TContext> {
+    canHandoffSteerWithRecipient?: (recipient: TelegramBusFollowerView) => boolean;
+    hasPendingDispatch?: () => boolean;
     ownsDirect: () => boolean;
     isFollowerRegistered: () => boolean;
     isBusEnabled: () => boolean;
@@ -1380,6 +1382,8 @@ export interface TelegramQueueHandoffReconcilerDeps<TContext> {
     recordFailure?: (error: unknown, details: Record<string, unknown>) => void;
 }
 export interface TelegramQueueHandoffReconciliationRuntimeAssemblyDeps<TContext> {
+    canHandoffSteerWithRecipient?: (recipient: TelegramBusFollowerView) => boolean;
+    hasPendingDispatch?: () => boolean;
     ownsDirect: () => boolean;
     isFollowerRegistered: () => boolean;
     isBusEnabled: () => boolean;