@llblab/pi-telegram 0.54.2 → 0.54.4

package/lib/routing.ts

@@ -462,7 +462,8 @@ function formatTelegramUnboundRerouteChooserText(command?: string): string {
 function formatTelegramUnboundRerouteRestoreChooserText(
   command?: string,
 ): string {
-  return `<b>🔁 Restore into this tab & send ${formatTelegramRouteSubject(command)}:</b>`;
+  const subject = command ? ` for ${formatTelegramRouteSubject(command)}` : "";
+  return `<b>🔁 Restore a Pi into this tab${subject}:</b>`;
 }
 
 function formatTelegramUnboundTopicGuidance(): string {
@@ -585,7 +586,10 @@ function classifyLiveRebindCleanupFailure(
     : "unknown";
 }
 
-/** Default live-rebind cleanup pacing: quick early attempts, then minutely, within a 15-minute window. */
+/**
+ * Default live-rebind cleanup pacing: quick early attempts, then minutely, within a 15-minute window. The first
+ * delay is not cosmetic: a leader's detached command reply still needs the released, cleanup-free row.
+ */
 export const TELEGRAM_LIVE_REBIND_CLEANUP_SCHEDULE = Object.freeze({
   delaysMs: Object.freeze([1_000, 2_000, 5_000, 10_000, 30_000]),
   intervalMs: 60_000,
@@ -643,6 +647,8 @@ export function createTelegramLiveRebindCoordinator(input: {
     /** Explicit staged singleton command branch; absence preserves ordinary live input behavior. */
     selectedCommand?: Bus.TelegramBusSelectedCommandInput;
   };
+  /** Restore moves the tab to its new owner: once applied, show that owner's title (best-effort, never blocking). */
+  retitle?: (isCurrent: () => boolean) => Promise<void>;
   recordRuntimeEvent?: (
     category: string,
     error: unknown,
@@ -773,6 +779,7 @@ export function createTelegramLiveRebindCoordinator(input: {
   let saved = false,
     commitIssued = false,
     applyIssued = false,
+    retitleIssued = false,
     peerReleaseIssued = false,
     donorSettlementAttempted = false,
     continuationIssued = false,
@@ -1030,6 +1037,17 @@ export function createTelegramLiveRebindCoordinator(input: {
         }
         if (!sourceSaved() || (preparation && !preparation.confirmSaved()))
           return "protected";
+        if (input.retitle && !retitleIssued) {
+          retitleIssued = true;
+          try {
+            await input.retitle(current);
+          } catch (error) {
+            input.recordRuntimeEvent?.("telegram", error, {
+              phase: "live-rebind-title",
+            });
+          }
+          if (!current() || !canonical(intent)) return "unknown";
+        }
         if (intent.phase === "rebound") {
           const expected = intent;
           input.restoreStore.advanceLiveRebind(
@@ -1330,6 +1348,8 @@ export const TELEGRAM_ALL_TAB_COMMAND_MAX_AGE_MS = 60 * 60_000;
 export const TELEGRAM_ROUTING_CHOICE_EXPIRED = "Routing choice expired";
 /** Every temporary routing tab carries this name, whether the bot created it or adopted Telegram's native tab. */
 const TELEGRAM_TEMPORARY_THREAD_NAME = "🚦 Routing";
+/** A mobile client's native tab creation precedes the All input it is named after by about a second. */
+const TELEGRAM_IMPLICIT_ALL_INPUT_WINDOW_SEC = 10;
 
 export function isTelegramAllTabCommandExpired(
   message: { date?: number; message_thread_id?: number },
@@ -1797,6 +1817,8 @@ export function createTelegramInboundRouteRuntime<
       TContext
     >
   >["canPrepareHeldCommand"];
+  /** Agent-settled hint: wakes waiting leader cleanup retries early; every readiness gate is still sampled fresh. */
+  onSessionSettled(ctx: TContext): void;
   /** Fresh body-free recipient observation only; never reconstructs an attempt or grants cleanup. */
   observeLiveRebindLeaderWork(
     intent: Threads.TelegramWorkspaceLiveRebindIntent,
@@ -1886,6 +1908,8 @@ export function createTelegramInboundRouteRuntime<
     temporaryThread?: Threads.TelegramTemporaryThreadEntry;
     /** Source copies left in All (a menu-picked command); deleted once, when the input is consumed. */
     allTabCopies?: number[];
+    /** The tab holds a forwarded copy of the threadless original, which then left All at once. */
+    allTabCopiesForwarded?: true;
     /** Acknowledged same-tab membership stays protective when its reader disappears; never a dispatch/cleanup grant. */
     temporaryMembership?: true;
     /** Re-entrancy lock for one command route in flight; orthogonal to `phase`. */
@@ -1916,7 +1940,8 @@ export function createTelegramInboundRouteRuntime<
     /** Some Forward outcome is unknown; process-local, so restart-safe issuance remains a release gate. */
     | { kind: "forward-unknown" }
     | { kind: "cleanup"; cleanup: PendingRerouteCleanup }
-    | { kind: "finalizing"; message: string };
+    /** `retainRecord`: a live rebind's chooser-scoped command reference outlives its deleted menu. */
+    | { kind: "finalizing"; message: string; retainRecord?: true };
   /** The command a chooser routes, read from its own source exactly as the root heading named it. */
   const getPendingRerouteCommandName = (
     pending: PendingUnboundReroute,
@@ -1945,6 +1970,9 @@ export function createTelegramInboundRouteRuntime<
       executor: Threads.TelegramWorkspaceRestoreExecutor;
       generation: number | undefined;
       scope: string | undefined;
+      target: { chatId: number; threadId: number };
+      name: string;
+      createdAtSec: number;
     }
   >();
   const guidedUnboundTopicKeys = new Set<string>();
@@ -2776,6 +2804,52 @@ export function createTelegramInboundRouteRuntime<
       pending.sourceTarget.chatId,
       pending.allTabCopies?.splice(0) ?? [],
     );
+  /**
+   * 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: PendingUnboundReroute,
+  ): Promise<void> => {
+    if (pending.allTabCopiesForwarded) return deleteAllTabCopies(pending);
+    pending.allTabCopies?.splice(0);
+    return Promise.resolve();
+  };
+  /**
+   * The Bot API files a threadless All input in All even when a mobile client first draws it in its new tab. One silent
+   * best-effort forward moves it into the routing tab it opened, and only a confirmed copy lets the original leave All;
+   * any failure keeps the original where the operator can still read it.
+   */
+  const moveAllTabSourceIntoTab = async (
+    pending: PendingUnboundReroute,
+    target: { chatId: number; threadId: number },
+    isCurrent: () => boolean,
+  ): Promise<number | undefined> => {
+    const [messageId] = pending.allTabCopies ?? [];
+    if (messageId === undefined || !deps.callApi || !isCurrent()) return;
+    try {
+      const copy = await deps.callApi<{ message_id?: unknown }>(
+        "forwardMessage",
+        {
+          chat_id: target.chatId,
+          message_thread_id: target.threadId,
+          from_chat_id: pending.sourceTarget.chatId,
+          message_id: messageId,
+          disable_notification: true,
+        },
+      );
+      const copyId = copy?.message_id;
+      if (typeof copyId !== "number" || !Number.isSafeInteger(copyId)) return;
+      pending.allTabCopiesForwarded = true;
+      await deleteAllTabCopies(pending);
+      return copyId;
+    } catch (error) {
+      deps.recordRuntimeEvent?.("routing", error, {
+        phase: "temporary-thread-source-forward",
+      });
+      return;
+    }
+  };
   const dismissRerouteChooserMessage = async (
     query: TCallbackQuery,
     assertExecutionCurrent?: () => void,
@@ -2805,6 +2879,36 @@ export function createTelegramInboundRouteRuntime<
       return false;
     }
   };
+  /** Choosers are one-shot: a final outcome deletes the menu; only a failed delete leaves an inert, button-free notice. */
+  const retireRerouteChooserMessage = async (
+    chatId: number,
+    messageId: number,
+    fallbackText: string,
+    assertCurrent?: () => void,
+  ): Promise<void> => {
+    if (deps.deleteMessage) {
+      try {
+        await deps.deleteMessage(chatId, messageId);
+        return;
+      } catch (error) {
+        deps.recordRuntimeEvent?.("telegram", error, {
+          phase: "reroute-chooser-delete",
+          chatId,
+          messageId,
+        });
+      }
+      assertCurrent?.();
+    }
+    await deps.editInteractiveMessage?.(
+      chatId,
+      messageId,
+      fallbackText,
+      "html",
+      {
+        inline_keyboard: [],
+      },
+    );
+  };
   const closeReroutedUnboundTopic = async (
     target: { chatId: number; threadId: number } | undefined,
     messageId: number | undefined,
@@ -2970,8 +3074,9 @@ export function createTelegramInboundRouteRuntime<
           continue;
         if (!recordCancelledTemporaryThreadInput(pending, ctx, current))
           continue;
+        // A sibling cancelled by Restore stays visible in the restored tab, like a desktop input typed there.
         if (await retireCancellationChooser(id, pending, current))
-          await deleteAllTabCopies(pending);
+          await releaseAllTabCopiesIntoSurvivingTab(pending);
       } catch (error) {
         deps.recordRuntimeEvent?.("routing", error, {
           phase: "temporary-thread-restore-sibling",
@@ -3701,6 +3806,25 @@ export function createTelegramInboundRouteRuntime<
                 );
                 if (!intent) continue;
               }
+              // The chooser follows the success proof, never old-thread cleanup, which may stay protected indefinitely.
+              const retireRestoreChoosers = async (): Promise<void> => {
+                for (const [id, pending] of pendingUnboundReroutes) {
+                  if (pending.workspaceRestore?.operationId !== operationId)
+                    continue;
+                  pending.phase = { kind: "finalizing", message: "Restored" };
+                  if (pending.chooserMessageId === undefined) continue;
+                  assertSettlementCurrent();
+                  await retireRerouteChooserMessage(
+                    pending.sourceTarget.chatId,
+                    pending.chooserMessageId,
+                    "<b>✅ Message routed.</b>",
+                    assertSettlementCurrent,
+                  );
+                  assertSettlementCurrent();
+                  if (pendingUnboundReroutes.get(id) === pending)
+                    removePendingReroute(id);
+                }
+              };
               if (intent.routing?.cleanup === undefined) {
                 if (
                   !intent.request.source.updateIds.every((id) =>
@@ -3711,13 +3835,14 @@ export function createTelegramInboundRouteRuntime<
                   )
                 )
                   continue;
-                // Positive settlement of every selected source is the success proof; old-thread cleanup may stay protected indefinitely.
+                // Positive settlement of every selected source is the success proof.
                 await disposeTemporaryThreadSiblingsAfterRestore(
                   intent,
                   ctx,
                   settlementAuthority.isCurrent,
                 );
                 assertSettlementCurrent();
+                await retireRestoreChoosers();
                 if (
                   isRerouteTargetProtected(
                     intent.request.binding.target,
@@ -3753,27 +3878,7 @@ export function createTelegramInboundRouteRuntime<
               }
               if (!store.retire(intent, settlementAuthority)) continue;
               retired = true;
-              for (const [id, pending] of pendingUnboundReroutes) {
-                if (pending.workspaceRestore?.operationId !== operationId)
-                  continue;
-                pending.phase = { kind: "finalizing", message: "Restored" };
-                if (
-                  !deps.editInteractiveMessage ||
-                  pending.chooserMessageId === undefined
-                )
-                  continue;
-                assertSettlementCurrent();
-                await deps.editInteractiveMessage(
-                  pending.sourceTarget.chatId,
-                  pending.chooserMessageId,
-                  "<b>✅ Message routed.</b>",
-                  "html",
-                  { inline_keyboard: [] },
-                );
-                assertSettlementCurrent();
-                if (pendingUnboundReroutes.get(id) === pending)
-                  removePendingReroute(id);
-              }
+              await retireRestoreChoosers();
             }
           },
         ),
@@ -5089,6 +5194,23 @@ export function createTelegramInboundRouteRuntime<
         messages: selection.messages,
         restoreStore: store,
         threadStore: threads,
+        // Same title as Workspace Restore: the display-mode title of the restored binding on its new tab.
+        retitle: deps.callApi
+          ? async (isCurrent) => {
+              if (!isCurrent()) return;
+              const slot = binding.slot ?? "";
+              await deps.callApi!("editForumTopic", {
+                chat_id: target.chatId,
+                message_thread_id: target.threadId,
+                name:
+                  deps.getDisplayTitle?.(target) ??
+                  ThreadNaming.getTelegramTopicTitleForThreadName(
+                    getRestoredThreadName(request.owner, slot),
+                    slot,
+                  ),
+              });
+            }
+          : undefined,
         authority: {
           executor: { instanceId, leaderEpoch: String(epoch) },
           operatorUserId,
@@ -5783,6 +5905,8 @@ export function createTelegramInboundRouteRuntime<
     string,
     ReturnType<typeof setTimeout> | "running"
   >();
+  // A leader retry waiting out its delay; a settled session wakes it at once, since its own busy run is the usual wait.
+  const liveRebindCleanupWakers = new Map<string, () => void>();
   /** End an unissued attempt honestly under fresh admission and current operator authority; no executor grant is borrowed. */
   const terminalizeUnissuedLiveRebindCleanup = async (
     operationId: string,
@@ -5855,7 +5979,8 @@ export function createTelegramInboundRouteRuntime<
         liveRebindCleanupChains.delete(operationId);
       return;
     }
-    const timer = setTimeout(() => {
+    const attemptNow = () => {
+      liveRebindCleanupWakers.delete(operationId);
       if (liveRebindCleanupChains.get(operationId) !== timer) return;
       liveRebindCleanupChains.set(operationId, "running");
       let continued = false;
@@ -5901,9 +6026,25 @@ export function createTelegramInboundRouteRuntime<
         });
       restoreSettlementTasks.add(task);
       void task.finally(() => restoreSettlementTasks.delete(task));
-    }, pacing.delaysMs[attempt] ?? pacing.intervalMs);
+    };
+    const timer = setTimeout(
+      attemptNow,
+      pacing.delaysMs[attempt] ?? pacing.intervalMs,
+    );
     timer.unref?.();
     liveRebindCleanupChains.set(operationId, timer);
+    // The first delay stays whole: a detached command reply still needs the released, cleanup-free row.
+    if (role === "leader" && attempt > 0)
+      liveRebindCleanupWakers.set(operationId, () => {
+        if (liveRebindCleanupChains.get(operationId) !== timer) return;
+        clearTimeout(timer);
+        attemptNow();
+      });
+  };
+  /** The agent settled: every gate is re-sampled now, so an old tab goes right after the answer, not at the next tick. */
+  const onSessionSettled = (ctx: TContext): void => {
+    if (deps.isContextActive?.(ctx) !== true) return;
+    for (const wake of [...liveRebindCleanupWakers.values()]) wake();
   };
   const restoreWorkspace = deps.workspaceRestoreRecipient
     ? async (input: {
@@ -6441,6 +6582,7 @@ export function createTelegramInboundRouteRuntime<
     assertExecutionCurrent = Updates.createTelegramUpdateExecutionFenceGuard(
       query,
     ),
+    retainRecord = false,
   ): Promise<void> => {
     assertExecutionCurrent();
     const dismissed = await dismissRerouteChooserMessage(
@@ -6449,12 +6591,18 @@ export function createTelegramInboundRouteRuntime<
     );
     assertExecutionCurrent();
     if (dismissed) {
-      removePendingReroute(rerouteId);
+      // A retained record no longer matches any chooser, so a late duplicate tap reads as expired.
+      if (retainRecord) pending.chooserMessageId = undefined;
+      else removePendingReroute(rerouteId);
       await deps.answerCallbackQuery(query.id, successMessage);
       await deleteAllTabCopies(pending);
       return;
     }
-    pending.phase = { kind: "finalizing", message: successMessage };
+    pending.phase = {
+      kind: "finalizing",
+      message: successMessage,
+      ...(retainRecord ? { retainRecord: true as const } : {}),
+    };
     await deps.answerCallbackQuery(
       query.id,
       `${successMessage}; tap again to clear the menu`,
@@ -7012,16 +7160,14 @@ export function createTelegramInboundRouteRuntime<
     if (
       !isPendingRerouteCancelled(pending) ||
       !isCurrent() ||
-      !deps.editInteractiveMessage ||
+      (!deps.deleteMessage && !deps.editInteractiveMessage) ||
       pending.chooserMessageId === undefined
     )
       return false;
-    await deps.editInteractiveMessage(
+    await retireRerouteChooserMessage(
       pending.sourceTarget.chatId,
       pending.chooserMessageId,
       "<b>⛔️ Routing cancelled.</b>",
-      "html",
-      { inline_keyboard: [] },
     );
     if (!isCurrent() || pendingUnboundReroutes.get(id) !== pending)
       return false;
@@ -7518,6 +7664,7 @@ export function createTelegramInboundRouteRuntime<
         const result = source.expire();
         if (!result) return;
         // Expiry revokes the donor carrier; old controls and late ACKs cannot issue another delivery. No body is archived.
+        let movedIntoTab = false;
         for (const [id, pending] of pendingUnboundReroutes) {
           if (
             !Updates.collectTelegramAdmissionSourceUpdateIds(
@@ -7525,6 +7672,7 @@ export function createTelegramInboundRouteRuntime<
             ).includes(source.original.updateId)
           )
             continue;
+          movedIntoTab ||= pending.allTabCopiesForwarded === true;
           removePendingReroute(id);
           if (
             signal.aborted ||
@@ -7557,13 +7705,15 @@ export function createTelegramInboundRouteRuntime<
         // never closes over this source or asks the worker to retain a terminal prompt while metadata publication fails.
         if (temporary?.target && runtimeCurrent()) {
           scheduleTemporaryThreadCleanup(temporary.target, ctx, true);
-          await deleteAllTabMessages(
-            temporary.target.chatId,
-            getTelegramAllTabSourceMessageIds(
-              [message!],
+          // A moved original already left All with its forward; only an unmoved one is deleted here.
+          if (!movedIntoTab)
+            await deleteAllTabMessages(
               temporary.target.chatId,
-            ),
-          );
+              getTelegramAllTabSourceMessageIds(
+                [message!],
+                temporary.target.chatId,
+              ),
+            );
         }
       },
     );
@@ -8167,6 +8317,7 @@ export function createTelegramInboundRouteRuntime<
         query,
         pending.phase.message,
         assertExecutionCurrent,
+        pending.phase.retainRecord === true,
       );
       return true;
     }
@@ -8561,7 +8712,8 @@ export function createTelegramInboundRouteRuntime<
             selection.record.owner?.kind === "leader" ? "leader" : "follower",
             ctx,
           );
-        if (outcome === "released") await deleteAllTabCopies(pending);
+        if (outcome === "released")
+          await releaseAllTabCopiesIntoSurvivingTab(pending);
       } catch (error) {
         deps.recordRuntimeEvent?.("routing", error, {
           phase: "live-rebind-chooser",
@@ -8570,31 +8722,41 @@ export function createTelegramInboundRouteRuntime<
         selection.isCurrent = undefined;
       }
       assertExecutionCurrent();
-      await deps.answerCallbackQuery(
-        query.id,
-        outcome === "released"
-          ? selection.extensionKind === "generated-prompt"
-            ? "Input queued in the rebound Thread; old-Thread cleanup is scheduled, not confirmed"
-            : selection.extensionCommand
-              ? "Command source disposal confirmed; reply delivery and old-Thread cleanup are not confirmed"
-              : selection.nameCommand
-                ? selection.nameCommand.args.trim()
-                  ? "Command source disposal confirmed; title/reply delivery and old-Thread cleanup are not confirmed"
-                  : "Command source disposal confirmed; name-dialog publication was handled, not title change or old-Thread cleanup"
-                : selection.confirmationCommand
-                  ? `Command source disposal confirmed; confirmation delivery and actual ${selection.confirmationCommand.name === "new" ? "session replacement" : "compaction"} or old-Thread cleanup are not confirmed`
-                  : selection.helpCommand
-                    ? "Command source disposal confirmed; menu/sync delivery and old-Thread cleanup are not confirmed"
-                    : selection.stopCommand
-                      ? "Command source disposal confirmed; abort settlement, reply delivery and old-Thread cleanup are not confirmed"
-                      : selection.nextCommand
-                        ? "Command source disposal confirmed; queue dispatch, transition notices and old-Thread cleanup are not confirmed"
-                        : selection.menuCommand || selection.abortCommand
-                          ? `Command source disposal confirmed; ${selection.menuCommand ? "menu" : "reply"} delivery and old-Thread cleanup are not confirmed`
-                          : selection.coordinator?.selectedCommandReference()
-                            ? "Command source disposal confirmed; recipient command effects and old-Thread cleanup are not confirmed"
-                            : "Input queued in the rebound Thread; old-Thread cleanup is scheduled, not confirmed"
-          : "Live rebind is unconfirmed; this choice never replays issued input",
+      if (outcome !== "released") {
+        await deps.answerCallbackQuery(
+          query.id,
+          "Live rebind is unconfirmed; this choice never replays issued input",
+        );
+        return true;
+      }
+      // The tab now belongs to the rebound thread; only the one-shot chooser message goes.
+      await finalizePendingReroute(
+        parsed.rerouteId,
+        pending,
+        query,
+        selection.extensionKind === "generated-prompt"
+          ? "Input queued in the rebound Thread; old-Thread cleanup is scheduled, not confirmed"
+          : selection.extensionCommand
+            ? "Command source disposal confirmed; reply delivery and old-Thread cleanup are not confirmed"
+            : selection.nameCommand
+              ? selection.nameCommand.args.trim()
+                ? "Command source disposal confirmed; title/reply delivery and old-Thread cleanup are not confirmed"
+                : "Command source disposal confirmed; name-dialog publication was handled, not title change or old-Thread cleanup"
+              : selection.confirmationCommand
+                ? `Command source disposal confirmed; confirmation delivery and actual ${selection.confirmationCommand.name === "new" ? "session replacement" : "compaction"} or old-Thread cleanup are not confirmed`
+                : selection.helpCommand
+                  ? "Command source disposal confirmed; menu/sync delivery and old-Thread cleanup are not confirmed"
+                  : selection.stopCommand
+                    ? "Command source disposal confirmed; abort settlement, reply delivery and old-Thread cleanup are not confirmed"
+                    : selection.nextCommand
+                      ? "Command source disposal confirmed; queue dispatch, transition notices and old-Thread cleanup are not confirmed"
+                      : selection.menuCommand || selection.abortCommand
+                        ? `Command source disposal confirmed; ${selection.menuCommand ? "menu" : "reply"} delivery and old-Thread cleanup are not confirmed`
+                        : selection.coordinator?.selectedCommandReference()
+                          ? "Command source disposal confirmed; recipient command effects and old-Thread cleanup are not confirmed"
+                          : "Input queued in the rebound Thread; old-Thread cleanup is scheduled, not confirmed",
+        assertExecutionCurrent,
+        true,
       );
       return true;
     }
@@ -8606,6 +8768,8 @@ export function createTelegramInboundRouteRuntime<
         messages: [...pending.messages],
       });
       let active = true;
+      // Delivery proof for the toast only; chooser retirement still waits for the positive settlement that follows.
+      let delivered = false;
       const ownerUserId = deps.configStore.getAllowedUserId();
       const leaderEpoch = deps.getCurrentLeaderEpoch?.();
       const admissionScope = deps.getAdmissionScope?.();
@@ -8671,7 +8835,8 @@ export function createTelegramInboundRouteRuntime<
                   : routed;
               await dispatchPendingRerouteMessages(pending, messages, ctx);
               assertRecipientCurrent();
-              await deleteAllTabCopies(pending);
+              delivered = true;
+              await releaseAllTabCopiesIntoSurvivingTab(pending);
               return true;
             }
             const forwarded = await forwardPendingRerouteMessages(
@@ -8682,7 +8847,10 @@ export function createTelegramInboundRouteRuntime<
               assertRecipientCurrent,
               recordForwardAcceptance,
             );
-            if (forwarded) await deleteAllTabCopies(pending);
+            if (forwarded) {
+              delivered = true;
+              await releaseAllTabCopiesIntoSurvivingTab(pending);
+            }
             return forwarded;
           },
         });
@@ -8693,7 +8861,7 @@ export function createTelegramInboundRouteRuntime<
       if (!selectionCurrent()) return true;
       await deps.answerCallbackQuery(
         query.id,
-        "Restore unconfirmed; not resending",
+        delivered ? "Restored" : "Restore unconfirmed; not resending",
       );
       return true;
     }
@@ -10075,6 +10243,47 @@ export function createTelegramInboundRouteRuntime<
     }
     return undefined;
   };
+  /**
+   * A fresh implicit native tab observed just before the All input in the same exact scope: mobile names it after
+   * the input, while other clients may use a generic name, so the immediately preceding creation also qualifies.
+   */
+  const findImplicitCreationForAllInput = (
+    message: TMessage,
+    updateId: number,
+    cap: NonNullable<ReturnType<typeof captureTemporaryThreadAuthority>>,
+    ctx: TContext,
+  ) => {
+    const text = (message.text ?? message.caption ?? "").trim();
+    let match:
+      | {
+          key: string;
+          implicit: typeof implicitThreadCreations extends Map<string, infer V>
+            ? V
+            : never;
+        }
+      | undefined;
+    for (const [key, implicit] of implicitThreadCreations) {
+      if (
+        ((implicit.name && text.startsWith(implicit.name)) ||
+          implicit.updateId === updateId - 1) &&
+        implicit.updateId < updateId &&
+        implicit.createdAtSec > 0 &&
+        message.date !== undefined &&
+        message.date >= implicit.createdAtSec &&
+        message.date - implicit.createdAtSec <=
+          TELEGRAM_IMPLICIT_ALL_INPUT_WINDOW_SEC &&
+        implicit.ctx === ctx &&
+        implicit.operatorUserId === cap.operatorUserId &&
+        implicit.journalBindingKey === cap.journalBindingKey &&
+        isDeepStrictEqual(implicit.executor, cap.authority.executor) &&
+        implicit.generation === deps.getSessionGeneration?.() &&
+        implicit.scope === deps.getAdmissionScope?.() &&
+        (!match || implicit.updateId > match.implicit.updateId)
+      )
+        match = { key, implicit };
+    }
+    return match;
+  };
   /**
    * An All input gets one source-bound tab. The original stays deferred in All until explicit routing,
    * and an existing entry is reused on replay, so restart never creates a second tab or retries an unknown one.
@@ -10116,6 +10325,9 @@ export function createTelegramInboundRouteRuntime<
             entry.source.updateId === updateId,
         );
     let entry: Threads.TelegramTemporaryThreadEntry | undefined;
+    // A tab opened by this call, by the bot or adopted from the client, gets the input's one forwarded copy; re-entry
+    // after a restart finds its tab already prepared and never forwards again.
+    let openedNow = false;
     await deps.runWorkspaceOperation(
       {
         operationId: `temporary-thread-${randomBytes(16).toString("hex")}`,
@@ -10130,6 +10342,45 @@ export function createTelegramInboundRouteRuntime<
           entry = found;
           return;
         }
+        // Mobile clients sending from All first create a native tab named after the input, then deliver
+        // the input itself to All: adopt that tab rather than leaving it behind next to a second one.
+        const native = findImplicitCreationForAllInput(
+          message,
+          updateId,
+          cap,
+          ctx,
+        );
+        if (native) {
+          const adopted = store.registerImplicitTemporaryThread(
+            { journalBindingKey, updateIds: [updateId] },
+            native.implicit.target,
+            randomBytes(16).toString("hex"),
+            {
+              ...authority,
+              isCurrent: () =>
+                current() &&
+                implicitThreadCreations.get(native.key) === native.implicit,
+            },
+          );
+          if (adopted && current()) {
+            implicitThreadCreations.delete(native.key);
+            entry = adopted;
+            openedNow = true;
+            // Adopted native tabs share the routing name; a failed rename never blocks routing.
+            try {
+              await deps.callApi!("editForumTopic", {
+                chat_id: native.implicit.target.chatId,
+                message_thread_id: native.implicit.target.threadId,
+                name: TELEGRAM_TEMPORARY_THREAD_NAME,
+              });
+            } catch (error) {
+              deps.recordRuntimeEvent?.("routing", error, {
+                phase: "temporary-thread-name",
+              });
+            }
+            return;
+          }
+        }
         const reservation = store.reserveTemporaryThread(
           source,
           randomBytes(16).toString("hex"),
@@ -10161,12 +10412,13 @@ export function createTelegramInboundRouteRuntime<
           threadId <= 0
         )
           return;
-        entry =
-          store.acknowledgeTemporaryThread(
-            reservation.entry,
-            { chatId: operatorUserId, threadId },
-            authority,
-          ) ?? entry;
+        const acknowledged = store.acknowledgeTemporaryThread(
+          reservation.entry,
+          { chatId: operatorUserId, threadId },
+          authority,
+        );
+        openedNow = !!acknowledged;
+        entry = acknowledged ?? entry;
       },
     );
     if (!current() || !entry)
@@ -10222,6 +10474,9 @@ export function createTelegramInboundRouteRuntime<
     pending.rootChooserText = formatTelegramTemporaryThreadChooserText(
       command?.name,
     );
+    const tabCopyId = openedNow
+      ? await moveAllTabSourceIntoTab(pending, target, current)
+      : undefined;
     try {
       if (!deps.sendInteractiveMessage)
         throw new Error("Temporary Thread chooser publication is unavailable.");
@@ -10233,7 +10488,9 @@ export function createTelegramInboundRouteRuntime<
           canCancel: !!pending.abandonment,
           getDisplayTitle: deps.getDisplayTitle,
         }),
-        { target },
+        tabCopyId === undefined
+          ? { target }
+          : { target, replyToMessageId: tabCopyId },
       );
       rememberRerouteChooser(rerouteId, chooserId);
     } catch (error) {
@@ -10625,6 +10882,15 @@ export function createTelegramInboundRouteRuntime<
         executor: structuredClone(cap.authority.executor),
         generation: deps.getSessionGeneration?.(),
         scope: deps.getAdmissionScope?.(),
+        target: {
+          chatId: lifecycle.target.chatId,
+          threadId: lifecycle.target.threadId!,
+        },
+        name:
+          "name" in created && typeof created.name === "string"
+            ? created.name
+            : "",
+        createdAtSec: message.date ?? 0,
       });
     } else implicitThreadCreations.delete(key);
   };
@@ -11015,6 +11281,33 @@ export function createTelegramInboundRouteRuntime<
           threadId: target.threadId,
         };
         /** Rebinds the leader record to this unbound tab, publishes its identity and handles the message there. */
+        // The leader's own Workspace binding follows a reclaimed tab, keeping its slot and name; without it, the tab
+        // would gain a second slot while Restore, labels and titles still pointed at the deleted target.
+        const leaderWorkspaceCwd =
+          typeof (ctx as { cwd?: unknown }).cwd === "string"
+            ? (ctx as { cwd: string }).cwd
+            : undefined;
+        const claimLeaderWorkspaceBinding = ():
+          Threads.TelegramWorkspaceThreadBinding | undefined => {
+          const sessionId = deps.workspaceRestoreRecipient?.getSessionId(ctx);
+          if (!leaderWorkspaceCwd || !sessionId || !instanceId)
+            return undefined;
+          const identity = deps.threadStore!.claimWorkspaceIdentity(
+            leaderWorkspaceCwd,
+            instanceId,
+            undefined,
+            { existingBindingOnly: true, sessionId },
+          );
+          const binding = identity
+            ? deps.threadStore!.getWorkspaceBinding(
+                identity.cwd,
+                identity.instanceSlot,
+                identity.sessionId,
+              )
+            : undefined;
+          if (!binding) deps.threadStore!.releaseWorkspaceClaim(instanceId);
+          return binding;
+        };
         const reclaimUnboundTargetForLeader = async (
           base: Partial<Threads.TelegramTopicTargetRecord> &
             Pick<Threads.TelegramTopicTargetRecord, "createdAtMs">,
@@ -11023,7 +11316,25 @@ export function createTelegramInboundRouteRuntime<
           threadName: string,
           event: string,
           details: Record<string, unknown>,
+          leaderBinding?: Threads.TelegramWorkspaceThreadBinding,
         ): Promise<void> => {
+          if (leaderBinding) {
+            const {
+              inactiveSinceMs: _inactiveSinceMs,
+              displayTitle: _displayTitle,
+              ...moved
+            } = leaderBinding;
+            const committed = deps.threadStore!.upsertWorkspaceBinding(
+              {
+                ...moved,
+                target: { ...unboundTarget },
+                updatedAtMs: Date.now(),
+              },
+              instanceId,
+            );
+            deps.threadStore!.releaseWorkspaceClaim(instanceId!);
+            if (committed) threadName = committed.threadName ?? threadName;
+          }
           deps.threadStore!.upsert({
             ...base,
             profileKey,
@@ -11055,6 +11366,35 @@ export function createTelegramInboundRouteRuntime<
             slot,
             profileKey,
           });
+          if (leaderBinding && deps.callApi) {
+            const title = deps.getDisplayTitle?.(unboundTarget);
+            if (title)
+              try {
+                await deps.callApi("editForumTopic", {
+                  chat_id: unboundTarget.chatId,
+                  message_thread_id: unboundTarget.threadId,
+                  name: title,
+                });
+                const current = deps
+                  .threadStore!.listWorkspaceBindings()
+                  .find(
+                    (value) =>
+                      value.bindingKey === leaderBinding.bindingKey &&
+                      isDeepStrictEqual(value.target, unboundTarget),
+                  );
+                if (current) {
+                  deps.threadStore!.upsertWorkspaceBinding({
+                    ...current,
+                    displayTitle: title,
+                  });
+                  await deps.threadStore!.persist();
+                }
+              } catch (error) {
+                deps.recordRuntimeEvent?.("bus", error, {
+                  phase: "leader-topic-reclaim-title",
+                });
+              }
+          }
           await textDispatch.handleMessage(message as TMessage, ctx);
         };
         const records = deps.threadStore.list();
@@ -11195,7 +11535,14 @@ export function createTelegramInboundRouteRuntime<
               if (!currentLeaderIsStale) throw error;
             }
             if (currentLeaderIsStale) {
-              const slot = deps.threadStore.allocateSlot(leaderProfileKey);
+              const leaderBinding = claimLeaderWorkspaceBinding();
+              const slot = deps.threadStore.allocateSlot(
+                leaderProfileKey,
+                leaderBinding?.slot,
+                leaderBinding?.bindingKey,
+              );
+              if (leaderBinding && leaderBinding.slot !== slot)
+                deps.threadStore.releaseWorkspaceClaim(instanceId!);
               if (!slot) {
                 deps.threadStore.markStaleByTarget(
                   currentLeaderRecord.target,
@@ -11231,6 +11578,7 @@ export function createTelegramInboundRouteRuntime<
                   phase: "leader-topic-unbound-stale-reclaim",
                   staleThreadId: currentLeaderRecord.target.threadId,
                 },
+                leaderBinding?.slot === slot ? leaderBinding : undefined,
               );
               return;
             }
@@ -11245,10 +11593,16 @@ export function createTelegramInboundRouteRuntime<
             deps.threadStore.getByProfileKey(leaderProfileKey);
           const priorLeaderIdentity =
             deps.threadStore.getIdentityByProfileKey(leaderProfileKey);
+          const leaderBinding = claimLeaderWorkspaceBinding();
           const slot = deps.threadStore.allocateSlot(
             leaderProfileKey,
-            priorLeaderRecord?.slot ?? priorLeaderIdentity?.slot,
+            leaderBinding?.slot ??
+              priorLeaderRecord?.slot ??
+              priorLeaderIdentity?.slot,
+            leaderBinding?.bindingKey,
           );
+          if (leaderBinding && leaderBinding.slot !== slot)
+            deps.threadStore.releaseWorkspaceClaim(instanceId!);
           if (!slot) {
             await deps.sendTextReply(
               target.chatId,
@@ -11278,6 +11632,7 @@ export function createTelegramInboundRouteRuntime<
             threadName,
             "Bus leader reclaimed unbound thread",
             { phase: "leader-topic-reclaim" },
+            leaderBinding?.slot === slot ? leaderBinding : undefined,
           );
           return;
         }
@@ -11307,6 +11662,7 @@ export function createTelegramInboundRouteRuntime<
     onUpdateCompleted,
     prepareHeldCommand: commandHandler.prepareHeldCommand,
     canPrepareHeldCommand: commandHandler.canPrepareHeldCommand,
+    onSessionSettled,
     observeLiveRebindLeaderWork,
     prepareLiveRebindLeaderCleanup,
     prepareLiveRebindFollowerCleanup,