@llblab/pi-telegram 0.42.3 → 0.43.0

package/lib/bus.ts

@@ -1450,18 +1450,25 @@ export function createTelegramBusFollowerThreadRestoreHandler(
   return async ({ record, target, oldTarget }) => {
     if (!record.instanceId) return false;
     const follower = deps.followerRegistry.get(record.instanceId);
-    if (!follower) return false;
+    if (!follower?.registrationGeneration || !oldTarget ||
+      follower.target?.chatId !== oldTarget.chatId ||
+      follower.target.threadId !== oldTarget.threadId ||
+      target.chatId !== oldTarget.chatId || target.threadId === oldTarget.threadId) return false;
     const replaced = await deps.followerTargetController.replaceTarget({
       follower,
       target,
       oldTarget,
       reason: "thread-restore",
     });
-    if (!replaced) return false;
+    const current = deps.followerRegistry.get(record.instanceId);
+    if (!replaced || !current ||
+      current.registrationGeneration !== follower.registrationGeneration ||
+      current.target?.chatId !== oldTarget.chatId ||
+      current.target.threadId !== oldTarget.threadId) return false;
     deps.followerRegistry.register({
-      ...follower,
+      ...current,
       target,
-      connectedAtMs: follower.connectedAtMs,
+      connectedAtMs: current.connectedAtMs,
     });
     deps.onRestored?.();
     return true;

package/lib/keyboard.ts

@@ -9,11 +9,13 @@ export type TelegramInlineKeyboardButtonStyle =
   | "success"
   | "primary";
 
-export interface TelegramInlineKeyboardButton {
+export type TelegramInlineKeyboardButton = {
   text: string;
-  callback_data: string;
   style?: TelegramInlineKeyboardButtonStyle;
-}
+} & (
+  | { callback_data: string; disabled?: never }
+  | { disabled: Record<string, never>; callback_data?: never }
+);
 
 export interface TelegramInlineKeyboardMarkup {
   inline_keyboard: TelegramInlineKeyboardButton[][];

package/lib/outbound-buttons.ts

@@ -12,6 +12,8 @@ import type {
 } from "./keyboard.ts";
 import {
   parseTelegramActionPayloadRows,
+  parseTelegramButtonPayloadRows,
+  replaceTelegramButtonFences,
   replaceTopLevelHtmlComments,
 } from "./outbound-markup.ts";
 import {
@@ -34,6 +36,7 @@ export interface TelegramOutboundButtonAction {
   prompt: string;
   binding?: TelegramOutboundButtonBinding;
   selectedStyle?: TelegramInlineKeyboardButtonStyle;
+  disabled?: true;
 }
 
 export interface TelegramOutboundButtonStoredAction extends TelegramOutboundButtonAction {
@@ -115,6 +118,12 @@ function parseTelegramButtonAction(
   const explicitLabel = getTelegramButtonString(payload, "label");
   const explicitPrompt = getTelegramButtonString(payload, "prompt");
   const label = explicitLabel ?? value ?? explicitPrompt;
+  if (payload.disabled !== undefined && typeof payload.disabled !== "boolean") {
+    return undefined;
+  }
+  if (payload.disabled === true) {
+    return { text: label ?? "", prompt: "", disabled: true };
+  }
   const prompt = explicitPrompt ?? value ?? explicitLabel;
   if (!label || !prompt) return undefined;
   const selectedStyle = payload.selected_style;
@@ -159,6 +168,7 @@ export function createTelegramButtonActionStore(
       return {
         text: action.text,
         prompt: action.prompt,
+        ...(action.disabled ? { disabled: true as const } : {}),
         ...(action.binding ? { binding: action.binding } : {}),
         ...(action.selectedStyle
           ? { selectedStyle: action.selectedStyle }
@@ -171,33 +181,75 @@ export function createTelegramButtonActionStore(
 const DEFAULT_TELEGRAM_BUTTON_REPLY_MARKDOWN =
   "☑️ **Choose an option:**";
 
+function escapeTelegramRichButtonText(text: string): string {
+  return text.replace(/[&<>"'`\\*_\[\]{}$~\r\n]/g, (character) =>
+    `&#${character.charCodeAt(0)};`,
+  );
+}
+
+function renderTelegramRichButtonRow(
+  row: TelegramOutboundButtonMarkup["inline_keyboard"][number],
+): string {
+  return `<tg-button-row>${row.map((button) => {
+    const attributes = button.disabled
+      ? 'type="disabled"'
+      : `type="callback_data" data="${escapeTelegramRichButtonText(button.callback_data)}"`;
+    return `<tg-button ${attributes}>${escapeTelegramRichButtonText(button.text)}</tg-button>`;
+  }).join("")}</tg-button-row>`;
+}
+
 export function planTelegramButtonReply(
   markdown: string,
   deps: {
     registerAction: (action: TelegramOutboundButtonAction) => string;
     binding?: TelegramOutboundButtonBinding;
+    rendering?: "rich" | "html";
   },
 ): TelegramButtonReplyPlan {
   const keyboard: TelegramOutboundButtonMarkup["inline_keyboard"] = [];
-  const stripped = replaceTopLevelHtmlComments(markdown, (comment) => {
+  const buildRows = (
+    payloadRows: Record<string, unknown>[][],
+    rich: boolean,
+  ): TelegramOutboundButtonMarkup["inline_keyboard"] | undefined => {
+    const actions = payloadRows.map((row) => row.map(parseTelegramButtonAction));
+    if (actions.some((row) => row.some((action) => !action))) return undefined;
+    if (rich && actions.some((row) => {
+      const projected = row.map((action) => action!.disabled
+        ? { text: action!.text || "\u00a0", disabled: {} }
+        : { text: action!.text, callback_data: "x".repeat(64) });
+      return row.length > 8 || renderTelegramRichButtonRow(projected).length > 32768;
+    })) return undefined;
+    return actions.map((row) => row.map((action) => action!.disabled
+      ? { text: action!.text || "\u00a0", disabled: {} }
+      : {
+          text: action!.text,
+          callback_data: deps.registerAction({
+            ...action!,
+            ...(deps.binding ? { binding: deps.binding } : {}),
+          }),
+        }));
+  };
+  const withRichButtons = replaceTelegramButtonFences(markdown, (payload, closed) => {
+    if (!closed) return "";
+    const payloadRows = parseTelegramButtonPayloadRows(payload);
+    if (!payloadRows) return "";
+    const rich = deps.rendering !== "html";
+    const rows = buildRows(payloadRows, rich);
+    if (!rows) return "";
+    if (!rich) {
+      keyboard.push(...rows);
+      return "";
+    }
+    return `\n${rows.map(renderTelegramRichButtonRow).join("\n\n")}\n`;
+  });
+  const stripped = replaceTopLevelHtmlComments(withRichButtons, (comment) => {
     const command = "telegram_button";
     const normalizedContent = comment.content.replace(/^\s+/, "").replace(/^!/, "");
     if (!normalizedContent.startsWith(command)) return comment.raw;
     const payloadRows = parseTelegramActionPayloadRows(comment, command);
     if (!payloadRows) return "";
-    const actionRows = payloadRows.map((payloadRow) =>
-      payloadRow.map(parseTelegramButtonAction),
-    );
-    if (actionRows.some((row) => row.some((action) => !action))) return "";
-    for (const actionRow of actionRows) {
-      keyboard.push(actionRow.map((action) => ({
-        text: action!.text,
-        callback_data: deps.registerAction({
-          ...action!,
-          ...(deps.binding ? { binding: deps.binding } : {}),
-        }),
-      })));
-    }
+    const rows = buildRows(payloadRows, false);
+    if (rows) keyboard.push(...rows);
     return "";
   });
   const visibleMarkdown = normalizeMarkdownAfterButtonExtraction(stripped);
@@ -254,7 +306,7 @@ export function markTelegramButtonSelected(
   let matched = false;
   const inlineKeyboard = replyMarkup.inline_keyboard.map((row) =>
     row.map((button) => {
-      if (button.callback_data !== callbackData) return { ...button };
+      if (button.disabled || button.callback_data !== callbackData) return { ...button };
       matched = true;
       return { ...button, style: selectedStyle };
     }),
@@ -277,6 +329,11 @@ export async function handleTelegramButtonCallbackQuery<TContext = unknown>(
     return false;
   }
 
+  if (action.disabled) {
+    await deps.answerCallbackQuery(query.id, "Button action unavailable.");
+    return true;
+  }
+
   const chatId = query.message?.chat?.id;
   const messageId = query.message?.message_id;
   if (typeof chatId !== "number" || typeof messageId !== "number") {

package/lib/outbound-markup.ts

@@ -90,6 +90,50 @@ export function collectTopLevelHtmlComments(markdown: string): {
   return { comments };
 }
 
+export function replaceTelegramButtonFences(
+  markdown: string,
+  replace: (payload: string, closed: boolean) => string,
+): string {
+  let result = "";
+  let copied = 0;
+  let offset = 0;
+  let fence: TelegramTopLevelFenceState | undefined;
+  let actionStart: number | undefined;
+  let contentStart = 0;
+  while (offset < markdown.length) {
+    const end = getMarkdownLineEnd(markdown, offset);
+    const line = getMarkdownLineText(markdown, offset, end);
+    if (fence) {
+      if (isTopLevelClosingFence(line, fence)) {
+        if (actionStart !== undefined) {
+          result += markdown.slice(copied, actionStart);
+          result += replace(markdown.slice(contentStart, offset), true) + "\n";
+          copied = end;
+          actionStart = undefined;
+        }
+        fence = undefined;
+      }
+    } else if (line.includes("<!--")) {
+      const close = markdown.indexOf("-->", offset + line.indexOf("<!--") + 4);
+      if (close < 0) break;
+      offset = getMarkdownLineEnd(markdown, close + 3);
+      continue;
+    } else {
+      fence = getTopLevelOpeningFence(line);
+      if (fence && /^```telegram_button[ \t]*$/.test(line)) {
+        actionStart = offset;
+        contentStart = end;
+      }
+    }
+    offset = end;
+  }
+  if (actionStart !== undefined) {
+    result += markdown.slice(copied, actionStart);
+    return result + replace(markdown.slice(contentStart), false);
+  }
+  return result + markdown.slice(copied);
+}
+
 export function replaceTopLevelHtmlComments(
   markdown: string,
   replacer: (comment: TelegramTopLevelHtmlComment) => string,
@@ -275,17 +319,26 @@ type TelegramCompactActionPayloadParser = (
 function parseTelegramButtonCompactActionPayload(
   atoms: readonly string[],
 ): Record<string, unknown> | undefined {
-  const [label, prompt, selectedStyle] = atoms;
+  const [label, prompt, selectedStyle, disabled] = atoms;
   if (atoms.length === 1) return label ? { value: label } : undefined;
-  if (!prompt) return undefined;
+  const isDisabled = disabled === "1" || disabled === "true";
+  if (!prompt && !(atoms.length === 4 && isDisabled)) return undefined;
   const action = label ? { label, prompt } : { prompt };
   if (atoms.length === 2) return action;
   if (
     selectedStyle !== "primary" &&
     selectedStyle !== "success" &&
-    selectedStyle !== "danger"
+    selectedStyle !== "danger" &&
+    !(atoms.length === 4 && selectedStyle === "")
   ) return undefined;
-  return { ...action, selected_style: selectedStyle };
+  if (atoms.length === 4 && !isDisabled && disabled !== "0" && disabled !== "false") {
+    return undefined;
+  }
+  return {
+    ...action,
+    ...(selectedStyle ? { selected_style: selectedStyle } : {}),
+    ...(atoms.length === 4 ? { disabled: isDisabled } : {}),
+  };
 }
 
 function parseTelegramVoiceCompactActionPayload(
@@ -303,7 +356,7 @@ function parseTelegramVoiceCompactActionPayload(
 function parseTelegramAdaptiveActionPayloadRows(
   source: string,
   parseCompactPayload: TelegramCompactActionPayloadParser,
-  options: { allowTrailing?: boolean } = {},
+  options: { allowTrailing?: boolean; maxCompactAtoms?: number } = {},
 ): { rows: Record<string, unknown>[][]; end: number } | undefined {
   let offset = 0;
   const isStructuralWhitespace = (character: string | undefined): boolean =>
@@ -343,7 +396,7 @@ function parseTelegramAdaptiveActionPayloadRows(
         continue;
       }
       if (character === "|") {
-        if (atomSources.length >= 3) return undefined;
+        if (atomSources.length >= (options.maxCompactAtoms ?? 3)) return undefined;
         atomSources.push([]);
         offset += 1;
         continue;
@@ -509,6 +562,16 @@ function isPlausibleTelegramMatrixStart(
   );
 }
 
+export function parseTelegramButtonPayloadRows(
+  source: string,
+): Record<string, unknown>[][] | undefined {
+  return parseTelegramAdaptiveActionPayloadRows(
+    source.trim(),
+    parseTelegramButtonCompactActionPayload,
+    { maxCompactAtoms: 4 },
+  )?.rows;
+}
+
 export function parseTelegramActionPayloadRows(
   comment: TelegramTopLevelHtmlComment,
   command: string,
@@ -533,7 +596,7 @@ export function parseTelegramActionPayloadRows(
     const parsed = parseTelegramAdaptiveActionPayloadRows(
       content.slice(offset),
       parseTelegramButtonCompactActionPayload,
-      { allowTrailing: true },
+      { allowTrailing: true, maxCompactAtoms: 4 },
     );
     if (parsed) return parsed.rows;
     const end = findTelegramStructuredPayloadEnd(content, offset);
@@ -546,8 +609,15 @@ export function parseTelegramActionPayloadRows(
     "prompt",
     "value",
     "selected_style",
+    "disabled",
   ]);
-  return attributes ? [[attributes]] : undefined;
+  if (!attributes) return undefined;
+  return [[{
+    ...attributes,
+    ...(attributes.disabled === "true" || attributes.disabled === "false"
+      ? { disabled: attributes.disabled === "true" }
+      : {}),
+  }]];
 }
 
 export function normalizeMarkdownAfterVoiceExtraction(
@@ -589,7 +659,9 @@ function stripTelegramHtmlCommentBlocks(markdown: string): string {
 }
 
 export function stripTelegramCommentMarkupForPreview(markdown: string): string {
-  const withoutClosedBlocks = stripTelegramHtmlCommentBlocks(markdown);
+  const withoutClosedBlocks = stripTelegramHtmlCommentBlocks(
+    replaceTelegramButtonFences(markdown, () => ""),
+  );
   const openBlockIndex =
     findTopLevelOpenOrPartialHtmlCommentIndex(withoutClosedBlocks);
   const previewMarkdown =

package/lib/outbound.ts

@@ -835,6 +835,7 @@ export {
 
 export function createTelegramOutboundReplyPlanner(
   store: Pick<TelegramButtonActionStore, "register">,
+  getRenderingMode: () => "rich" | "html" = () => "rich",
 ): (
   markdown: string,
   options?: { binding?: TelegramOutboundButtonBinding },
@@ -842,6 +843,7 @@ export function createTelegramOutboundReplyPlanner(
   return (markdown, options) => {
     const buttonReply = planTelegramButtonReply(markdown, {
       registerAction: store.register,
+      rendering: getRenderingMode(),
       ...(options?.binding ? { binding: options.binding } : {}),
     });
 

package/lib/replies.ts

@@ -532,7 +532,7 @@ function splitTelegramNativeMarkdownCountedBlocks(block: string): string[] {
 function countTelegramNativeMarkdownBlocks(block: string): number {
   if (/^ {0,3}(`{3,}|~{3,})/.test(block)) return 1;
   const lines = block.split("\n").filter((line) => line.trim().length > 0);
-  if (lines.some((line) => /^\s*([-*+] |\d+\. |>|\|)/.test(line))) {
+  if (lines.some((line) => /^\s*([-*+] |\d+\. |>|\||<tg-button-row>)/.test(line))) {
     return Math.max(1, lines.length);
   }
   return 1;

package/lib/routing.ts

@@ -281,19 +281,17 @@ function formatTelegramAllTabMenuChooserText(command: string): string {
     "",
     `You used <code>/${escapeHtml(command)}</code> from the <b>All</b> tab.`,
     "Select the Pi thread that should handle it:",
+    "To restore into a new thread, send a plain message in that destination thread first.",
   ].join("\n");
 }
 
 function buildTelegramUnboundRerouteChooserMarkup(
   rerouteId: string,
   records: readonly Threads.TelegramTopicTargetRecord[],
-  _options: {
-    currentLeaderProfileKey?: string;
-    currentInstanceId?: string;
-  } = {},
+  options: { canRestore: boolean },
 ): Menu.TelegramReplyMarkup {
   const activeRecords = records.filter((record) => record.status === "active");
-  const canRestoreAnyLiveThread = activeRecords.length > 0;
+  const canRestoreAnyLiveThread = options.canRestore && activeRecords.length > 0;
   const rows = activeRecords.map((record) => [
     {
       text: getTelegramRouteThreadButtonLabel(record),
@@ -433,6 +431,7 @@ async function deleteReservedTelegramTopicThroughReconciler(
   });
   deps.recordThreadReconciliationPlan?.(plan);
   await ThreadReconciler.applyThreadReconciliationPlan(plan, {
+    isCleanupTargetProtected: Threads.createTelegramCleanupTargetProtection(deps.threadStore),
     callApi: deps.callApi,
     markStaleByTarget: (staleTarget, syncStatus, lastSyncError) =>
       deps.threadStore?.markStaleByTarget(
@@ -734,6 +733,8 @@ export function createTelegramInboundRouteRuntime<
         instanceId?: string;
       };
   type PendingUnboundReroute = {
+    sourceTarget: Queue.TelegramQueueTarget;
+    chooserMessageId?: number;
     messages: TMessage[];
     createdAtMs: number;
     dispatchKind: "prompt" | "command";
@@ -842,12 +843,33 @@ export function createTelegramInboundRouteRuntime<
     nextUnboundRerouteId += 1;
     const id = nextUnboundRerouteId.toString(36);
     pendingUnboundReroutes.set(id, {
+      sourceTarget: {
+        chatId: messages[0]!.chat.id,
+        ...(typeof messages[0]!.message_thread_id === "number"
+          ? { threadId: messages[0]!.message_thread_id }
+          : {}),
+      },
       messages,
       createdAtMs: Date.now(),
       dispatchKind,
     });
     return id;
   };
+  const rememberRerouteChooser = (id: string, messageId: number | undefined): void => {
+    const pending = pendingUnboundReroutes.get(id);
+    if (pending) pending.chooserMessageId = messageId;
+  };
+  const matchesRerouteChooser = (
+    pending: PendingUnboundReroute,
+    query: TCallbackQuery,
+  ): boolean => {
+    const message = query.message;
+    return !!message && pending.chooserMessageId !== undefined &&
+      message.message_id === pending.chooserMessageId &&
+      message.chat.id === pending.sourceTarget.chatId &&
+      (message.message_thread_id === undefined ||
+        message.message_thread_id === pending.sourceTarget.threadId);
+  };
   const pendingUnboundRerouteMediaGroups = new Map<
     string,
     {
@@ -951,6 +973,10 @@ export function createTelegramInboundRouteRuntime<
     assertExecutionCurrent?.();
     deps.recordThreadReconciliationPlan?.(plan);
     const result = await ThreadReconciler.applyThreadReconciliationPlan(plan, {
+      isCleanupTargetProtected(target) {
+        assertExecutionCurrent?.();
+        return isRerouteTargetProtected(target);
+      },
       callApi: deps.callApi,
       markStaleByTarget: (staleTarget, syncStatus, lastSyncError) =>
         deps.threadStore?.markStaleByTarget(
@@ -967,6 +993,14 @@ export function createTelegramInboundRouteRuntime<
     assertExecutionCurrent?.();
     return (result.incompleteActions?.length ?? 0) === 0;
   };
+  const isRerouteTargetProtected = (target: Queue.TelegramQueueTarget): boolean => {
+    const matches = (candidate: Queue.TelegramQueueTarget): boolean =>
+      candidate.chatId === target.chatId && candidate.threadId === target.threadId;
+    return (deps.getLiveThreadTargets?.() ?? []).some(matches) ||
+      (deps.threadStore?.list() ?? []).some((record) => matches(record.target)) ||
+      (deps.threadStore?.listReservations() ?? []).some((record) => matches(record.target)) ||
+      (deps.threadStore?.listPendingProvisions() ?? []).some((record) => !!record.target && matches(record.target));
+  };
   const dismissRerouteChooserMessage = async (
     query: TCallbackQuery,
     assertExecutionCurrent?: () => void,
@@ -986,6 +1020,7 @@ export function createTelegramInboundRouteRuntime<
       assertExecutionCurrent?.();
       return true;
     } catch (error) {
+      assertExecutionCurrent?.();
       deps.recordRuntimeEvent?.("telegram", error, {
         phase: "reroute-chooser-delete",
         chatId,
@@ -1103,12 +1138,14 @@ export function createTelegramInboundRouteRuntime<
     pending: PendingUnboundReroute,
     query: TCallbackQuery,
     successMessage: string,
-    assertExecutionCurrent?: () => void,
+    assertExecutionCurrent = Updates.createTelegramUpdateExecutionFenceGuard(query),
   ): Promise<void> => {
+    assertExecutionCurrent();
     const dismissed = await dismissRerouteChooserMessage(
       query,
       assertExecutionCurrent,
     );
+    assertExecutionCurrent();
     if (dismissed) {
       pendingUnboundReroutes.delete(rerouteId);
       await deps.answerCallbackQuery(query.id, successMessage);
@@ -1169,6 +1206,8 @@ export function createTelegramInboundRouteRuntime<
       query.data,
     );
     if (!parsed) return false;
+    const assertExecutionCurrent = Updates.createTelegramUpdateExecutionFenceGuard(query);
+    assertExecutionCurrent();
     const chatId = query.message?.chat?.id;
     const messageId = query.message?.message_id;
     const pending = pendingUnboundReroutes.get(parsed.rerouteId);
@@ -1176,12 +1215,18 @@ export function createTelegramInboundRouteRuntime<
       typeof chatId !== "number" ||
       typeof messageId !== "number" ||
       !deps.threadStore ||
-      !pending
+      !pending ||
+      !matchesRerouteChooser(pending, query)
     ) {
       await deps.answerCallbackQuery(query.id, "Message route expired.");
       return true;
     }
+    if (pending.sourceTarget.threadId === undefined) {
+      await deps.answerCallbackQuery(query.id, "Restore needs a destination thread. Send a plain message in a new Telegram thread first.");
+      return true;
+    }
     await deps.threadStore.load();
+    assertExecutionCurrent();
     const activeRecords = getTelegramRoutableThreadRecords(
       deps.threadStore.list(),
       deps.getLiveThreadTargets?.(),
@@ -1199,19 +1244,17 @@ export function createTelegramInboundRouteRuntime<
         replyMarkup,
       );
     } else if (deps.sendInteractiveMessage) {
-      await deps.sendInteractiveMessage(
+      const chooserId = await deps.sendInteractiveMessage(
         chatId,
         formatTelegramUnboundRerouteRestoreChooserText(),
         "html",
         replyMarkup,
-        typeof query.message?.message_thread_id === "number"
-          ? {
-              target: { chatId, threadId: query.message.message_thread_id },
-              replyToMessageId: messageId,
-            }
-          : undefined,
+        { target: pending.sourceTarget, replyToMessageId: messageId },
       );
+      assertExecutionCurrent();
+      rememberRerouteChooser(parsed.rerouteId, chooserId);
     }
+    assertExecutionCurrent();
     await deps.answerCallbackQuery(query.id, "Choose instance to restore.");
     return true;
   };
@@ -1226,7 +1269,8 @@ export function createTelegramInboundRouteRuntime<
     assertExecutionCurrent();
     const chatId = query.message?.chat?.id;
     const pending = pendingUnboundReroutes.get(parsed.rerouteId);
-    if (typeof chatId !== "number" || !deps.threadStore || !pending) {
+    if (typeof chatId !== "number" || !deps.threadStore || !pending ||
+      !matchesRerouteChooser(pending, query)) {
       await deps.answerCallbackQuery(query.id, "Message route expired.");
       return true;
     }
@@ -1300,10 +1344,23 @@ export function createTelegramInboundRouteRuntime<
       parsed.threadId,
     );
     const sourceTarget =
-      typeof query.message?.message_thread_id === "number"
-        ? { chatId, threadId: query.message.message_thread_id }
+      typeof pending.sourceTarget.threadId === "number"
+        ? { chatId, threadId: pending.sourceTarget.threadId }
         : undefined;
-    const sourceMessageId = query.message?.message_id;
+    const sourceMessageId = pending.chooserMessageId;
+    if (parsed.useNewSlot && !sourceTarget) {
+      await deps.answerCallbackQuery(query.id, "Restore needs a destination thread. Send a plain message in a new Telegram thread first.");
+      return true;
+    }
+    if (parsed.useNewSlot && sourceTarget && record.target.chatId === sourceTarget.chatId &&
+      record.target.threadId === sourceTarget.threadId) {
+      await deps.answerCallbackQuery(query.id, "🚫 Selected thread is already the destination.");
+      return true;
+    }
+    if (parsed.useNewSlot && sourceTarget && isRerouteTargetProtected(sourceTarget)) {
+      await deps.answerCallbackQuery(query.id, "🚫 Thread restore source is already owned.");
+      return true;
+    }
     const currentInstanceId = deps.getCurrentInstanceId?.();
     const leaderProfileKey = getLeaderTopicProfileKey(ctx, currentInstanceId);
     const isCurrentLeaderRecord = isCurrentLeaderTopicRecord(
@@ -1507,6 +1564,7 @@ export function createTelegramInboundRouteRuntime<
         rerouteConfirmedAtMs: nowMs,
       });
       await deps.threadStore.persist();
+      assertExecutionCurrent();
       deps.setCurrentLeaderIdentity?.({
         target: sourceTarget,
         slot,
@@ -1944,7 +2002,7 @@ export function createTelegramInboundRouteRuntime<
   };
   const sendUnboundRerouteChooserNow = async (
     messages: TMessage[],
-    ctx: TContext,
+    _ctx: TContext,
     reportDeferred = true,
   ): Promise<void> => {
     const message = messages[0];
@@ -1988,20 +2046,13 @@ export function createTelegramInboundRouteRuntime<
     const text = formatTelegramUnboundRerouteChooserText(activeRecords, {
       includeGuidance,
     });
-    const currentInstanceId = deps.getCurrentInstanceId?.();
     const replyMarkup = buildTelegramUnboundRerouteChooserMarkup(
       rerouteId,
       activeRecords,
-      {
-        currentLeaderProfileKey: getLeaderTopicProfileKey(
-          ctx,
-          currentInstanceId,
-        ),
-        currentInstanceId,
-      },
+      { canRestore: sourceTarget !== undefined },
     );
     if (deps.sendInteractiveMessage) {
-      await deps.sendInteractiveMessage(
+      const chooserId = await deps.sendInteractiveMessage(
         message.chat.id,
         text,
         "html",
@@ -2010,12 +2061,14 @@ export function createTelegramInboundRouteRuntime<
           ? { target: sourceTarget, replyToMessageId: message.message_id }
           : { replyToMessageId: message.message_id },
       );
+      rememberRerouteChooser(rerouteId, chooserId);
       return;
     }
-    await deps.sendTextReply(message.chat.id, message.message_id, text, {
+    const chooserId = await deps.sendTextReply(message.chat.id, message.message_id, text, {
       parseMode: "HTML",
       target: sourceTarget,
     });
+    rememberRerouteChooser(rerouteId, chooserId);
   };
   const sendUnboundRerouteChooser = async (
     message: TMessage,
@@ -2080,9 +2133,10 @@ export function createTelegramInboundRouteRuntime<
     const replyMarkup = buildTelegramUnboundRerouteChooserMarkup(
       rerouteId,
       activeRecords,
+      { canRestore: typeof message.message_thread_id === "number" },
     );
     if (deps.sendInteractiveMessage) {
-      await deps.sendInteractiveMessage(
+      const chooserId = await deps.sendInteractiveMessage(
         message.chat.id,
         text,
         "html",
@@ -2096,10 +2150,11 @@ export function createTelegramInboundRouteRuntime<
             }
           : undefined,
       );
+      rememberRerouteChooser(rerouteId, chooserId);
       return true;
     }
     if (deps.callApi) {
-      await deps.callApi("sendMessage", {
+      const chooser = await deps.callApi<{ message_id?: number }>("sendMessage", {
         chat_id: message.chat.id,
         text,
         parse_mode: "HTML",
@@ -2116,12 +2171,14 @@ export function createTelegramInboundRouteRuntime<
             }
           : {}),
       });
+      rememberRerouteChooser(rerouteId, chooser?.message_id);
       return true;
     }
-    await deps.sendTextReply(message.chat.id, message.message_id, text, {
+    const chooserId = await deps.sendTextReply(message.chat.id, message.message_id, text, {
       parseMode: "HTML",
       target: options.target,
     });
+    rememberRerouteChooser(rerouteId, chooserId);
     return true;
   };
   const commandOrPrompt = Commands.createTelegramCommandOrPromptRuntime<