@llblab/pi-telegram 0.17.4 → 0.18.0

package/lib/routing.ts

@@ -17,11 +17,377 @@ import * as PromptTemplates from "./prompt-templates.ts";
 import * as Queue from "./queue.ts";
 import type { TelegramBridgeRuntime } from "./runtime.ts";
 import * as TextGroups from "./text-groups.ts";
+import * as ThreadReconciler from "./thread-reconciler.ts";
 import * as Turns from "./turns.ts";
+
+function getContextCwd(ctx: unknown): string | undefined {
+  if (!ctx || typeof ctx !== "object") return undefined;
+  const cwd = (ctx as { cwd?: unknown }).cwd;
+  return typeof cwd === "string" && cwd.length > 0 ? cwd : undefined;
+}
+
+function getLeaderTopicProfileKey(
+  ctx: unknown,
+  instanceId: string | undefined,
+): string | undefined {
+  const cwd = getContextCwd(ctx);
+  if (cwd) return `cwd:${cwd}`;
+  return instanceId ? `leader:${instanceId}` : undefined;
+}
+
+function isCurrentLeaderTopicRecord(
+  record: Threads.TelegramTopicTargetRecord,
+  profileKey: string | undefined,
+  instanceId: string | undefined,
+): boolean {
+  if (instanceId && record.instanceId === instanceId) return true;
+  return !!profileKey && record.profileKey === profileKey;
+}
+
+function hasActiveLeaderTopic(
+  records: Threads.TelegramTopicTargetRecord[],
+  profileKey: string | undefined,
+  instanceId: string | undefined,
+): boolean {
+  return records.some((record) => {
+    if (record.status !== "active") return false;
+    return isCurrentLeaderTopicRecord(record, profileKey, instanceId);
+  });
+}
+
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+interface TelegramAllTabPendingCommand {
+  command: Commands.ParsedTelegramCommand;
+  text: string;
+  createdAtMs: number;
+}
+
+const TELEGRAM_ALL_TAB_MENU_CALLBACK_PREFIX = "allmenu:";
+const TELEGRAM_UNBOUND_REROUTE_CALLBACK_PREFIX = "reroute:";
+const TELEGRAM_UNBOUND_REROUTE_RESTORE_MENU_CALLBACK_PREFIX = "rerouterestore:";
+const TELEGRAM_UNBOUND_REROUTE_NEW_SLOT_CALLBACK_PREFIX = "reroutenew:";
+
+function formatTelegramAllTabMenuCallbackData(
+  commandId: string,
+  threadId: number,
+): string {
+  return `${TELEGRAM_ALL_TAB_MENU_CALLBACK_PREFIX}${commandId}:${threadId}`;
+}
+
+function parseTelegramAllTabMenuCallbackData(
+  data: string | undefined,
+): { commandId: string; threadId: number } | undefined {
+  const match = data?.match(/^allmenu:([a-z0-9]+):(\d+)$/);
+  const commandId = match?.[1];
+  const threadId = Number(match?.[2]);
+  if (!commandId || !Number.isSafeInteger(threadId)) return undefined;
+  return { commandId, threadId };
+}
+
+function formatTelegramUnboundRerouteCallbackData(
+  rerouteId: string,
+  threadId: number,
+): string {
+  return `${TELEGRAM_UNBOUND_REROUTE_CALLBACK_PREFIX}${rerouteId}:${threadId}`;
+}
+
+function formatTelegramUnboundRerouteRestoreMenuCallbackData(
+  rerouteId: string,
+): string {
+  return `${TELEGRAM_UNBOUND_REROUTE_RESTORE_MENU_CALLBACK_PREFIX}${rerouteId}`;
+}
+
+function formatTelegramUnboundRerouteNewSlotCallbackData(
+  rerouteId: string,
+  threadId: number,
+): string {
+  return `${TELEGRAM_UNBOUND_REROUTE_NEW_SLOT_CALLBACK_PREFIX}${rerouteId}:${threadId}`;
+}
+
+function parseTelegramUnboundRerouteRestoreMenuCallbackData(
+  data: string | undefined,
+): { rerouteId: string } | undefined {
+  const match = data?.match(/^rerouterestore:([a-z0-9]+)$/);
+  const rerouteId = match?.[1];
+  return rerouteId ? { rerouteId } : undefined;
+}
+
+function parseTelegramUnboundRerouteCallbackData(
+  data: string | undefined,
+): { rerouteId: string; threadId: number; useNewSlot: boolean } | undefined {
+  const match = data?.match(/^(reroute|reroutenew):([a-z0-9]+):(\d+)$/);
+  const prefix = match?.[1];
+  const rerouteId = match?.[2];
+  const threadId = Number(match?.[3]);
+  if (!prefix || !rerouteId || !Number.isSafeInteger(threadId))
+    return undefined;
+  return { rerouteId, threadId, useNewSlot: prefix === "reroutenew" };
+}
+
+function getTelegramThreadRecordLabel(
+  record: Threads.TelegramTopicTargetRecord,
+): string {
+  return getRestoredThreadName(record, record.slot ?? "");
+}
+
+function getTelegramRouteThreadButtonLabel(
+  record: Threads.TelegramTopicTargetRecord,
+): string {
+  return `↪️ ${getTelegramThreadRecordLabel(record)}`;
+}
+
+function getTelegramReplaceThreadButtonLabel(
+  record: Threads.TelegramTopicTargetRecord,
+): string {
+  return `➡️ ${getTelegramThreadRecordLabel(record)}`;
+}
+
+function getNextTelegramSlotPreference(
+  slot: string | undefined,
+): string | undefined {
+  if (!slot || !/^[A-Z]$/.test(slot)) return undefined;
+  const index = slot.charCodeAt(0) - "A".charCodeAt(0);
+  return String.fromCharCode("A".charCodeAt(0) + ((index + 1) % 26));
+}
+
+function getRestoredThreadName(
+  record: Threads.TelegramTopicTargetRecord,
+  slot: string,
+): string {
+  return record.threadName &&
+    Threads.isTelegramTopicThreadNameValidForSlot(record.threadName, slot)
+    ? record.threadName
+    : (Threads.chooseTelegramThreadName({ slot }) ?? "Pi");
+}
+
+function isTelegramLiveThreadTarget(
+  record: Threads.TelegramTopicTargetRecord,
+  liveTargets: readonly Queue.TelegramQueueTarget[] | undefined,
+): boolean {
+  if (!liveTargets) return record.status === "active";
+  return liveTargets.some(
+    (target) =>
+      target.chatId === record.target.chatId &&
+      target.threadId === record.target.threadId,
+  );
+}
+
+function getTelegramRoutableThreadRecords(
+  records: readonly Threads.TelegramTopicTargetRecord[],
+  liveTargets: readonly Queue.TelegramQueueTarget[] | undefined,
+): Threads.TelegramTopicTargetRecord[] {
+  return records.filter(
+    (record) =>
+      record.status === "active" &&
+      isTelegramLiveThreadTarget(record, liveTargets),
+  );
+}
+
+function buildTelegramAllTabMenuChooserMarkup(
+  commandId: string,
+  records: readonly Threads.TelegramTopicTargetRecord[],
+): Menu.TelegramReplyMarkup {
+  const rows = records.map((record) => [
+    {
+      text: getTelegramRouteThreadButtonLabel(record),
+      callback_data: formatTelegramAllTabMenuCallbackData(
+        commandId,
+        record.target.threadId,
+      ),
+    },
+  ]);
+  return { inline_keyboard: rows };
+}
+
+function formatTelegramAllTabMenuChooserText(command: string): string {
+  return [
+    "<b>🧵 Choose target thread</b>",
+    "",
+    `You used <code>/${escapeHtml(command)}</code> from the <b>All</b> tab.`,
+    "Select the Pi thread that should handle it:",
+  ].join("\n");
+}
+
+function buildTelegramUnboundRerouteChooserMarkup(
+  rerouteId: string,
+  records: readonly Threads.TelegramTopicTargetRecord[],
+  options: {
+    currentLeaderProfileKey?: string;
+    currentInstanceId?: string;
+  } = {},
+): Menu.TelegramReplyMarkup {
+  const activeRecords = records.filter((record) => record.status === "active");
+  const canRestoreCurrentLeader = activeRecords.some(
+    (record) =>
+      typeof record.rerouteConfirmedAtMs === "number" &&
+      isCurrentLeaderTopicRecord(
+        record,
+        options.currentLeaderProfileKey,
+        options.currentInstanceId,
+      ),
+  );
+  const rows = activeRecords.map((record) => [
+    {
+      text: getTelegramRouteThreadButtonLabel(record),
+      callback_data: formatTelegramUnboundRerouteCallbackData(
+        rerouteId,
+        record.target.threadId,
+      ),
+    },
+  ]);
+  return {
+    inline_keyboard: canRestoreCurrentLeader
+      ? [
+          ...rows,
+          [
+            {
+              text: "🔁 Replace/restore thread…",
+              callback_data:
+                formatTelegramUnboundRerouteRestoreMenuCallbackData(rerouteId),
+            },
+          ],
+        ]
+      : rows,
+  };
+}
+
+function buildTelegramUnboundRerouteRestoreChooserMarkup(
+  rerouteId: string,
+  records: readonly Threads.TelegramTopicTargetRecord[],
+): Menu.TelegramReplyMarkup {
+  return {
+    inline_keyboard: records
+      .filter((record) => record.status === "active")
+      .map((record) => [
+        {
+          text: getTelegramReplaceThreadButtonLabel(record),
+          callback_data: formatTelegramUnboundRerouteNewSlotCallbackData(
+            rerouteId,
+            record.target.threadId,
+          ),
+        },
+      ]),
+  };
+}
+
+function formatTelegramUnboundRerouteRestoreChooserText(): string {
+  return [
+    "<b>🧵 Replace/restore Telegram thread</b>",
+    "",
+    "Choose the Pi instance to move to this new Telegram thread:",
+  ].join("\n");
+}
+
+function formatTelegramUnboundTopicGuidance(): string {
+  return [
+    "⚠️ <b>New thread is not a Pi instance</b>",
+    "",
+    "To create a bound Telegram tab:",
+    "<code>1.</code> Start another Pi instance in your terminal.",
+    "<code>2.</code> Run <code>/telegram-connect</code> in that instance.",
+    "<code>3.</code> The bridge will create and bind a fresh Telegram tab for it.",
+  ].join("\n");
+}
+
+function formatTelegramTargetKey(target: Queue.TelegramQueueTarget): string {
+  return `${target.chatId}:${target.threadId ?? "all"}`;
+}
+
+function formatTelegramUnboundRerouteChooserText(
+  _records: readonly Threads.TelegramTopicTargetRecord[],
+  options: { includeGuidance?: boolean } = {},
+): string {
+  const rerouteText = [
+    "🧵 <b>Choose target thread</b>",
+    "",
+    "Your message is still in this Telegram thread.",
+    "Select the Pi thread that should handle it:",
+  ].join("\n");
+  return options.includeGuidance === false
+    ? rerouteText
+    : [formatTelegramUnboundTopicGuidance(), "", rerouteText].join("\n");
+}
+
 import { getTelegramVoiceReplyMode } from "./voice.ts";
 import type { TelegramUser } from "./updates.ts";
+import * as Threads from "./threads.ts";
 import * as Updates from "./updates.ts";
 
+async function deleteReservedTelegramTopicThroughReconciler(
+  deps: {
+    callApi?: <TResponse>(
+      method: string,
+      body: Record<string, unknown>,
+    ) => Promise<TResponse>;
+    threadStore?: Pick<
+      Threads.TelegramTopicTargetStore,
+      | "list"
+      | "listReservations"
+      | "listSyncObservations"
+      | "markStaleByTarget"
+      | "persist"
+    >;
+    getCurrentLeaderEpoch?: () => number | string | undefined;
+    getThreadReconciliationMachineState?: () =>
+      | ThreadReconciler.ThreadReconciliationMachineState
+      | undefined;
+    recordThreadReconciliationPlan?: (
+      plan: ThreadReconciler.ThreadReconciliationPlan,
+    ) => void;
+    recordRuntimeEvent?: (
+      category: string,
+      error: unknown,
+      details?: Record<string, unknown>,
+    ) => void;
+  },
+  target: { chatId: number; threadId: number },
+  messageId: number,
+): Promise<boolean> {
+  if (!deps.threadStore) return false;
+  const nowMs = Date.now();
+  const currentLeaderEpoch = deps.getCurrentLeaderEpoch?.();
+  const plan = ThreadReconciler.planThreadReconciliation({
+    nowMs,
+    currentLeaderEpoch,
+    previousState: deps.getThreadReconciliationMachineState?.(),
+    records: deps.threadStore.list(),
+    reservations: deps.threadStore.listReservations(),
+    observations: deps.threadStore.listSyncObservations(),
+    reservedMessages: [
+      {
+        target,
+        observedAtMs: nowMs,
+        messageId,
+        ...(currentLeaderEpoch !== undefined
+          ? { leaderEpoch: currentLeaderEpoch }
+          : {}),
+      },
+    ],
+  });
+  deps.recordThreadReconciliationPlan?.(plan);
+  await ThreadReconciler.applyThreadReconciliationPlan(plan, {
+    callApi: deps.callApi,
+    markStaleByTarget: (staleTarget, syncStatus, lastSyncError) =>
+      deps.threadStore?.markStaleByTarget(
+        staleTarget,
+        syncStatus,
+        lastSyncError,
+      ) ?? false,
+    persist: () => deps.threadStore?.persist() ?? Promise.resolve(),
+    getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
+    recordRuntimeEvent: deps.recordRuntimeEvent,
+  });
+  return plan.actions.some(
+    (action) => action.kind === "close-delete-reserved-topic",
+  );
+}
+
 export type TelegramRoutedMessage = Updates.TelegramUpdateMessage &
   Media.TelegramMediaMessage &
   Media.TelegramMediaGroupMessage &
@@ -40,7 +406,41 @@ export interface TelegramInboundRouteRuntimeDeps<
   configStore: Pick<
     TelegramConfigStore,
     "get" | "getAllowedUserId" | "setAllowedUserId" | "persist"
+  > & { set?: TelegramConfigStore["set"] };
+  callApi?: <TResponse>(
+    method: string,
+    body: Record<string, unknown>,
+  ) => Promise<TResponse>;
+  getCurrentInstanceId?: () => string | undefined;
+  getMessageOwnership?: Updates.TelegramMessageOwnershipLookup;
+  getTargetOwnership?: Updates.TelegramTargetOwnershipLookup;
+  getLiveThreadTargets?: () => Queue.TelegramQueueTarget[];
+  getCurrentLeaderEpoch?: () => number | string | undefined;
+  getThreadReconciliationMachineState?: () =>
+    | ThreadReconciler.ThreadReconciliationMachineState
+    | undefined;
+  recordThreadReconciliationPlan?: (
+    plan: ThreadReconciler.ThreadReconciliationPlan,
+  ) => void;
+  handleTelegramTopicLifecycleUpdate?: (
+    lifecycle: Updates.TelegramTopicLifecycleUpdate<TMessage>,
+    ctx: TContext,
+  ) => Promise<void> | void;
+  handleTelegramThreadTargetObserved?: (
+    target: Threads.TelegramTopicTargetRecord["target"],
+    ctx: TContext,
+  ) => Promise<void> | void;
+  foreignOwnedUpdateForwarder?: Updates.TelegramForeignOwnedUpdateForwarder<
+    TContext,
+    Updates.TelegramMessageReactionUpdated,
+    TCallbackQuery,
+    TMessage
   >;
+  replaceFollowerThreadTarget?: (input: {
+    record: Threads.TelegramTopicTargetRecord;
+    target: Threads.TelegramTopicTargetRecord["target"];
+    oldTarget: Threads.TelegramTopicTargetRecord["target"];
+  }) => Promise<boolean>;
   bridgeRuntime: TelegramBridgeRuntime;
   activeTurnRuntime: Queue.TelegramActiveTurnStore;
   mediaGroupRuntime: Media.TelegramMediaGroupController<TMessage, TContext>;
@@ -78,12 +478,17 @@ export interface TelegramInboundRouteRuntimeDeps<
   ) => Promise<boolean>;
   buttonActionStore?: OutboundHandlers.TelegramButtonActionStore;
   inboundHandlerRuntime: TelegramInboundHandlerRuntime<TContext>;
+  threadStore?: Threads.TelegramTopicTargetStore;
   updateStatus: (ctx: TContext, error?: string) => void;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
-  startTypingLoop?: (ctx: TContext, chatId?: number) => void;
+  startTypingLoop?: (
+    ctx: TContext,
+    chatId?: number,
+    options?: { target?: { chatId: number; threadId?: number } },
+  ) => void;
   stopTypingLoop?: () => void;
   answerCallbackQuery: (
     callbackQueryId: string,
@@ -101,6 +506,7 @@ export interface TelegramInboundRouteRuntimeDeps<
     text: string,
     mode: "markdown" | "html" | "plain",
     replyMarkup: Menu.TelegramReplyMarkup,
+    options?: { target?: Queue.TelegramQueueTarget; replyToMessageId?: number },
   ) => Promise<number | undefined>;
   deleteMessage?: (chatId: number, messageId: number) => Promise<void>;
   answerGuestQuery: (guestQueryId: string, text?: string) => Promise<void>;
@@ -108,6 +514,7 @@ export interface TelegramInboundRouteRuntimeDeps<
     chatId: number,
     replyToMessageId: number,
     text: string,
+    options?: { parseMode?: "HTML"; target?: Queue.TelegramQueueTarget },
   ) => Promise<number | undefined>;
   setMyCommands: Commands.TelegramBotCommandRegistrationDeps["setMyCommands"];
   getCommands: () => Parameters<
@@ -141,6 +548,8 @@ export interface TelegramInboundRouteRuntimeDeps<
 }
 
 const TELEGRAM_OWNED_CALLBACK_PREFIXES = [
+  TELEGRAM_ALL_TAB_MENU_CALLBACK_PREFIX,
+  TELEGRAM_UNBOUND_REROUTE_CALLBACK_PREFIX,
   "compact:",
   "menu:",
   "model:",
@@ -176,6 +585,74 @@ export function createTelegramInboundRouteRuntime<
     TModel
   >,
 ): Updates.TelegramUpdateRuntimeController<TContext, TUpdate> {
+  const pendingUnboundReroutes = new Map<
+    string,
+    { messages: TMessage[]; createdAtMs: number }
+  >();
+  const pendingAllTabCommands = new Map<string, TelegramAllTabPendingCommand>();
+  const guidedUnboundTopicKeys = new Set<string>();
+  let nextUnboundRerouteId = 0;
+  let nextAllTabCommandId = 0;
+  const prunePendingUnboundReroutes = () => {
+    const nowMs = Date.now();
+    for (const [id, entry] of pendingUnboundReroutes) {
+      if (nowMs - entry.createdAtMs > 30 * 60_000) {
+        pendingUnboundReroutes.delete(id);
+      }
+    }
+    while (pendingUnboundReroutes.size > 100) {
+      const oldest = pendingUnboundReroutes.keys().next().value;
+      if (!oldest) break;
+      pendingUnboundReroutes.delete(oldest);
+    }
+  };
+  const storePendingUnboundReroute = (messages: TMessage[]): string => {
+    prunePendingUnboundReroutes();
+    nextUnboundRerouteId += 1;
+    const id = nextUnboundRerouteId.toString(36);
+    pendingUnboundReroutes.set(id, { messages, createdAtMs: Date.now() });
+    return id;
+  };
+  const pendingUnboundRerouteMediaGroups = new Map<
+    string,
+    {
+      messages: TMessage[];
+      timer: ReturnType<typeof setTimeout>;
+    }
+  >();
+  const prunePendingAllTabCommands = () => {
+    const nowMs = Date.now();
+    for (const [id, entry] of pendingAllTabCommands) {
+      if (nowMs - entry.createdAtMs > 30 * 60_000) {
+        pendingAllTabCommands.delete(id);
+      }
+    }
+    while (pendingAllTabCommands.size > 100) {
+      const oldest = pendingAllTabCommands.keys().next().value;
+      if (!oldest) break;
+      pendingAllTabCommands.delete(oldest);
+    }
+  };
+  const storePendingAllTabCommand = (
+    command: Commands.ParsedTelegramCommand,
+    text: string,
+  ): string => {
+    prunePendingAllTabCommands();
+    const bareCommandText = `/${command.name}`;
+    const id = text.trim() === bareCommandText ? command.name : undefined;
+    if (id) {
+      pendingAllTabCommands.set(id, { command, text, createdAtMs: Date.now() });
+      return id;
+    }
+    nextAllTabCommandId += 1;
+    const generatedId = nextAllTabCommandId.toString(36);
+    pendingAllTabCommands.set(generatedId, {
+      command,
+      text,
+      createdAtMs: Date.now(),
+    });
+    return generatedId;
+  };
   const menuCallbackHandler = Menu.createTelegramMenuCallbackHandlerForContext<
     TCallbackQuery,
     TContext,
@@ -206,13 +683,18 @@ export function createTelegramInboundRouteRuntime<
     editInteractiveMessage: deps.editInteractiveMessage,
     sendInteractiveMessage: deps.sendInteractiveMessage,
     deleteMessage: deps.deleteMessage,
-    enqueueSectionPrompt: async (prompt: string, ctx: TContext) => {
-      const chatId = deps.configStore.getAllowedUserId();
+    enqueueSectionPrompt: async (
+      prompt: string,
+      ctx: TContext,
+      target?: Queue.TelegramQueueTarget,
+    ) => {
+      const chatId = target?.chatId ?? deps.configStore.getAllowedUserId();
       if (typeof chatId !== "number") return;
       const order = deps.bridgeRuntime.queue.allocateItemOrder();
       const turn: Queue.PendingTelegramTurn = {
         kind: "prompt",
         chatId,
+        ...(target ? { target } : {}),
         replyToMessageId: 0,
         sourceMessageIds: [],
         queueOrder: order,
@@ -233,10 +715,518 @@ export function createTelegramInboundRouteRuntime<
       deps.dispatchNextQueuedTelegramTurn(ctx);
     },
   });
+  const cloneTelegramMessagesForThread = (
+    messages: TMessage[],
+    threadId: number,
+  ): TMessage[] => {
+    return messages.map(
+      (message) =>
+        ({
+          ...message,
+          message_id: 0,
+          message_thread_id: threadId,
+          reply_to_message: undefined,
+        }) as TMessage,
+    );
+  };
+  const applyThreadCleanupPlan = async (
+    plan: ThreadReconciler.ThreadReconciliationPlan,
+  ): Promise<void> => {
+    deps.recordThreadReconciliationPlan?.(plan);
+    await ThreadReconciler.applyThreadReconciliationPlan(plan, {
+      callApi: deps.callApi,
+      markStaleByTarget: (staleTarget, syncStatus, lastSyncError) =>
+        deps.threadStore?.markStaleByTarget(
+          staleTarget,
+          syncStatus,
+          lastSyncError,
+        ) ?? false,
+      persist: () => deps.threadStore?.persist() ?? Promise.resolve(),
+      removePendingProvisionById: (id) =>
+        deps.threadStore?.removePendingProvision(id) ?? false,
+      getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
+      recordRuntimeEvent: deps.recordRuntimeEvent,
+    });
+  };
+  const dismissRerouteChooserMessage = async (
+    query: TCallbackQuery,
+  ): Promise<void> => {
+    const chatId = query.message?.chat?.id;
+    const messageId = query.message?.message_id;
+    if (
+      typeof chatId !== "number" ||
+      typeof messageId !== "number" ||
+      !deps.deleteMessage
+    ) {
+      return;
+    }
+    try {
+      await deps.deleteMessage(chatId, messageId);
+    } catch (error) {
+      deps.recordRuntimeEvent?.("telegram", error, {
+        phase: "reroute-chooser-delete",
+        chatId,
+        messageId,
+        threadId: query.message?.message_thread_id,
+      });
+    }
+  };
+  const closeReroutedUnboundTopic = async (
+    target: { chatId: number; threadId: number } | undefined,
+    messageId: number | undefined,
+  ): Promise<void> => {
+    if (!target || !deps.threadStore) return;
+    const nowMs = Date.now();
+    const currentLeaderEpoch = deps.getCurrentLeaderEpoch?.();
+    const plan = ThreadReconciler.planThreadReconciliation({
+      nowMs,
+      currentLeaderEpoch,
+      previousState: deps.getThreadReconciliationMachineState?.(),
+      records: deps.threadStore.list(),
+      reservations: deps.threadStore.listReservations(),
+      pendingProvisions: deps.threadStore.listPendingProvisions(),
+      unboundMessages: [
+        {
+          target,
+          observedAtMs: nowMs,
+          ...(typeof messageId === "number" ? { messageId } : {}),
+          ...(currentLeaderEpoch !== undefined
+            ? { leaderEpoch: currentLeaderEpoch }
+            : {}),
+        },
+      ],
+    });
+    await applyThreadCleanupPlan(plan);
+  };
+  const closePreviousLeaderThread = async (
+    target: { chatId: number; threadId: number } | undefined,
+  ): Promise<void> => {
+    if (!target || !deps.threadStore) return;
+    const currentLeaderEpoch = deps.getCurrentLeaderEpoch?.();
+    await applyThreadCleanupPlan({
+      actions: [
+        {
+          kind: "close-delete-previous-leader-topic",
+          target,
+          reason: "previous-leader",
+          instanceId: deps.getCurrentInstanceId?.(),
+          ...(currentLeaderEpoch !== undefined
+            ? { leaderEpoch: currentLeaderEpoch }
+            : {}),
+        },
+      ],
+    });
+  };
+  const closeReplacedFollowerThread = async (
+    target: { chatId: number; threadId: number } | undefined,
+    instanceId: string | undefined,
+  ): Promise<void> => {
+    if (!target || !deps.threadStore) return;
+    const currentLeaderEpoch = deps.getCurrentLeaderEpoch?.();
+    await applyThreadCleanupPlan({
+      actions: [
+        {
+          kind: "close-delete-replaced-follower-topic",
+          target,
+          reason: "replaced-follower",
+          instanceId,
+          ...(currentLeaderEpoch !== undefined
+            ? { leaderEpoch: currentLeaderEpoch }
+            : {}),
+        },
+      ],
+    });
+  };
+  const handleUnboundRerouteRestoreMenuCallback = async (
+    query: TCallbackQuery,
+    _ctx: TContext,
+  ): Promise<boolean> => {
+    const parsed = parseTelegramUnboundRerouteRestoreMenuCallbackData(
+      query.data,
+    );
+    if (!parsed) return false;
+    const chatId = query.message?.chat?.id;
+    const messageId = query.message?.message_id;
+    const pending = pendingUnboundReroutes.get(parsed.rerouteId);
+    if (
+      typeof chatId !== "number" ||
+      typeof messageId !== "number" ||
+      !deps.threadStore ||
+      !pending
+    ) {
+      await deps.answerCallbackQuery(query.id, "Message route expired.");
+      return true;
+    }
+    await deps.threadStore.load();
+    const activeRecords = getTelegramRoutableThreadRecords(
+      deps.threadStore.list(),
+      deps.getLiveThreadTargets?.(),
+    );
+    const replyMarkup = buildTelegramUnboundRerouteRestoreChooserMarkup(
+      parsed.rerouteId,
+      activeRecords,
+    );
+    if (deps.editInteractiveMessage) {
+      await deps.editInteractiveMessage(
+        chatId,
+        messageId,
+        formatTelegramUnboundRerouteRestoreChooserText(),
+        "html",
+        replyMarkup,
+      );
+    } else if (deps.sendInteractiveMessage) {
+      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,
+      );
+    }
+    await deps.answerCallbackQuery(query.id, "Choose instance to restore.");
+    return true;
+  };
+  const handleUnboundRerouteCallback = async (
+    query: TCallbackQuery,
+    ctx: TContext,
+  ): Promise<boolean> => {
+    const parsed = parseTelegramUnboundRerouteCallbackData(query.data);
+    if (!parsed) return false;
+    const chatId = query.message?.chat?.id;
+    const pending = pendingUnboundReroutes.get(parsed.rerouteId);
+    if (typeof chatId !== "number" || !deps.threadStore || !pending) {
+      await deps.answerCallbackQuery(query.id, "Message route expired.");
+      return true;
+    }
+    await deps.threadStore.load();
+    const record = getTelegramRoutableThreadRecords(
+      deps.threadStore.list(),
+      deps.getLiveThreadTargets?.(),
+    ).find(
+      (candidate) =>
+        candidate.target.chatId === chatId &&
+        candidate.target.threadId === parsed.threadId,
+    );
+    if (!record) {
+      await deps.answerCallbackQuery(query.id, "Thread is not active yet.");
+      return true;
+    }
+    const reroutedMessages = cloneTelegramMessagesForThread(
+      pending.messages,
+      parsed.threadId,
+    );
+    const sourceTarget =
+      typeof query.message?.message_thread_id === "number"
+        ? { chatId, threadId: query.message.message_thread_id }
+        : undefined;
+    const sourceMessageId = query.message?.message_id;
+    const currentInstanceId = deps.getCurrentInstanceId?.();
+    const leaderProfileKey = getLeaderTopicProfileKey(ctx, currentInstanceId);
+    const isCurrentLeaderRecord = isCurrentLeaderTopicRecord(
+      record,
+      leaderProfileKey,
+      currentInstanceId,
+    );
+    if (parsed.useNewSlot && !isCurrentLeaderRecord) {
+      if (
+        !sourceTarget ||
+        !deps.replaceFollowerThreadTarget ||
+        !deps.foreignOwnedUpdateForwarder?.forwardMessage
+      ) {
+        await deps.answerCallbackQuery(
+          query.id,
+          "Follower thread restore is not available yet.",
+        );
+        return true;
+      }
+      const replaced = await deps.replaceFollowerThreadTarget({
+        record,
+        target: sourceTarget,
+        oldTarget: record.target,
+      });
+      if (!replaced) {
+        await deps.answerCallbackQuery(
+          query.id,
+          "Follower thread is unavailable.",
+        );
+        return true;
+      }
+      const nowMs = Date.now();
+      const slot = record.slot ?? "?";
+      const threadName = getRestoredThreadName(record, slot);
+      deps.threadStore.markStaleByTarget(
+        record.target,
+        "deleted",
+        "Follower thread was replaced by restore source.",
+      );
+      deps.threadStore.upsert({
+        ...record,
+        target: sourceTarget,
+        status: "active",
+        syncStatus: "open",
+        updatedAtMs: nowMs,
+        threadName,
+        lastSyncObservedAtMs: nowMs,
+        lastReconcileAction: "follower-thread-restore",
+        rerouteConfirmedAtMs: nowMs,
+      });
+      await deps.threadStore.persist();
+      if (deps.callApi) {
+        try {
+          await deps.callApi("editForumTopic", {
+            chat_id: sourceTarget.chatId,
+            message_thread_id: sourceTarget.threadId,
+            name: Threads.getTelegramTopicTitleForThreadName(threadName, slot),
+          });
+        } catch (renameError) {
+          deps.recordRuntimeEvent?.("telegram", renameError, {
+            phase: "follower-topic-reroute-restore-rename",
+            chatId: sourceTarget.chatId,
+            threadId: sourceTarget.threadId,
+            slot: record.slot,
+          });
+        }
+      }
+      await closeReplacedFollowerThread(record.target, record.instanceId);
+      const forwarded = await Promise.all(
+        cloneTelegramMessagesForThread(
+          pending.messages,
+          sourceTarget.threadId,
+        ).map((message) =>
+          deps.foreignOwnedUpdateForwarder!.forwardMessage!({
+            message,
+            ownership: { instanceId: record.instanceId! },
+            ctx,
+          }),
+        ),
+      );
+      const allForwarded = forwarded.every(Boolean);
+      if (allForwarded) {
+        pendingUnboundReroutes.delete(parsed.rerouteId);
+        await dismissRerouteChooserMessage(query);
+      }
+      await deps.answerCallbackQuery(
+        query.id,
+        allForwarded ? "Message routed." : "Target thread is unavailable.",
+      );
+      return true;
+    }
+    if (
+      record.instanceId &&
+      record.instanceId !== currentInstanceId &&
+      !isCurrentLeaderRecord
+    ) {
+      if (!deps.foreignOwnedUpdateForwarder?.forwardMessage) {
+        await deps.answerCallbackQuery(
+          query.id,
+          "Open that thread and resend the message there.",
+        );
+        return true;
+      }
+      const forwarded = await Promise.all(
+        reroutedMessages.map((message) =>
+          deps.foreignOwnedUpdateForwarder!.forwardMessage!({
+            message,
+            ownership: { instanceId: record.instanceId! },
+            ctx,
+          }),
+        ),
+      );
+      const allForwarded = forwarded.every(Boolean);
+      if (allForwarded) {
+        pendingUnboundReroutes.delete(parsed.rerouteId);
+        await dismissRerouteChooserMessage(query);
+        await closeReroutedUnboundTopic(sourceTarget, sourceMessageId);
+      }
+      await deps.answerCallbackQuery(
+        query.id,
+        allForwarded ? "Message routed." : "Target thread is unavailable.",
+      );
+      return true;
+    }
+    if (
+      sourceTarget &&
+      isCurrentLeaderRecord &&
+      (parsed.useNewSlot || typeof record.rerouteConfirmedAtMs !== "number") &&
+      (record.target.chatId !== sourceTarget.chatId ||
+        record.target.threadId !== sourceTarget.threadId)
+    ) {
+      deps.threadStore.markStaleByTarget(
+        record.target,
+        "deleted",
+        parsed.useNewSlot
+          ? "Current leader thread was replaced by a new-slot reroute source."
+          : "Current leader thread was replaced by reroute source.",
+      );
+      const slot = parsed.useNewSlot
+        ? (deps.threadStore.allocateSlot(
+            leaderProfileKey ?? record.profileKey,
+            getNextTelegramSlotPreference(record.slot),
+          ) ??
+          record.slot ??
+          "?")
+        : (record.slot ?? "?");
+      const nowMs = Date.now();
+      const threadName = getRestoredThreadName(record, slot);
+      deps.threadStore.upsert({
+        ...record,
+        target: sourceTarget,
+        status: "active",
+        updatedAtMs: nowMs,
+        threadName,
+        instanceId: currentInstanceId,
+        slot,
+        lastReconcileAction: parsed.useNewSlot
+          ? "reroute-new-slot"
+          : "reroute-reclaim",
+        rerouteConfirmedAtMs: nowMs,
+      });
+      await deps.threadStore.persist();
+      if (deps.callApi) {
+        try {
+          await deps.callApi("editForumTopic", {
+            chat_id: sourceTarget.chatId,
+            message_thread_id: sourceTarget.threadId,
+            name: Threads.getTelegramTopicTitleForThreadName(threadName, slot),
+          });
+        } catch (renameError) {
+          deps.recordRuntimeEvent?.("telegram", renameError, {
+            phase: "leader-topic-reroute-reclaim-rename",
+            chatId: sourceTarget.chatId,
+            threadId: sourceTarget.threadId,
+            slot,
+          });
+        }
+      }
+      deps.recordRuntimeEvent?.(
+        "bus",
+        "Bus leader reclaimed reroute source thread",
+        {
+          phase: "leader-topic-reroute-reclaim",
+          chatId: sourceTarget.chatId,
+          threadId: sourceTarget.threadId,
+          staleThreadId: record.target.threadId,
+          slot,
+        },
+      );
+      if (parsed.useNewSlot) {
+        await closePreviousLeaderThread(record.target);
+      }
+      await promptEnqueue(
+        cloneTelegramMessagesForThread(pending.messages, sourceTarget.threadId),
+        ctx,
+      );
+      pendingUnboundReroutes.delete(parsed.rerouteId);
+      await dismissRerouteChooserMessage(query);
+      await deps.answerCallbackQuery(query.id, "Message routed.");
+      return true;
+    }
+    await promptEnqueue(reroutedMessages, ctx);
+    pendingUnboundReroutes.delete(parsed.rerouteId);
+    await dismissRerouteChooserMessage(query);
+    await closeReroutedUnboundTopic(sourceTarget, sourceMessageId);
+    await deps.answerCallbackQuery(query.id, "Message routed.");
+    return true;
+  };
+  let dispatchAllTabCommandToTarget:
+    | ((
+        commandText: string,
+        query: TCallbackQuery,
+        threadId: number,
+        ctx: TContext,
+      ) => Promise<void>)
+    | undefined;
+  const handleAllTabMenuCallback = async (
+    query: TCallbackQuery,
+    ctx: TContext,
+  ): Promise<boolean> => {
+    const parsed = parseTelegramAllTabMenuCallbackData(query.data);
+    if (!parsed) return false;
+    const chatId = query.message?.chat?.id;
+    const pending = pendingAllTabCommands.get(parsed.commandId);
+    if (typeof chatId !== "number" || !deps.threadStore || !pending) {
+      await deps.answerCallbackQuery(query.id, "Thread menu expired.");
+      return true;
+    }
+    await deps.threadStore.load();
+    const record = getTelegramRoutableThreadRecords(
+      deps.threadStore.list(),
+      deps.getLiveThreadTargets?.(),
+    ).find(
+      (candidate) =>
+        candidate.target.chatId === chatId &&
+        candidate.target.threadId === parsed.threadId,
+    );
+    if (!record) {
+      await deps.answerCallbackQuery(query.id, "Thread is not active yet.");
+      return true;
+    }
+    const currentInstanceId = deps.getCurrentInstanceId?.();
+    const leaderProfileKey = getLeaderTopicProfileKey(ctx, currentInstanceId);
+    const isCurrentLeaderRecord = isCurrentLeaderTopicRecord(
+      record,
+      leaderProfileKey,
+      currentInstanceId,
+    );
+    if (
+      record.instanceId &&
+      record.instanceId !== currentInstanceId &&
+      !isCurrentLeaderRecord
+    ) {
+      if (!deps.foreignOwnedUpdateForwarder?.forwardMessage) {
+        await deps.answerCallbackQuery(
+          query.id,
+          "Open that thread and run /start there.",
+        );
+        return true;
+      }
+      const forwarded = await deps.foreignOwnedUpdateForwarder.forwardMessage({
+        message: {
+          ...(query.message ?? {}),
+          message_id: query.message?.message_id ?? 0,
+          chat: { id: chatId, type: "private" },
+          from: query.from,
+          message_thread_id: parsed.threadId,
+          text: pending.text,
+        } as TMessage,
+        ownership: { instanceId: record.instanceId },
+        ctx,
+      });
+      if (forwarded) pendingAllTabCommands.delete(parsed.commandId);
+      await deps.answerCallbackQuery(
+        query.id,
+        forwarded
+          ? "Opening in target thread."
+          : "Target thread is unavailable.",
+      );
+      return true;
+    }
+    if (!dispatchAllTabCommandToTarget) {
+      await deps.answerCallbackQuery(query.id, "Thread menu expired.");
+      return true;
+    }
+    await dispatchAllTabCommandToTarget(
+      pending.text,
+      query,
+      parsed.threadId,
+      ctx,
+    );
+    pendingAllTabCommands.delete(parsed.commandId);
+    await deps.answerCallbackQuery(query.id, "Opening in target thread.");
+    return true;
+  };
   const callbackHandler = async (
     query: TCallbackQuery,
     ctx: TContext,
   ): Promise<void> => {
+    if (await handleUnboundRerouteRestoreMenuCallback(query, ctx)) return;
+    if (await handleUnboundRerouteCallback(query, ctx)) return;
+    if (await handleAllTabMenuCallback(query, ctx)) return;
     if (deps.buttonActionStore) {
       const handled = await OutboundHandlers.handleTelegramButtonCallbackQuery(
         query,
@@ -253,6 +1243,13 @@ export function createTelegramInboundRouteRuntime<
             deps.queueMutationRuntime.append(
               OutboundHandlers.createTelegramButtonPromptTurn({
                 chatId,
+                target:
+                  typeof buttonQuery.message?.message_thread_id === "number"
+                    ? {
+                        chatId,
+                        threadId: buttonQuery.message.message_thread_id,
+                      }
+                    : { chatId },
                 replyToMessageId: messageId,
                 queueOrder,
                 action,
@@ -271,7 +1268,7 @@ export function createTelegramInboundRouteRuntime<
         ctx,
         answerCallbackQuery: deps.answerCallbackQuery,
         editInteractiveMessage: deps.editInteractiveMessage ?? (async () => {}),
-        runCompact: async (compactCtx, chatId, replyToMessageId) => {
+        runCompact: async (compactCtx, chatId, replyToMessageId, target) => {
           await Commands.handleTelegramCompactCommand({
             isIdle: () => deps.isIdle(compactCtx),
             hasPendingMessages: () => deps.hasPendingMessages(compactCtx),
@@ -294,11 +1291,16 @@ export function createTelegramInboundRouteRuntime<
                 : undefined,
             compact: (callbacks) => deps.compact(compactCtx, callbacks),
             startTypingLoop: deps.startTypingLoop
-              ? () => deps.startTypingLoop?.(compactCtx, chatId)
+              ? () =>
+                  deps.startTypingLoop?.(compactCtx, chatId, {
+                    target,
+                  })
               : undefined,
             stopTypingLoop: deps.stopTypingLoop,
             sendTextReply: (text) =>
-              deps.sendTextReply(chatId, replyToMessageId, text).then(() => {}),
+              deps
+                .sendTextReply(chatId, replyToMessageId, text, { target })
+                .then(() => {}),
             suppressStartNotice: true,
             recordRuntimeEvent: deps.recordRuntimeEvent,
           });
@@ -343,6 +1345,22 @@ export function createTelegramInboundRouteRuntime<
       const mode = deps.configStore.get().voice?.replyMode;
       return mode === "manual" || mode === "mirror" || mode === "always";
     },
+    getTelegramThreadLabel(message) {
+      if (!deps.threadStore) return undefined;
+      const chatId = message.chat.id;
+      const threadId = message.message_thread_id;
+      if (!threadId) return undefined;
+      const records = deps.threadStore.list();
+      for (const r of records) {
+        if (r.target.chatId !== chatId || r.target.threadId !== threadId)
+          continue;
+        return r.threadName &&
+          Threads.isTelegramTopicThreadNameValidForSlot(r.threadName, r.slot)
+          ? r.threadName
+          : getRestoredThreadName(r, r.slot ?? "");
+      }
+      return undefined;
+    },
   });
   const enqueueContinueTurn = async (
     message: TMessage,
@@ -429,28 +1447,207 @@ export function createTelegramInboundRouteRuntime<
       deps.bridgeRuntime.lifecycle.shouldFoldQueuedPromptsIntoHistory,
     setFoldQueuedPromptsIntoHistory:
       deps.bridgeRuntime.lifecycle.setFoldQueuedPromptsIntoHistory,
-    createTurn: promptTurnBuilder,
+    createTurn: async (messages, historyTurns, turnCtx) => {
+      const turn = await promptTurnBuilder(messages, historyTurns, turnCtx);
+      return turn.replyToMessageId > 0
+        ? turn
+        : { ...turn, replyToMessageId: 0 };
+    },
     updateStatus: deps.updateStatus,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
   }).enqueue;
+  const sendUnboundRerouteChooserNow = async (
+    messages: TMessage[],
+    ctx: TContext,
+  ): Promise<void> => {
+    const message = messages[0];
+    if (!message || !deps.threadStore) return;
+    const records = deps.threadStore.list();
+    const activeRecords = getTelegramRoutableThreadRecords(
+      records,
+      deps.getLiveThreadTargets?.(),
+    );
+    const sourceTarget =
+      typeof message.message_thread_id === "number"
+        ? { chatId: message.chat.id, threadId: message.message_thread_id }
+        : undefined;
+    const sourceKey = sourceTarget
+      ? formatTelegramTargetKey(sourceTarget)
+      : undefined;
+    const includeGuidance = sourceKey
+      ? !guidedUnboundTopicKeys.has(sourceKey)
+      : true;
+    if (sourceKey) guidedUnboundTopicKeys.add(sourceKey);
+    if (activeRecords.length === 0) {
+      await deps.sendTextReply(
+        message.chat.id,
+        message.message_id,
+        [
+          includeGuidance ? formatTelegramUnboundTopicGuidance() : undefined,
+          "This thread is not bound to a Pi instance. Open an active Pi thread or run /telegram-connect from a Pi session to bind one.",
+        ]
+          .filter((line): line is string => typeof line === "string")
+          .join("\n\n"),
+        { parseMode: "HTML", target: sourceTarget },
+      );
+      return;
+    }
+    const rerouteId = storePendingUnboundReroute(messages);
+    const text = formatTelegramUnboundRerouteChooserText(activeRecords, {
+      includeGuidance,
+    });
+    const currentInstanceId = deps.getCurrentInstanceId?.();
+    const replyMarkup = buildTelegramUnboundRerouteChooserMarkup(
+      rerouteId,
+      activeRecords,
+      {
+        currentLeaderProfileKey: getLeaderTopicProfileKey(
+          ctx,
+          currentInstanceId,
+        ),
+        currentInstanceId,
+      },
+    );
+    if (deps.sendInteractiveMessage) {
+      await deps.sendInteractiveMessage(
+        message.chat.id,
+        text,
+        "html",
+        replyMarkup,
+        sourceTarget
+          ? { target: sourceTarget, replyToMessageId: message.message_id }
+          : { replyToMessageId: message.message_id },
+      );
+      return;
+    }
+    await deps.sendTextReply(message.chat.id, message.message_id, text, {
+      parseMode: "HTML",
+      target: sourceTarget,
+    });
+  };
+  const sendUnboundRerouteChooser = async (
+    message: TMessage,
+    ctx: TContext,
+  ): Promise<void> => {
+    const groupKey = Media.getTelegramMediaGroupKey(message);
+    if (!groupKey) {
+      await sendUnboundRerouteChooserNow([message], ctx);
+      return;
+    }
+    const existing = pendingUnboundRerouteMediaGroups.get(groupKey);
+    if (existing) clearTimeout(existing.timer);
+    const messages = [...(existing?.messages ?? []), message];
+    const timer = setTimeout(() => {
+      pendingUnboundRerouteMediaGroups.delete(groupKey);
+      void sendUnboundRerouteChooserNow(messages, ctx);
+    }, 1200);
+    timer.unref?.();
+    pendingUnboundRerouteMediaGroups.set(groupKey, { messages, timer });
+  };
+  const getKnownTelegramAllTabCommand = (
+    text: string,
+  ): Commands.ParsedTelegramCommand | undefined => {
+    const command = Commands.parseTelegramCommand(text);
+    if (!command) return undefined;
+    if (reservedCommandNames().has(command.name)) return command;
+    if (Commands.findTelegramExtensionCommand(command.name)) return command;
+    if (
+      getPromptTemplateCommands().some(
+        (template) => template.command === command.name,
+      )
+    ) {
+      return command;
+    }
+    return undefined;
+  };
+  const sendAllTabCommandChooser = async (
+    command: Commands.ParsedTelegramCommand,
+    commandText: string,
+    message: TMessage,
+    options: {
+      replyToSource?: boolean;
+      target?: Queue.TelegramQueueTarget;
+    } = {},
+  ): Promise<boolean> => {
+    if (!deps.threadStore) return false;
+    const records = deps.threadStore.list();
+    const activeRecords = getTelegramRoutableThreadRecords(
+      records,
+      deps.getLiveThreadTargets?.(),
+    );
+    if (activeRecords.length === 0) return false;
+    const commandId = storePendingAllTabCommand(command, commandText);
+    const text = formatTelegramAllTabMenuChooserText(command.name);
+    const replyMarkup = buildTelegramAllTabMenuChooserMarkup(
+      commandId,
+      activeRecords,
+    );
+    if (deps.sendInteractiveMessage) {
+      await deps.sendInteractiveMessage(
+        message.chat.id,
+        text,
+        "html",
+        replyMarkup,
+        options.target || options.replyToSource
+          ? {
+              ...(options.target ? { target: options.target } : {}),
+              ...(options.replyToSource
+                ? { replyToMessageId: message.message_id }
+                : {}),
+            }
+          : undefined,
+      );
+      return true;
+    }
+    if (deps.callApi) {
+      await deps.callApi("sendMessage", {
+        chat_id: message.chat.id,
+        text,
+        parse_mode: "HTML",
+        reply_markup: replyMarkup,
+        ...(typeof options.target?.threadId === "number"
+          ? { message_thread_id: options.target.threadId }
+          : {}),
+        ...(options.replyToSource
+          ? {
+              reply_parameters: {
+                message_id: message.message_id,
+                allow_sending_without_reply: true,
+              },
+            }
+          : {}),
+      });
+      return true;
+    }
+    await deps.sendTextReply(message.chat.id, message.message_id, text, {
+      parseMode: "HTML",
+      target: options.target,
+    });
+    return true;
+  };
   const commandOrPrompt = Commands.createTelegramCommandOrPromptRuntime<
     TMessage,
     TContext
   >({
     extractRawText: Media.extractFirstTelegramMessageText,
+    shouldIgnoreMessages: (messages) =>
+      !Media.hasTelegramMessagesPromptContent(messages),
     handleCommand: commandHandler,
     executeExtensionCommand: async (command, message, ctx) => {
       const extensionCommand = Commands.findTelegramExtensionCommand(
         command.name,
       );
       if (!extensionCommand) return false;
+      const sourceTarget = Updates.getTelegramMessageTarget(message);
       try {
         await extensionCommand.handler({
           name: command.name,
           args: command.args,
           reply: (text) =>
             deps
-              .sendTextReply(message.chat.id, message.message_id, text)
+              .sendTextReply(message.chat.id, message.message_id, text, {
+                target: sourceTarget,
+              })
               .then(() => {}),
           enqueuePrompt: (prompt) =>
             promptEnqueue(
@@ -472,6 +1669,7 @@ export function createTelegramInboundRouteRuntime<
           message.chat.id,
           message.message_id,
           "Command failed.",
+          { target: sourceTarget },
         );
       }
       return true;
@@ -486,6 +1684,24 @@ export function createTelegramInboundRouteRuntime<
       ({ ...message, text, caption: undefined }) as TMessage,
     enqueueTurn: promptEnqueue,
   });
+  dispatchAllTabCommandToTarget = async (commandText, query, threadId, ctx) => {
+    const chatId = query.message?.chat?.id;
+    if (typeof chatId !== "number") return;
+    await commandOrPrompt.dispatchMessages(
+      [
+        {
+          ...(query.message ?? {}),
+          message_id: 0,
+          chat: { id: chatId, type: "private" },
+          from: query.from,
+          message_thread_id: threadId,
+          text: commandText,
+          caption: undefined,
+        } as TMessage,
+      ],
+      ctx,
+    );
+  };
   const mediaDispatch = Media.createTelegramMediaGroupDispatchRuntime<
     TMessage,
     TContext
@@ -508,6 +1724,16 @@ export function createTelegramInboundRouteRuntime<
     ...deps.telegramQueueStore,
     updateStatus: deps.updateStatus,
   });
+  const handleTelegramTopicLifecycleUpdate = async (
+    lifecycle: Updates.TelegramTopicLifecycleUpdate<TMessage>,
+    ctx: TContext,
+  ): Promise<void> => {
+    await deps.handleTelegramTopicLifecycleUpdate?.(lifecycle, ctx);
+    if (lifecycle.kind !== "created" || !deps.threadStore) {
+      return;
+    }
+    await deps.threadStore.load();
+  };
   const handleAuthorizedTelegramGuestMessage = async (
     guestMessage: Updates.TelegramGuestMessage & { from: TelegramUser },
     ctx: TContext,
@@ -609,6 +1835,11 @@ export function createTelegramInboundRouteRuntime<
   };
   return Updates.createTelegramPairedUpdateRuntime<TContext, TUpdate>({
     getAllowedUserId: deps.configStore.getAllowedUserId,
+    getCurrentInstanceId: deps.getCurrentInstanceId,
+    getMessageOwnership: deps.getMessageOwnership,
+    getTargetOwnership: deps.getTargetOwnership,
+    handleTelegramTopicLifecycleUpdate,
+    foreignOwnedUpdateForwarder: deps.foreignOwnedUpdateForwarder,
     setAllowedUserId: deps.configStore.setAllowedUserId,
     persistConfig: deps.configStore.persist,
     updateStatus: deps.updateStatus,
@@ -623,8 +1854,441 @@ export function createTelegramInboundRouteRuntime<
     answerGuestQuery: deps.answerGuestQuery,
     handleAuthorizedTelegramCallbackQuery: callbackHandler,
     sendTextReply: deps.sendTextReply,
-    handleAuthorizedTelegramMessage: textDispatch.handleMessage,
+    handleAuthorizedTelegramMessage: async (message, ctx) => {
+      if (typeof message.message_thread_id === "number") {
+        await deps.handleTelegramThreadTargetObserved?.(
+          {
+            chatId: message.chat.id,
+            threadId: message.message_thread_id,
+          },
+          ctx,
+        );
+      }
+      const text = Media.extractFirstTelegramMessageText([
+        message as TMessage,
+      ]).trim();
+      if (deps.threadStore && typeof message.message_thread_id !== "number") {
+        await deps.threadStore.load();
+        if (deps.threadStore.getBotState().threadMode === "disabled") {
+          await textDispatch.handleMessage(message as TMessage, ctx);
+          return;
+        }
+        const records = deps.threadStore.list();
+        const bindings = getTelegramRoutableThreadRecords(
+          records,
+          deps.getLiveThreadTargets?.(),
+        );
+        const command = getKnownTelegramAllTabCommand(text);
+        if (bindings.length > 0 && command && command.name !== "thread") {
+          if (
+            await sendAllTabCommandChooser(command, text, message as TMessage, {
+              replyToSource: true,
+            })
+          ) {
+            return;
+          }
+        }
+        if (bindings.length > 0 && !text.startsWith("/")) {
+          const probeTarget = bindings[0]?.target;
+          if (probeTarget?.threadId && deps.callApi) {
+            try {
+              await deps.callApi("sendChatAction", {
+                chat_id: probeTarget.chatId,
+                message_thread_id: probeTarget.threadId,
+                action: "typing",
+              });
+            } catch (error) {
+              if (
+                Threads.isTelegramTopicModeUnavailableError(error) ||
+                Threads.isTelegramTopicTargetStaleError(error)
+              ) {
+                deps.threadStore.setBotState({
+                  threadMode: "disabled",
+                  updatedAtMs: Date.now(),
+                  lastReconcileAction:
+                    "thread-mode-unavailable-threadless-prompt",
+                });
+                await deps.threadStore.persist();
+                await textDispatch.handleMessage(message as TMessage, ctx);
+                return;
+              }
+              deps.recordRuntimeEvent?.("telegram", error, {
+                phase: "threadless-topic-capability-check",
+                chatId: probeTarget.chatId,
+                threadId: probeTarget.threadId,
+              });
+            }
+          }
+          await deps.sendTextReply(
+            message.chat.id,
+            message.message_id,
+            "This bot is in threaded multi-instance mode. Send prompts in a bound Pi thread tab so they route to the right instance.",
+          );
+          return;
+        }
+      }
+      await textDispatch.handleMessage(message as TMessage, ctx);
+    },
     handleAuthorizedTelegramEditedMessage: editRuntime.updateFromEditedMessage,
     handleAuthorizedTelegramGuestMessage,
+    handleUnboundTelegramTopicMessage: async (message, ctx) => {
+      if (!deps.threadStore) {
+        await textDispatch.handleMessage(message as TMessage, ctx);
+        return;
+      }
+      await deps.threadStore.load();
+      if (deps.threadStore.getBotState().threadMode === "disabled") {
+        await textDispatch.handleMessage(message as TMessage, ctx);
+        return;
+      }
+      const target = Updates.getTelegramMessageTarget(message);
+      if (!target?.threadId) {
+        await textDispatch.handleMessage(message as TMessage, ctx);
+        return;
+      }
+      const text = Media.extractFirstTelegramMessageText([
+        message as TMessage,
+      ]).trim();
+      const instanceId = deps.getCurrentInstanceId?.();
+      const leaderProfileKey = getLeaderTopicProfileKey(ctx, instanceId);
+      const existing = deps.threadStore.list().find((r) => {
+        return (
+          r.target.chatId === target.chatId &&
+          r.target.threadId === target.threadId
+        );
+      });
+      if (existing) {
+        const isLeaderTopic =
+          (instanceId && existing.instanceId === instanceId) ||
+          (!!leaderProfileKey && existing.profileKey === leaderProfileKey);
+        if (existing.status === "active" && isLeaderTopic) {
+          if (typeof existing.rerouteConfirmedAtMs !== "number") {
+            const nowMs = Date.now();
+            deps.threadStore.upsert({
+              ...existing,
+              updatedAtMs: nowMs,
+              rerouteConfirmedAtMs: nowMs,
+            });
+            await deps.threadStore.persist();
+          }
+          await textDispatch.handleMessage(message as TMessage, ctx);
+          return;
+        }
+        if (existing.status === "starting") {
+          await deps.sendTextReply(
+            target.chatId,
+            message.message_id,
+            "Instance " +
+              getTelegramThreadRecordLabel(existing) +
+              " is starting. Please wait…",
+            { target },
+          );
+          return;
+        }
+        if (existing.status === "active") {
+          await deps.sendTextReply(
+            target.chatId,
+            message.message_id,
+            "Instance " +
+              getTelegramThreadRecordLabel(existing) +
+              " is not connected to the Telegram bus yet. Run /telegram-connect in that Pi instance; keeping this thread.",
+            { target },
+          );
+          return;
+        }
+        if (
+          (existing.status === "stale" || existing.status === "offline") &&
+          leaderProfileKey &&
+          !hasActiveLeaderTopic(
+            deps.threadStore.list(),
+            leaderProfileKey,
+            instanceId,
+          )
+        ) {
+          const priorLeaderRecord =
+            deps.threadStore.getByProfileKey(leaderProfileKey);
+          const slot =
+            deps.threadStore.allocateSlot(
+              leaderProfileKey,
+              priorLeaderRecord?.slot ?? existing.slot,
+            ) ??
+            priorLeaderRecord?.slot ??
+            existing.slot ??
+            "A";
+          const threadName =
+            priorLeaderRecord?.threadName ??
+            existing.threadName ??
+            Threads.chooseTelegramThreadName({ slot }) ??
+            "Pi";
+          deps.threadStore.upsert({
+            profileKey: leaderProfileKey,
+            owner: {
+              kind: "leader",
+              cwd:
+                typeof (ctx as { cwd?: unknown }).cwd === "string"
+                  ? (ctx as { cwd?: string }).cwd
+                  : undefined,
+              instanceId,
+            },
+            target: { chatId: target.chatId, threadId: target.threadId },
+            status: "active",
+            createdAtMs: priorLeaderRecord?.createdAtMs ?? existing.createdAtMs,
+            updatedAtMs: Date.now(),
+            threadName,
+            instanceId,
+            slot,
+          });
+          await deps.threadStore.persist();
+          if (deps.callApi) {
+            try {
+              await deps.callApi("editForumTopic", {
+                chat_id: target.chatId,
+                message_thread_id: target.threadId,
+                name: Threads.getTelegramTopicTitleForThreadName(
+                  threadName,
+                  slot,
+                ),
+              });
+            } catch (renameError) {
+              deps.recordRuntimeEvent?.("telegram", renameError, {
+                phase: "leader-topic-reclaim-rename",
+                chatId: target.chatId,
+                threadId: target.threadId,
+                slot,
+              });
+            }
+          }
+          deps.recordRuntimeEvent?.(
+            "bus",
+            "Bus leader reclaimed unbound thread",
+            {
+              phase: "leader-topic-reclaim",
+              chatId: target.chatId,
+              threadId: target.threadId,
+              slot,
+              profileKey: leaderProfileKey,
+            },
+          );
+          await textDispatch.handleMessage(message as TMessage, ctx);
+          return;
+        }
+        await deps.sendTextReply(
+          target.chatId,
+          message.message_id,
+          "Topic " +
+            (existing.slot ?? "?") +
+            " is " +
+            existing.status +
+            ". Start a Pi instance to claim it.",
+          { target },
+        );
+        return;
+      }
+      const reservations = deps.threadStore.listReservations();
+      const reservation = reservations.find(
+        (reservation) =>
+          reservation.target.chatId === target.chatId &&
+          reservation.target.threadId === target.threadId,
+      );
+      if (reservation) {
+        await deps.sendTextReply(
+          target.chatId,
+          message.message_id,
+          "Previous leader thread (" +
+            (reservation.slot ?? "?") +
+            "). Closing and deleting this old topic. Use the current thread tab instead.",
+          { target },
+        );
+        await deleteReservedTelegramTopicThroughReconciler(
+          deps,
+          { chatId: target.chatId, threadId: target.threadId },
+          message.message_id,
+        );
+        return;
+      }
+      const records = deps.threadStore.list();
+      const command = getKnownTelegramAllTabCommand(text);
+      if (
+        command &&
+        getTelegramRoutableThreadRecords(records, deps.getLiveThreadTargets?.())
+          .length > 0
+      ) {
+        if (
+          await sendAllTabCommandChooser(command, text, message as TMessage, {
+            target: { chatId: target.chatId, threadId: target.threadId },
+            replyToSource: true,
+          })
+        ) {
+          return;
+        }
+      }
+      if (leaderProfileKey && deps.callApi) {
+        const currentLeaderRecord = records.find((record) => {
+          if (record.status !== "active") return false;
+          if (instanceId && record.instanceId === instanceId) return true;
+          return record.profileKey === leaderProfileKey;
+        });
+        if (
+          currentLeaderRecord &&
+          (currentLeaderRecord.target.chatId !== target.chatId ||
+            currentLeaderRecord.target.threadId !== target.threadId)
+        ) {
+          let currentLeaderIsStale = false;
+          try {
+            await deps.callApi("sendChatAction", {
+              chat_id: currentLeaderRecord.target.chatId,
+              message_thread_id: currentLeaderRecord.target.threadId,
+              action: "typing",
+            });
+          } catch (error) {
+            currentLeaderIsStale =
+              Threads.isTelegramTopicTargetStaleError(error);
+            if (!currentLeaderIsStale) throw error;
+          }
+          if (currentLeaderIsStale) {
+            deps.threadStore.markStaleByTarget(
+              currentLeaderRecord.target,
+              "deleted",
+              "Current leader thread is stale during unbound prompt routing.",
+            );
+            const slot = currentLeaderRecord.slot ?? "A";
+            const threadName = getRestoredThreadName(currentLeaderRecord, slot);
+            deps.threadStore.upsert({
+              ...currentLeaderRecord,
+              profileKey: leaderProfileKey,
+              owner: {
+                kind: "leader",
+                cwd:
+                  typeof (ctx as { cwd?: unknown }).cwd === "string"
+                    ? (ctx as { cwd?: string }).cwd
+                    : undefined,
+                instanceId,
+              },
+              target: { chatId: target.chatId, threadId: target.threadId },
+              status: "active",
+              updatedAtMs: Date.now(),
+              threadName,
+              instanceId,
+              slot,
+            });
+            await deps.threadStore.persist();
+            try {
+              await deps.callApi("editForumTopic", {
+                chat_id: target.chatId,
+                message_thread_id: target.threadId,
+                name: Threads.getTelegramTopicTitleForThreadName(
+                  threadName,
+                  slot,
+                ),
+              });
+            } catch (renameError) {
+              deps.recordRuntimeEvent?.("telegram", renameError, {
+                phase: "leader-topic-unbound-reclaim-rename",
+                chatId: target.chatId,
+                threadId: target.threadId,
+                slot,
+              });
+            }
+            deps.recordRuntimeEvent?.(
+              "bus",
+              "Bus leader reclaimed stale-current unbound thread",
+              {
+                phase: "leader-topic-unbound-stale-reclaim",
+                chatId: target.chatId,
+                threadId: target.threadId,
+                staleThreadId: currentLeaderRecord.target.threadId,
+                slot,
+                profileKey: leaderProfileKey,
+              },
+            );
+            await textDispatch.handleMessage(message as TMessage, ctx);
+            return;
+          }
+        }
+      }
+      if (
+        leaderProfileKey &&
+        !hasActiveLeaderTopic(records, leaderProfileKey, instanceId)
+      ) {
+        const priorLeaderRecord =
+          deps.threadStore.getByProfileKey(leaderProfileKey);
+        const priorLeaderIdentity =
+          deps.threadStore.getIdentityByProfileKey(leaderProfileKey);
+        const slot =
+          deps.threadStore.allocateSlot(
+            leaderProfileKey,
+            priorLeaderRecord?.slot ?? priorLeaderIdentity?.slot,
+          ) ??
+          priorLeaderRecord?.slot ??
+          priorLeaderIdentity?.slot ??
+          "A";
+        const identityThreadName =
+          priorLeaderIdentity?.threadName &&
+          Threads.isTelegramTopicThreadNameValidForSlot(
+            priorLeaderIdentity.threadName,
+            slot,
+          )
+            ? priorLeaderIdentity.threadName
+            : undefined;
+        const threadName =
+          priorLeaderRecord?.threadName ??
+          identityThreadName ??
+          Threads.chooseTelegramThreadName({ slot }) ??
+          "Pi";
+        deps.threadStore.upsert({
+          profileKey: leaderProfileKey,
+          owner: {
+            kind: "leader",
+            cwd:
+              typeof (ctx as { cwd?: unknown }).cwd === "string"
+                ? (ctx as { cwd?: string }).cwd
+                : undefined,
+            instanceId,
+          },
+          target: { chatId: target.chatId, threadId: target.threadId },
+          status: "active",
+          createdAtMs: priorLeaderRecord?.createdAtMs ?? Date.now(),
+          updatedAtMs: Date.now(),
+          threadName,
+          instanceId,
+          slot,
+        });
+        await deps.threadStore.persist();
+        if (deps.callApi) {
+          try {
+            await deps.callApi("editForumTopic", {
+              chat_id: target.chatId,
+              message_thread_id: target.threadId,
+              name: Threads.getTelegramTopicTitleForThreadName(
+                threadName,
+                slot,
+              ),
+            });
+          } catch (renameError) {
+            deps.recordRuntimeEvent?.("telegram", renameError, {
+              phase: "leader-topic-reclaim-rename",
+              chatId: target.chatId,
+              threadId: target.threadId,
+              slot,
+            });
+          }
+        }
+        deps.recordRuntimeEvent?.(
+          "bus",
+          "Bus leader reclaimed unbound thread",
+          {
+            phase: "leader-topic-reclaim",
+            chatId: target.chatId,
+            threadId: target.threadId,
+            slot,
+            profileKey: leaderProfileKey,
+          },
+        );
+        await textDispatch.handleMessage(message as TMessage, ctx);
+        return;
+      }
+      await sendUnboundRerouteChooser(message as TMessage, ctx);
+      return;
+    },
   });
 }