@llblab/pi-kit 0.33.0 → 0.34.0

package/node_modules/@llblab/pi-telegram/dist/lib/routing.js

@@ -584,6 +584,20 @@ export function createTelegramLiveRebindCoordinator(input) {
                 }
                 : undefined;
         },
+        /** Observe only an already-issued leader command; never prepares, relocates or executes input. */
+        observeCommandCompletion() {
+            if (!continuationIssued || !leader?.complete)
+                return undefined;
+            if (!current())
+                return "unknown";
+            try {
+                return observeCommandCompletion();
+            }
+            catch (error) {
+                input.recordRuntimeEvent?.("telegram", error, { phase: "live-rebind-command-observation" });
+                return "unknown";
+            }
+        },
         async advance() {
             if (advancing || !current())
                 return "protected";
@@ -1331,13 +1345,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 +1624,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 +1643,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 +1664,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;
@@ -3020,7 +3114,7 @@ export function createTelegramInboundRouteRuntime(deps) {
                 Bus.isSameTelegramBusFollowerRegistration(live, follower) &&
                 [
                     ...Bus.TELEGRAM_BUS_LIVE_REBIND_CAPABILITIES,
-                    ...(heldSelected ? Bus.TELEGRAM_BUS_HELD_COMMAND_CAPABILITIES : []),
+                    ...(heldSelected ? Bus.getTelegramBusHeldCommandCapabilities(heldSelected.name) : []),
                 ].every((cap) => Bus.hasTelegramBusCapability(live.protocol, cap)) &&
                 !!live.target &&
                 live.target.chatId === binding.target.chatId &&
@@ -3573,6 +3667,7 @@ export function createTelegramInboundRouteRuntime(deps) {
         return {
             operationId: request.operationId,
             selectedCommandReference: () => coordinator?.selectedCommandReference(),
+            observeCommandCompletion: () => coordinator?.observeCommandCompletion(),
             async advance() {
                 if (!coordinator) {
                     if (!current() || !getRecipient())
@@ -4076,7 +4171,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 +4644,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 +4743,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 +4762,10 @@ export function createTelegramInboundRouteRuntime(deps) {
             message,
             ownership,
             ctx,
+            assertAuthority() {
+                assertExecutionCurrent?.();
+                Updates.assertTelegramUpdateExecutionCurrent(message);
+            },
         })));
         assertExecutionCurrent?.();
         if (!isDeepStrictEqual(deps.getTargetOwnership?.(target), ownership))
@@ -4719,6 +4924,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 +5460,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 ||
@@ -5983,6 +6199,52 @@ export function createTelegramInboundRouteRuntime(deps) {
                 const operationId = selection.coordinator.operationId;
                 if (current())
                     outcome = await selection.coordinator.advance();
+                const completionTimeoutMs = deps.liveRebindCommandCompletionTimeoutMs ?? 0;
+                if (outcome === "unknown" && !selection.commandCompletionWaited && selection.record.owner?.kind === "leader" &&
+                    (selection.helpCommand || selection.menuCommand || selection.abortCommand || selection.nextCommand || selection.stopCommand) &&
+                    Number.isFinite(completionTimeoutMs) && completionTimeoutMs > 0 &&
+                    selection.coordinator.observeCommandCompletion() !== undefined) {
+                    selection.commandCompletionWaited = true;
+                    const coordinator = selection.coordinator;
+                    const signal = Updates.getTelegramUpdateExecutionFence(query)?.signal;
+                    outcome = await new Promise((resolve) => {
+                        let settled = false;
+                        const subscriptions = [];
+                        const finish = (result) => {
+                            if (settled)
+                                return;
+                            settled = true;
+                            clearTimeout(timer);
+                            for (const unsubscribe of subscriptions)
+                                unsubscribe();
+                            signal?.removeEventListener("abort", abort);
+                            resolve(result);
+                        };
+                        const abort = () => finish("unknown");
+                        const observe = () => {
+                            if (settled)
+                                return;
+                            if (!current()) {
+                                finish("unknown");
+                                return;
+                            }
+                            if (coordinator.observeCommandCompletion() === "released")
+                                finish("released");
+                        };
+                        const timer = setTimeout(abort, completionTimeoutMs);
+                        timer.unref?.();
+                        for (const message of selection.messages) {
+                            const unsubscribe = Updates.subscribeTelegramDeferredSourceCompletion(message, observe);
+                            if (unsubscribe)
+                                subscriptions.push(unsubscribe);
+                        }
+                        signal?.addEventListener("abort", abort, { once: true });
+                        if (signal?.aborted || !current())
+                            abort();
+                        else if (coordinator.observeCommandCompletion() === "released")
+                            finish("released");
+                    });
+                }
                 // Cleanup readiness follows the canonical released row, not source disposal: a detached command ACK may
                 // still be pending while every attempt samples current work afresh.
                 const row = outcome === "protected"
@@ -6047,6 +6309,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 +6398,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 +6424,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 +7610,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/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/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/node_modules/@llblab/pi-telegram/dist/lib/sync.js

@@ -6,7 +6,7 @@
 import { getTelegramTargetKey } from "./target.js";
 import { getTelegramApiErrorRequestTarget, isTelegramStaleTargetHttpError, } from "./telegram-api.js";
 import * as ThreadReconciler from "./thread-reconciler.js";
-import { commitTelegramWorkspaceProvisionBinding, createTelegramCleanupTargetProtection, getTelegramTargetFromApiBody, getTelegramThreadOwnerKey, isSameTelegramProcessInstance, isTelegramTopicTargetStaleError, provisionOwnBusTopic, } from "./threads.js";
+import { commitTelegramWorkspaceProvisionBinding, createTelegramCleanupTargetProtection, getTelegramTargetFromApiBody, getTelegramThreadOwnerKey, isSameTelegramProcessInstance, isTelegramTopicTargetStaleError, provisionOwnBusTopic, resetTelegramConnectionProvisioning, } from "./threads.js";
 import { createTelegramWorkspaceAdmissionOperationId, runWithTelegramWorkspaceAdmissionsAsync, } from "./workspace-admission.js";
 import { normalizeTelegramWorkspacePath } from "./workspace-identity.js";
 import { TelegramWorkspaceSlotUnavailableError } from "./workspace-slots.js";
@@ -463,11 +463,21 @@ export async function ensureTelegramLeaderThreadBinding(deps) {
         ...(deps.telegramProfile ? { telegramProfile: deps.telegramProfile } : {}),
     };
     const leaderProfileKey = getTelegramThreadOwnerKey(leaderOwner);
+    if (deps.forceFreshUnnamed) {
+        await resetTelegramConnectionProvisioning({
+            store: deps.topicTargetStore, owner: "leader", instanceId: deps.instanceId,
+            profileKey: leaderProfileKey, isCurrent: () => {
+                assertLeaderEpoch("connect-recovery");
+                return true;
+            }, recordEvent: deps.recordEvent,
+        });
+    }
     const legacyLeaderRecord = deps.topicTargetStore.getByProfileKey(leaderProfileKey);
     let capacityUnavailable = false;
     const workspaceIdentity = normalizedLeaderCwd
         ? deps.topicTargetStore.claimWorkspaceIdentity(normalizedLeaderCwd, deps.instanceId, legacyLeaderRecord?.instanceId, {
             sessionId: deps.sessionId,
+            provisionProfileKey: leaderProfileKey,
             onCapacityUnavailable() {
                 capacityUnavailable = true;
             },

package/node_modules/@llblab/pi-telegram/dist/lib/threads.d.ts

@@ -495,6 +495,7 @@ export interface TelegramTopicTargetStore {
     } | undefined;
     listReservations: () => TelegramThreadReservation[];
     listPendingProvisions: () => TelegramThreadPendingProvision[];
+    resetPendingProvisionForConnect: (expected: TelegramThreadPendingProvision, isCurrent: () => boolean) => Promise<boolean>;
     listPendingCleanups: () => TelegramThreadCleanupIntent[];
     listSyncObservations: () => TelegramTopicSyncObservation[];
     reserveThread: (reservation: TelegramThreadReservation) => void;
@@ -559,6 +560,7 @@ export interface TelegramTopicTargetStore {
     claimWorkspaceIdentity: (cwd: string, instanceId: string, previousInstanceId?: string, options?: {
         existingBindingOnly?: boolean;
         sessionId?: string;
+        provisionProfileKey?: string;
         onCapacityUnavailable?: () => void;
     }) => TelegramWorkspaceBindingIdentity | undefined;
     releaseWorkspaceClaim: (instanceId: string) => boolean;
@@ -957,4 +959,13 @@ export declare function getTelegramTargetFromApiBody(body: unknown): (TelegramTa
 export declare function isTelegramTopicTargetStaleError(error: unknown): boolean;
 export declare function isTelegramTopicModeUnavailableError(error: unknown): boolean;
 export declare function createTelegramTopicTargetRenamer(deps: TelegramTopicTargetRenamerDeps): (request: TelegramTopicTargetRenameRequest) => Promise<TelegramTopicTargetRecord | undefined>;
+/** Caller holds profile Workspace admission; only an explicit connect grants a fresh creation attempt. */
+export declare function resetTelegramConnectionProvisioning(input: {
+    store: TelegramTopicTargetStore;
+    owner: TelegramThreadPendingProvision["owner"];
+    instanceId: string;
+    profileKey: string;
+    isCurrent: () => boolean;
+    recordEvent: (category: string, message: unknown, details?: Record<string, unknown>) => void;
+}): Promise<void>;
 export declare function createTelegramTopicTargetProvisioner(deps: TelegramTopicTargetProvisionerDeps): (request: TelegramTopicTargetProvisionRequest) => Promise<TelegramTopicTargetProvisionResult>;