@llblab/pi-telegram 0.19.2 → 0.20.0

package/lib/media.ts

@@ -33,11 +33,36 @@ export interface TelegramRichMessage {
   blocks?: unknown[];
 }
 
+export interface TelegramMessageUser {
+  id?: number;
+  is_bot?: boolean;
+  first_name?: string;
+  last_name?: string;
+  username?: string;
+}
+
+export interface TelegramMessageForwardOrigin {
+  type?: string;
+  sender_user?: TelegramMessageUser;
+  sender_user_name?: string;
+  sender_chat?: { title?: string; username?: string; id?: number };
+  chat?: { title?: string; username?: string; id?: number };
+  author_signature?: string;
+}
+
 export interface TelegramReplyToMessage {
   message_id?: number;
+  from?: TelegramMessageUser;
   text?: string;
   caption?: string;
   rich_message?: TelegramRichMessage;
+  photo?: TelegramPhotoSize[];
+  document?: TelegramDocument;
+  video?: TelegramVideo;
+  audio?: TelegramAudio;
+  voice?: TelegramVoice;
+  animation?: TelegramAnimation;
+  sticker?: TelegramSticker;
 }
 
 export interface TelegramSticker {
@@ -46,6 +71,10 @@ export interface TelegramSticker {
 
 export interface TelegramMediaMessage {
   message_id: number;
+  from?: TelegramMessageUser;
+  forward_origin?: TelegramMessageForwardOrigin;
+  forward_from?: TelegramMessageUser;
+  forward_sender_name?: string;
   text?: string;
   caption?: string;
   rich_message?: TelegramRichMessage;
@@ -277,6 +306,39 @@ function truncateTelegramReplyContextText(text: string): string {
   return `${text.slice(0, TELEGRAM_REPLY_CONTEXT_MAX_LENGTH).trimEnd()}…`;
 }
 
+function formatTelegramUser(user: TelegramMessageUser | undefined): string | undefined {
+  if (!user) return undefined;
+  if (user.username) return user.username;
+  if (typeof user.id === "number") return String(user.id);
+  const name = [user.first_name, user.last_name].filter(Boolean).join(" ").trim();
+  return name || undefined;
+}
+
+function formatTelegramForwardOriginIdentifier(
+  message: TelegramMediaMessage,
+): string | undefined {
+  const origin = message.forward_origin;
+  const user = origin?.sender_user ?? message.forward_from;
+  if (user?.username) return user.username;
+  if (typeof user?.id === "number") return String(user.id);
+  const chat = origin?.sender_chat ?? origin?.chat;
+  if (chat?.username) return chat.username;
+  if (typeof chat?.id === "number") return String(chat.id);
+  return origin?.sender_user_name ?? message.forward_sender_name;
+}
+
+export function extractTelegramForwardContextText(
+  message: TelegramMediaMessage,
+  allowedUserId?: number,
+): string {
+  const originUser = message.forward_origin?.sender_user ?? message.forward_from;
+  const isOwnerOrigin =
+    typeof allowedUserId === "number" && originUser?.id === allowedUserId;
+  const origin = formatTelegramForwardOriginIdentifier(message);
+  if (!origin || isOwnerOrigin) return "";
+  return `from: ${origin}`;
+}
+
 export function extractTelegramReplyContextText(
   message: TelegramMediaMessage,
 ): string {
@@ -289,13 +351,44 @@ export function extractTelegramReplyContextText(
   return quoted ? truncateTelegramReplyContextText(quoted) : "";
 }
 
+export function buildTelegramReplyContextBlock(
+  message: TelegramMediaMessage,
+  replyFiles: Pick<DownloadedTelegramFile, "path">[] = [],
+): string {
+  const from = formatTelegramUser(message.reply_to_message?.from);
+  const header = from ? `[reply|from:${from}]` : "[reply]";
+  const text = extractTelegramReplyContextText(message);
+  const dirs = [...new Set(replyFiles.map((file) => dirname(file.path)))];
+  const sameDir = dirs.length === 1;
+  const attachmentHeader = sameDir
+    ? `[attachments${from ? `|from:${from}` : ""}] ${dirs[0]}`
+    : `[attachments${from ? `|from:${from}` : ""}]`;
+  const fileLines = sameDir
+    ? replyFiles.map((file) => `- /${basename(file.path)}`)
+    : replyFiles.map((file) => `- ${file.path}`);
+  const replyBlock = text ? `${header} ${text}` : header;
+  if (fileLines.length > 0) {
+    return `${replyBlock}\n\n${attachmentHeader}\n${fileLines.join("\n")}`;
+  }
+  if (text) return replyBlock;
+  return "";
+}
+
 export function appendTelegramReplyContext(
   text: string,
   replyContext: string,
 ): string {
   if (!replyContext) return text;
-  const replyBlock = `[reply] ${replyContext}`;
-  return text ? `${text}\n\n${replyBlock}` : `_\n\n${replyBlock}`;
+  return text ? `${text}\n\n${replyContext}` : `_\n\n${replyContext}`;
+}
+
+export function appendTelegramForwardContext(
+  text: string,
+  forwardContext: string,
+): string {
+  if (!forwardContext) return text;
+  const forwardBlock = `[forward|${forwardContext.replace(/:\s+/g, ":")}]`;
+  return text ? `\n\n${forwardBlock} ${text}` : `\n\n${forwardBlock}`;
 }
 
 export function extractTelegramMessagePromptText(
@@ -303,7 +396,7 @@ export function extractTelegramMessagePromptText(
 ): string {
   return appendTelegramReplyContext(
     extractTelegramMessageText(message),
-    extractTelegramReplyContextText(message),
+    buildTelegramReplyContextBlock(message),
   );
 }
 
@@ -321,7 +414,7 @@ export function extractTelegramMessagesPromptText(
   if (!firstMessage) return text;
   return appendTelegramReplyContext(
     text,
-    extractTelegramReplyContextText(firstMessage),
+    buildTelegramReplyContextBlock(firstMessage),
   );
 }
 

package/lib/outbound-buttons.ts

@@ -192,7 +192,7 @@ export function createTelegramButtonPromptTurn(options: {
     replyToMessageId: options.replyToMessageId,
     sourceMessageIds: [options.replyToMessageId],
     queueOrder: options.queueOrder,
-    queueLane: "default",
+    queueLane: "priority",
     laneOrder: options.queueOrder,
     queuedAttachments: [],
     content: [{ type: "text", text: prompt }],

package/lib/outbound.ts

@@ -6,8 +6,9 @@
 
 import { randomUUID } from "node:crypto";
 import { mkdir } from "node:fs/promises";
-import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
+
+import { resolveTelegramTempDir } from "./paths.ts";
 
 import {
   planTelegramButtonReply,
@@ -66,8 +67,7 @@ export function recordTelegramRuntimeEvent(
 }
 
 export type TelegramOutboundCommandTemplateConfig =
-  | string
-  | CommandTemplateObjectConfig;
+  string | CommandTemplateObjectConfig;
 export interface TelegramOutboundHandlerConfig extends CommandTemplateObjectConfig {
   type?: string;
   match?: string | string[];
@@ -448,10 +448,7 @@ function getVoiceReplyTemplateValues(
 }
 
 function getDefaultTelegramVoiceTempDir(): string {
-  const agentDir = process.env.PI_CODING_AGENT_DIR
-    ? resolve(process.env.PI_CODING_AGENT_DIR)
-    : join(homedir(), ".pi", "agent");
-  return join(agentDir, "tmp", "telegram");
+  return resolveTelegramTempDir();
 }
 
 async function generateTelegramVoiceReplyFileWithHandler(

package/lib/paths.ts

@@ -0,0 +1,77 @@
+/**
+ * Telegram bridge path resolution for Pi-compatible runtimes
+ * Zones: telemetry paths, filesystem, runtime identity
+ * Owns agent-dir detection and extension-local path derivation
+ *
+ * This domain is pure/path-only: it resolves directories and file paths
+ * from environment and runtime identity. It does not read config, manage
+ * state, or import broader Telegram domains.
+ */
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export interface TelegramAgentDirResolutionInput {
+  env?: Partial<Pick<NodeJS.ProcessEnv, "PI_CODING_AGENT_DIR">>;
+  execPath?: string;
+  argv?: readonly string[];
+}
+
+/**
+ * Resolve the agent data directory for the current Pi-compatible runtime.
+ *
+ * Precedence:
+ * 1. `PI_CODING_AGENT_DIR` env variable, when explicitly set.
+ * 2. Detect Pi-compatible runtime identity from the executable or argv[1]
+ *    (e.g. OMP vs standard Pi agent).
+ * 3. Fallback: `~/.pi/agent`.
+ */
+export function resolveAgentDir(
+  input: TelegramAgentDirResolutionInput = {},
+): string {
+  const env = input.env ?? process.env;
+  if (env.PI_CODING_AGENT_DIR) return resolve(env.PI_CODING_AGENT_DIR);
+  const execPath = input.execPath ?? process.execPath;
+  const argv = input.argv ?? process.argv;
+  const execBasename = execPath.toLowerCase().split(/[\\/]/u).pop() ?? "";
+  const argv1Last = (argv[1] ?? "").toLowerCase().split(/[\\/]/u).pop() ?? "";
+  if (execBasename.startsWith("omp") || argv1Last.startsWith("omp")) {
+    return join(homedir(), ".omp", "agent");
+  }
+  return join(homedir(), ".pi", "agent");
+}
+
+/** Telegram bridge configuration file (<agentDir>/telegram.json). */
+export function resolveTelegramConfigPath(): string {
+  return join(resolveAgentDir(), "telegram.json");
+}
+
+/** Telegram singleton lock file (<agentDir>/locks.json). */
+export function resolveTelegramLocksPath(): string {
+  return join(resolveAgentDir(), "locks.json");
+}
+
+/** Telegram bridge temporary directory (<agentDir>/tmp/telegram). */
+export function resolveTelegramTempDir(agentDir = resolveAgentDir()): string {
+  return join(agentDir, "tmp", "telegram");
+}
+
+export function getTelegramProfilePathSuffix(profileName?: string): string {
+  return profileName ? `.${profileName.replace(/[^a-zA-Z0-9._-]+/g, "_")}` : "";
+}
+
+export function resolveTelegramProfileTempFilePath(
+  baseName: string,
+  extension: string,
+  agentDir = resolveAgentDir(),
+  profileName?: string,
+): string {
+  return join(
+    resolveTelegramTempDir(agentDir),
+    `${baseName}${getTelegramProfilePathSuffix(profileName)}.${extension}`,
+  );
+}
+
+/** Runtime event log (<agentDir>/tmp/telegram/logs.jsonl). */
+export function resolveTelegramRuntimeLogPath(): string {
+  return resolveTelegramProfileTempFilePath("logs", "jsonl");
+}

package/lib/prompt-templates.ts

@@ -116,11 +116,13 @@ export function getTelegramPromptTemplateCommands(
     if (!telegramCommand) continue;
     if (reservedNames.has(telegramCommand)) continue;
     if (seen.has(telegramCommand)) continue;
+    const sourcePath = command.sourceInfo?.path;
+    if (!sourcePath) continue;
     seen.add(telegramCommand);
     promptCommands.push({
       command: telegramCommand,
       description: command.description,
-      path: command.sourceInfo.path,
+      path: sourcePath,
     });
   }
   return promptCommands.sort((a, b) => a.command.localeCompare(b.command));

package/lib/prompts.ts

@@ -15,7 +15,7 @@ Telegram bridge available. Do not use it from local/TUI prompts unless explicitl
 
 const TELEGRAM_TURN_SYSTEM_PROMPT_SUFFIX = `
 
-Telegram turn note: If context was compacted or you need the pi-telegram bridge contract, call tool \`telegram_help\`.`;
+Telegram turn note: If context was compacted or you need the pi-telegram bridge contract, call tool \`telegram_help\`; hidden comments are valid only for explicit \`telegram_voice\` or \`telegram_button\` actions with payload.`;
 
 const TELEGRAM_HELP_TEXT = `--- TELEGRAM BRIDGE HELP ---
 

package/lib/queue.ts

@@ -273,6 +273,37 @@ export function appendTelegramQueueItem<
   return [...items, item];
 }
 
+function getTelegramPromptTextSignature(item: PendingTelegramTurn): string {
+  return item.content
+    .filter((entry): entry is TelegramPromptTextContent => entry.type === "text")
+    .map((entry) => entry.text)
+    .join("\n");
+}
+
+function isDuplicateTelegramPromptTurn(
+  left: PendingTelegramTurn,
+  right: PendingTelegramTurn,
+): boolean {
+  return (
+    left.chatId === right.chatId &&
+    left.target?.threadId === right.target?.threadId &&
+    left.replyToMessageId === right.replyToMessageId &&
+    getTelegramPromptTextSignature(left) === getTelegramPromptTextSignature(right)
+  );
+}
+
+export function appendTelegramPromptTurnOnce<TContext = unknown>(
+  items: TelegramQueueItem<TContext>[],
+  turn: PendingTelegramTurn,
+): { items: TelegramQueueItem<TContext>[]; appended: boolean } {
+  assertTelegramQueueItemAdmissionValid(turn);
+  const duplicate = items.some(
+    (item) => isPendingTelegramTurn(item) && isDuplicateTelegramPromptTurn(item, turn),
+  );
+  if (duplicate) return { items, appended: false };
+  return { items: [...items, turn], appended: true };
+}
+
 export function compareTelegramQueueItems<TContext = unknown>(
   left: TelegramQueueItem<TContext>,
   right: TelegramQueueItem<TContext>,
@@ -2051,7 +2082,7 @@ export function executeTelegramQueueDispatchPlan<TContext = unknown>(
   }
   deps.onPromptDispatchStart(plan.item.chatId);
   try {
-    deps.sendUserMessage(plan.item.content, TELEGRAM_PROMPT_FOLLOW_UP_DELIVERY);
+    deps.sendUserMessage(plan.item.content);
   } catch (error) {
     const message = getTelegramQueueErrorMessage(error);
     deps.onPromptDispatchFailure(message);

package/lib/routing.ts

@@ -5,6 +5,7 @@
  */
 
 import { readFile } from "node:fs/promises";
+import { basename, dirname } from "node:path";
 import * as Commands from "./commands.ts";
 import type { TelegramConfigStore } from "./config.ts";
 import type { TelegramSectionRegistry } from "./sections.ts";
@@ -20,6 +21,31 @@ import * as TextGroups from "./text-groups.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
 import * as Turns from "./turns.ts";
 
+function formatTelegramPromptPeer(user: { id?: unknown; username?: unknown } | undefined): string | undefined {
+  if (!user) return undefined;
+  if (typeof user.username === "string" && user.username.length > 0) return user.username;
+  return typeof user.id === "number" ? String(user.id) : undefined;
+}
+
+function appendTelegramSourceAttachmentSection(
+  text: string,
+  from: string | undefined,
+  files: Pick<Media.DownloadedTelegramFile, "path">[],
+): string {
+  if (files.length === 0) return text;
+  const dirs = [...new Set(files.map((file) => dirname(file.path)))];
+  const sameDir = dirs.length === 1;
+  const source = from ? `|from:${from}` : "";
+  const header = sameDir
+    ? `[attachments${source}] ${dirs[0]}`
+    : `[attachments${source}]`;
+  const items = sameDir
+    ? files.map((file) => `/${basename(file.path)}`)
+    : files.map((file) => file.path);
+  const prefix = text.length > 0 ? `${text}\n\n` : "";
+  return `${prefix}${header}\n${items.map((item) => `- ${item}`).join("\n")}`;
+}
+
 function getContextCwd(ctx: unknown): string | undefined {
   if (!ctx || typeof ctx !== "object") return undefined;
   const cwd = (ctx as { cwd?: unknown }).cwd;
@@ -1248,22 +1274,25 @@ export function createTelegramInboundRouteRuntime<
             if (typeof chatId !== "number" || typeof messageId !== "number")
               return;
             const queueOrder = deps.bridgeRuntime.queue.allocateItemOrder();
-            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,
-              }),
-              context,
+            const turn = OutboundHandlers.createTelegramButtonPromptTurn({
+              chatId,
+              target:
+                typeof buttonQuery.message?.message_thread_id === "number"
+                  ? {
+                      chatId,
+                      threadId: buttonQuery.message.message_thread_id,
+                    }
+                  : { chatId },
+              replyToMessageId: messageId,
+              queueOrder,
+              action,
+            });
+            const result = Queue.appendTelegramPromptTurnOnce(
+              deps.telegramQueueStore.getQueuedItems(),
+              turn,
             );
+            if (!result.appended) return;
+            deps.telegramQueueStore.setQueuedItems(result.items);
             deps.updateStatus(context);
             requestDispatchNextQueuedTelegramTurn(context);
           },
@@ -1323,15 +1352,39 @@ export function createTelegramInboundRouteRuntime<
     );
     if (handledBySettings) return;
     const callbackData = query.data;
-    if (
-      deps.sendUserMessage &&
-      callbackData &&
-      !isTelegramOwnedCallbackData(callbackData)
-    ) {
-      deps.sendUserMessage(
-        `[callback] ${callbackData}`,
-        Queue.TELEGRAM_PROMPT_FOLLOW_UP_DELIVERY,
-      );
+    if (callbackData && !isTelegramOwnedCallbackData(callbackData)) {
+      const chatId = query.message?.chat?.id;
+      const messageId = query.message?.message_id;
+      if (typeof chatId === "number" && typeof messageId === "number") {
+        const queueOrder = deps.bridgeRuntime.queue.allocateItemOrder();
+        const target =
+          typeof query.message?.message_thread_id === "number"
+            ? { chatId, threadId: query.message.message_thread_id }
+            : { chatId };
+        const turn: Queue.PendingTelegramTurn = {
+          kind: "prompt",
+          chatId,
+          target,
+          replyToMessageId: messageId,
+          sourceMessageIds: [messageId],
+          queueOrder,
+          queueLane: "priority",
+          laneOrder: queueOrder,
+          queuedAttachments: [],
+          content: [{ type: "text", text: `[callback] ${callbackData}` }],
+          historyText: callbackData,
+          statusSummary: callbackData,
+        };
+        const result = Queue.appendTelegramPromptTurnOnce(
+          deps.telegramQueueStore.getQueuedItems(),
+          turn,
+        );
+        if (result.appended) {
+          deps.telegramQueueStore.setQueuedItems(result.items);
+          deps.updateStatus(ctx);
+          requestDispatchNextQueuedTelegramTurn(ctx);
+        }
+      }
       await deps.answerCallbackQuery(query.id);
       return;
     }
@@ -1345,6 +1398,7 @@ export function createTelegramInboundRouteRuntime<
     downloadFile: deps.downloadFile,
     processAttachments: deps.inboundHandlerRuntime.process,
     resolveTimeLine: deps.resolveTimeLine,
+    getAllowedUserId: deps.configStore.getAllowedUserId,
 
     // Voice policy for the current turn. Missing config still behaves as manual,
     // but only explicit telegram.json voice.replyMode is shown in prompt context.
@@ -1757,30 +1811,37 @@ export function createTelegramInboundRouteRuntime<
     const text = guestMessage.text ?? "";
     const gm = guestMessage as unknown as Record<string, unknown>;
     // Build telegram prefix with guest context
-    const fromRaw = gm.from as Record<string, unknown> | undefined;
-    const fromName =
-      (fromRaw?.username as string) || (fromRaw?.first_name as string) || "";
     const chatRaw = gm.chat as Record<string, unknown>;
     const chatTitle = chatRaw?.title as string | undefined;
     const chatType = chatRaw?.type as string;
+    const fromRaw = gm.from as Record<string, unknown> | undefined;
+    const replyMsg = gm.reply_to_message as Record<string, unknown> | undefined;
+    const replyFromRaw = replyMsg?.from as Record<string, unknown> | undefined;
+    const fromPeer = formatTelegramPromptPeer(fromRaw);
+    const replyPeer = formatTelegramPromptPeer(replyFromRaw);
+    const fromIsOwner = fromRaw?.id === deps.configStore.getAllowedUserId();
+    const guestPeer = chatType === "private" && fromIsOwner && replyPeer
+      ? replyPeer
+      : fromPeer;
     const prefixParts = ["telegram"];
-    if (fromName) prefixParts.push(`from:${fromName}`);
     if (chatType !== "private" && chatTitle) {
       prefixParts.push(`guest:${chatTitle}`);
+    } else if (chatType === "private" && guestPeer) {
+      prefixParts.push(`guest:${guestPeer}`);
     }
     const telegramPrefix = `[${prefixParts.join("|")}]`;
     // Extract reply context
-    const replyMsg = gm.reply_to_message as Record<string, unknown> | undefined;
     const replyText = replyMsg
       ? ((replyMsg.text as string) || (replyMsg.caption as string) || "").trim()
       : "";
-    const replyFrom = replyMsg
-      ? ((replyMsg.from as Record<string, unknown> | undefined)?.username as
-          | string
-          | undefined)
-      : undefined;
     // Download files, run inbound handlers
     const guestMsg = guestMessage as unknown as Media.TelegramMediaMessage;
+    const replyFiles = guestMsg.reply_to_message
+      ? await Media.downloadTelegramMessageFiles(
+          [guestMsg.reply_to_message as Media.TelegramMediaMessage],
+          { downloadFile: deps.downloadFile },
+        )
+      : [];
     const files = await Media.downloadTelegramMessageFiles([guestMsg], {
       downloadFile: deps.downloadFile,
     });
@@ -1789,13 +1850,16 @@ export function createTelegramInboundRouteRuntime<
       text,
       ctx,
     );
-    let rawText = processed.rawText || text;
-    // Append reply context after handler processing
-    if (replyText) {
-      const replyBlock = replyFrom
-        ? `[reply|from:${replyFrom}] ${replyText}`
-        : `[reply] ${replyText}`;
-      rawText = `${rawText}\n\n${replyBlock}`;
+    const rawText = processed.rawText || text;
+    let sourceContext = "";
+    if (replyMsg) {
+      const replyHeader = replyPeer ? `[reply|from:${replyPeer}]` : "[reply]";
+      const replyBlock = replyText ? `${replyHeader} ${replyText}` : replyHeader;
+      sourceContext = appendTelegramSourceAttachmentSection(
+        replyBlock,
+        replyPeer,
+        replyFiles,
+      );
     }
     const promptText = Turns.buildTelegramTurnPrompt({
       telegramPrefix,
@@ -1803,6 +1867,7 @@ export function createTelegramInboundRouteRuntime<
       files,
       promptFiles: processed.promptFiles,
       handlerOutputs: processed.handlerOutputs,
+      sourceContext,
     });
     const order = deps.bridgeRuntime.queue.allocateItemOrder();
     const content: Queue.TelegramPromptContent[] = [

package/lib/status.ts

@@ -180,6 +180,7 @@ export type TelegramBridgeBusLifecyclePhase = "electing";
 export interface TelegramBridgeStatusLineState {
   hasBotToken?: boolean;
   botUsername?: string;
+  activeProfileName?: string;
   allowedUserId?: number;
   botThreadMode?: "unknown" | "enabled" | "disabled";
   botThreadModeUpdatedAtMs?: number;
@@ -257,6 +258,7 @@ export interface TelegramBridgeStatusRuntimeDeps<
 > {
   statusKey?: string;
   getConfig: () => TelegramBridgeStatusConfig;
+  getActiveProfileName?: () => string | undefined;
   isPollingActive: () => boolean;
   getActiveSourceMessageIds: () => number[] | undefined;
   hasActiveTurn: () => boolean;
@@ -621,6 +623,7 @@ export function createTelegramBridgeStatusRuntime<
       return {
         hasBotToken: Boolean(config.botToken),
         botUsername: config.botUsername,
+        activeProfileName: deps.getActiveProfileName?.(),
         allowedUserId: config.allowedUserId,
         botThreadMode: botThreadMode?.threadMode,
         botThreadModeUpdatedAtMs: botThreadMode?.updatedAtMs,
@@ -770,7 +773,7 @@ export function buildTelegramStatusBarText(
   if (state.busLifecyclePhase === "electing")
     return `${label} ${theme.fg("warning", "electing")}${queued}`;
   if (!state.pollingActive && state.busRole !== "follower")
-    return `${label} ${theme.fg("muted", "disconnected")}${queued}`;
+    return `${theme.fg("accent", "telegram")} ${theme.fg("muted", "disconnected")}${queued}`;
   if (state.compactionInProgress) {
     return `${label} ${theme.fg("warning", "compacting")}${queued}`;
   }
@@ -1065,6 +1068,7 @@ function buildTelegramBridgeCompactStatusLines(
   return [
     "connection:",
     `- bot: ${formatTelegramBridgeBotStatus(state)}`,
+    ...(state.activeProfileName ? [`- profile: ${state.activeProfileName}`] : []),
     `- user: ${state.allowedUserId ?? "not paired"}`,
     ...(state.botThreadMode ? [`- thread mode: ${state.botThreadMode}`] : []),
     ...(state.busRole ? [`- role: ${state.busRole}`] : []),
@@ -1119,6 +1123,7 @@ export function buildTelegramBridgeDiagnosticStatusLines(
   return [
     "connection:",
     `- bot: ${formatTelegramBridgeBotStatus(state)}`,
+    ...(state.activeProfileName ? [`- profile: ${state.activeProfileName}`] : []),
     `- allowed user: ${state.allowedUserId ?? "not paired"}`,
     ...(state.botThreadMode
       ? [

package/lib/sync.ts

@@ -24,6 +24,7 @@ export interface TelegramLeaderThreadSyncDeps {
   getAllowedUserId: () => number | undefined;
   instanceId: string;
   cwd?: string;
+  telegramProfile?: string;
   forceFreshUnnamed?: boolean;
   getNowMs?: () => number;
   getRandom?: () => number;
@@ -110,7 +111,7 @@ export interface TelegramLeaderHealthRuntime {
 export interface TelegramManualThreadDisconnectDeps<TSyncState> {
   instanceId: string;
   getCurrentThreadRecord: () =>
-    | { target: TelegramTarget; instanceId?: string }
+    | { target: TelegramTarget; instanceId?: string; owner?: { kind?: string } }
     | undefined;
   topicTargetStore: Pick<
     TelegramTopicTargetStore,
@@ -160,23 +161,26 @@ export function createTelegramManualThreadDisconnectHandler<
   return async () => {
     const currentRecord = deps.getCurrentThreadRecord();
     if (currentRecord?.target.threadId) {
-      await ThreadReconciler.applyThreadReconciliationPlan(
-        ThreadReconciler.planDisconnectedInstanceThreadCleanup({
-          target: currentRecord.target as TelegramTarget & { threadId: number },
-          instanceId: deps.instanceId,
-        }),
-        {
-          callApi(method, body) {
-            return deps.callApi(method, body);
-          },
-          persist() {
-            return deps.topicTargetStore.persist();
+      const isManualFollower = currentRecord.owner?.kind === "manual-follower";
+      if (!isManualFollower) {
+        await ThreadReconciler.applyThreadReconciliationPlan(
+          ThreadReconciler.planDisconnectedInstanceThreadCleanup({
+            target: currentRecord.target as TelegramTarget & { threadId: number },
+            instanceId: deps.instanceId,
+          }),
+          {
+            callApi(method, body) {
+              return deps.callApi(method, body);
+            },
+            persist() {
+              return deps.topicTargetStore.persist();
+            },
+            recordRuntimeEvent: deps.recordRuntimeEvent,
           },
-          recordRuntimeEvent: deps.recordRuntimeEvent,
-        },
-      );
-      if (deps.topicTargetStore.markOfflineByInstanceId(deps.instanceId) > 0) {
-        await deps.topicTargetStore.persist();
+        );
+        if (deps.topicTargetStore.markOfflineByInstanceId(deps.instanceId) > 0) {
+          await deps.topicTargetStore.persist();
+        }
       }
       const leaderTarget = deps.getLeaderTarget();
       if (
@@ -360,6 +364,7 @@ export async function ensureTelegramLeaderThreadBinding(
     getAllowedUserId: deps.getAllowedUserId,
     instanceId: deps.instanceId,
     cwd: deps.cwd,
+    telegramProfile: deps.telegramProfile,
     getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
     getThreadReconciliationMachineState:
       deps.getThreadReconciliationMachineState,