@llblab/pi-telegram 0.18.5 → 0.19.0

package/docs/multi-instance-bus.md

@@ -184,7 +184,7 @@ Manual smoke checklist:
 
 1. Enable Telegram private-chat Threaded Mode for the paired bot.
 2. Start Pi in one Windows terminal and run `/telegram-connect`; verify it becomes the leader and gets a named Telegram thread.
-3. Start Pi in a second Windows terminal and run `/telegram-connect`; verify it registers as follower rather than offering takeover, creates/uses its assigned thread, and terminal status shows `<ThreadName> Follower`.
+3. Start Pi in a second Windows terminal and run `/telegram-connect`; verify it registers as follower rather than offering takeover, creates/uses its assigned thread, terminal status shows `<ThreadName> Follower` while idle, and a follower prompt flips it to `<ThreadName> Active` while work is running.
 4. From the follower thread, send a prompt that requests inline buttons; tap a button and verify the follow-up prompt queues in the follower instance.
 5. From the follower thread, request a voice reply and/or attachment; verify upload routes through the leader transport into the follower thread.
 6. Close the follower terminal; verify heartbeat pruning, disconnected notice, and cleanup behavior match Unix-like behavior.
@@ -283,6 +283,27 @@ This preserves one API bus and one set of rate-limit/retry diagnostics. The curr
 
 Every outbound request carries its target. The leader injects `message_thread_id` when `target.threadId` exists.
 
+## Leader/Follower Capability Parity Matrix
+
+Threaded Mode should make follower threads behave like normal Telegram instance surfaces, with the leader acting only as transport owner. Any feature in the matrix below that works for the leader must either work for followers or have an explicit documented exception.
+
+| Surface | Leader behavior | Follower requirement | Routing/ownership invariant | Regression evidence |
+| --- | --- | --- | --- | --- |
+| Prompt intake | Thread prompt queues locally | Thread prompt is forwarded and queued by the owning follower | Target ownership routes by `{ chatId, threadId }` before local handling | Routing tests for foreign target message forwarding |
+| Queued-message removal reactions | 👎/👻/💔/💩/🗑 removes pending prompt/media turn | Same reaction on a queued follower prompt removes that follower's pending turn before dispatch | When the leader forwards a prompt to a follower, it records `chatId/messageId -> follower instance` because Bot API reaction updates expose chat/message but not thread id | Update runtime regression records forwarded message ownership and forwards the later reaction |
+| Queue priority reactions | 👍/⚡/❤/🕊/🔥 prioritizes queued prompts | Same reactions prioritize follower queued prompts | Reaction forwarding uses stored message ownership, then follower mutates its local queue | Reaction mutation tests plus forwarded-reaction coverage |
+| Message edits | Edits update matching queued prompt text | Edits in a follower thread update that follower's queued prompt | Message target ownership forwards edits to the owning instance; stored message ownership is the fallback when Telegram edit payloads omit thread id | Update routing tests for foreign target and message-owned edited-message forwarding |
+| Callbacks/buttons/menus | Callback handled by the owning instance/menu state | Follower callbacks are forwarded to the owning follower; follower menu sends/edits/deletes route through leader transport | Leader records ownership for follower-sent Bot API messages so callbacks can route by message id even when Telegram omits thread id; Bot API edit/delete lacks thread id, so follower bus allows validated same-chat message operations | Callback forwarding, generated-button target, bus follower-sent ownership, and bus edit/delete allowlist tests |
+| Replies/finals | Final replies land in the same thread | Follower finals go through leader transport into follower thread | Outbound calls carry target and inject `message_thread_id` | Reply delivery and bus API tests |
+| Previews/Rich Drafts | Draft previews use the active thread target | Follower previews use the same native draft lifecycle through the leader | Preview transport preserves target and draft id | Preview thread-target tests |
+| Attachments/voice | Files and voice upload in the instance thread | Follower uploads route through leader multipart transport | Multipart calls are target-scoped and follower-authorized | Bus allowlist and outbound delivery tests |
+| Native activity status | `sendChatAction(typing)` shows thread Active, mirrors aggregate `All`, and terminal status flips from role to `active` during work | Follower work sends one thread action and one aggregate action through leader transport, and terminal status follows the same idle-role → active transition as leaders | Typing loop targets the active turn and avoids duplicate aggregate sends/rate-limit pressure; status rendering gives processing labels precedence over stable bus role labels | Runtime typing loop starter and status bar parity regressions |
+| Leader election / promotion | Current leader keeps its thread across reload | A promoted follower keeps its existing thread, slot, and name when elected and after later reload | Promotion converts the current follower binding into the leader profile before forced lock acquisition, so leader startup reuses it instead of provisioning a new thread | Follower heartbeat recovery passes binding snapshot into promotion; own-topic provisioner reuses promoted bindings |
+| `/start` command/menu bootstrap | Registers visible bot commands and opens the menu | Follower `/start` can refresh the bot command menu through the leader and open its local menu without warnings | Bot command registration is a validated global Bot API call allowed through trusted follower bus transport | Bus allowlist regression for `setMyCommands` |
+| Follower reconnect | Existing leader binding is reused only when still usable | Follower reconnect that points at a closed/stale Telegram tab recreates a visible thread before reporting success, and session replacement replaces any old same-profile/same-target registry entry | Same-profile reuse is probed with a connected notice; stale Bot API errors mark the old target stale and provision a fresh target; live follower target ownership never falls back to leader records | Bus leader stale reused follower-thread provisioner and bus registry/ownership regressions |
+| Unbound thread reroute/restore | New unbound thread can route to a live instance or replace the selected instance thread | Same chooser exposes all currently live bus leader/follower targets; restore is offered from concrete unbound threads, not historical snapshots | Live bus roster plus active target bindings define the selectable set; history/state snapshots are not authority | Routing chooser regressions for live target filtering and restore rows |
+| Status/menu diagnostics | Status reflects leader role, queue, and target | Follower status reflects follower role, thread name, queue, and bus health | Status is local runtime truth plus bus registration state, not leader queue state | Status and bus diagnostics tests |
+
 ## Queue And State Scoping
 
 Each instance owns its own queue and active turn state. The leader does not become a central queue scheduler for all agents; that would be a separate daemon-mode architecture.
@@ -312,7 +333,7 @@ Typical config remains just bot identity and authorization:
 Rules:
 
 - Classic mode is selected by Telegram capability: when private-chat threads are unavailable or disabled, the polling owner uses ordinary single-DM behavior and blocked instances do not register as followers. During a live downgrade from Threaded Mode, the current bus leader becomes the classic polling owner after two 2.5-second capability-monitor probes and followers disconnect; if classic polling restore fails transiently, later monitor ticks retry the restore instead of allowing a follower takeover. Followers must not turn the downgrade into a takeover while active thread bindings prove the singleton owner was already established by the bus leader.
-- Telegram private-chat Threaded Mode enables local leader/follower behavior automatically. The leader owns `getUpdates`; registered followers route Telegram API work through the leader. `/telegram-connect` registers as follower when a live leader exists and does not offer manual takeover in that state. The TUI status bar reports `telegram leader` or `telegram follower` so transport role is visible without opening diagnostics.
+- Telegram private-chat Threaded Mode enables local leader/follower behavior automatically. The leader owns `getUpdates`; registered followers route Telegram API work through the leader. `/telegram-connect` registers as follower when a live leader exists and does not offer manual takeover in that state. The TUI status bar reports `telegram leader` or `telegram follower` while idle so transport role is visible without opening diagnostics, and both roles switch to `active`/`compacting` processing labels during local Telegram work. Follower registration is unique by live profile/target: a reload or session replacement must replace stale registry entries rather than leaving multiple routable ids for one Telegram thread, and fallback target ownership must not classify leader records as followers.
 - The thread chat is the owner's private bot DM (`allowedUserId`); no `topics.chatId` config is needed. Thread names are assigned by the bridge from a baked compact per-slot palette. There is no agent-facing `telegram_rename_thread` tool and no separate user-facing slash command for manual thread renames.
 - Thread reuse is extension-owned through current live binding identity; there is no separate `topics` config surface in the active private-chat thread model. Manual followers use instance-scoped internal keys by default so multiple terminal processes in the same cwd can receive separate threads.
 - Thread cleanup remains conservative and centralized: destructive close/delete actions are planned and applied through `thread-reconciler` with proof-before-delete checks, leader-epoch fencing, and retry-preserving failure semantics.

package/index.ts

@@ -487,6 +487,7 @@ export default function (pi: Pi.ExtensionAPI) {
     getMessageText: Replies.getAgentMessageText,
     getDefaultReplyToMessageId: activeTurnRuntime.getReplyToMessageId,
     sendDraft: nativeMarkdownDraftSender,
+    canSend: configControls.areRichDraftPreviewsEnabled,
     sendMarkdownReply,
     recordRuntimeEvent,
     ...replyTransport,
@@ -662,6 +663,9 @@ export default function (pi: Pi.ExtensionAPI) {
       return telegramInstanceId;
     },
     getMessageOwnership: messageOwnershipStore.get,
+    recordMessageOwnership(input) {
+      messageOwnershipStore.record(input);
+    },
     getTargetOwnership(target) {
       return Bus.getTelegramFollowerTargetOwnership({
         target,
@@ -821,7 +825,29 @@ export default function (pi: Pi.ExtensionAPI) {
           telegramBusLifecycleOverridePhase = phase;
         },
         updateStatus,
-        async promoteToLeader(ctx) {
+        async promoteToLeader(ctx, binding) {
+          const promotedRecord =
+            await Threads.promoteTelegramFollowerBindingToLeader({
+              store: threadStore,
+              instanceId: telegramInstanceId,
+              cwd: ctx.cwd,
+              target: binding.target,
+              slot: binding.slot,
+              threadName: binding.threadName,
+            });
+          if (promotedRecord) {
+            recordRuntimeEvent(
+              "bus",
+              "Follower thread binding promoted to leader",
+              {
+                phase: "follower-promoted-binding",
+                chatId: promotedRecord.target.chatId,
+                threadId: promotedRecord.target.threadId,
+                slot: promotedRecord.slot,
+                threadName: promotedRecord.threadName,
+              },
+            );
+          }
           await lockedPollingRuntime.start(ctx, { force: true });
         },
         sleep(ms) {
@@ -898,6 +924,14 @@ export default function (pi: Pi.ExtensionAPI) {
     startPolling: pollingRuntime.start,
     stopPolling: pollingRuntime.stop,
     authorizeFollowerApiCall: Bus.isTelegramFollowerApiCallAllowed,
+    recordFollowerMessageOwnership(record) {
+      messageOwnershipStore.record({
+        chatId: record.chatId,
+        messageId: record.messageId,
+        target: record.target,
+        instanceId: record.follower.instanceId,
+      });
+    },
     provisionLeaderTarget:
       BusLeader.createTelegramBusLeaderTargetProvisioner<Pi.ExtensionContext>({
         getAllowedUserId: configStore.getAllowedUserId,
@@ -1273,8 +1307,6 @@ export default function (pi: Pi.ExtensionAPI) {
     sendRecordVoiceAction,
     sendMarkdownReply,
     sendTextReply,
-    editInteractiveMessage,
-    deleteMessage: deleteTelegramMessage,
     dispatchNextQueuedTelegramTurn,
     answerGuestQuery,
     sendGuestReply,

package/lib/bindings.ts

@@ -21,7 +21,6 @@ import * as Replies from "./replies.ts";
 import * as Runtime from "./runtime.ts";
 import * as Setup from "./setup.ts";
 import * as Status from "./status.ts";
-import * as Target from "./target.ts";
 import * as TelegramApi from "./telegram-api.ts";
 
 type ActivePiModel = NonNullable<Pi.ExtensionContext["model"]>;
@@ -166,14 +165,6 @@ interface TelegramLifecycleBindingDeps {
     Keyboard.TelegramInlineKeyboardMarkup
   >["sendTextReply"] &
     NonNullable<OutboundHandlers.TelegramVoiceReplySenderDeps["sendTextReply"]>;
-  editInteractiveMessage: (
-    chatId: number,
-    messageId: number,
-    text: string,
-    mode: "html" | "markdown",
-    replyMarkup: Keyboard.TelegramInlineKeyboardMarkup,
-  ) => Promise<void>;
-  deleteMessage: (chatId: number, messageId: number) => Promise<void>;
   dispatchNextQueuedTelegramTurn: (ctx: Pi.ExtensionContext) => void;
   answerGuestQuery: NonNullable<
     Queue.TelegramAgentEndHookRuntimeDeps<
@@ -225,8 +216,6 @@ export function registerTelegramLifecycleRuntimeHooks({
   sendRecordVoiceAction,
   sendMarkdownReply,
   sendTextReply,
-  editInteractiveMessage,
-  deleteMessage,
   dispatchNextQueuedTelegramTurn,
   answerGuestQuery,
   sendGuestReply,
@@ -367,12 +356,12 @@ export function registerTelegramLifecycleRuntimeHooks({
     onSessionBeforeCompact: compactionObserver.onSessionBeforeCompact,
     onSessionCompact: compactionObserver.onSessionCompact,
     onAgentStart: agentStartWithDedupReset,
-    async onToolExecutionStart(event, _ctx) {
+    async onToolExecutionStart(_event, _ctx) {
       agentLifecycleHooks.onToolExecutionStart();
     },
     onToolExecutionUpdate() {},
-    async onToolExecutionEnd(event, ctx) {
-      agentLifecycleHooks.onToolExecutionEnd(event, ctx);
+    async onToolExecutionEnd(_event, ctx) {
+      agentLifecycleHooks.onToolExecutionEnd(_event, ctx);
     },
     onAgentEnd: agentLifecycleHooks.onAgentEnd,
     onBeforeAgentStart: Prompts.createTelegramProactiveBeforeAgentStartHook({

package/lib/bus-follower.ts

@@ -203,16 +203,25 @@ export interface TelegramBusFollowerLeaderLock {
   busSecret?: string;
 }
 
+export interface TelegramBusFollowerPromotedBinding {
+  target?: TelegramTarget;
+  slot?: string;
+  threadName?: string;
+}
+
 export interface TelegramBusFollowerHeartbeatRecoveryHandlerDeps<TContext> {
   registrationState: Pick<
     TelegramBusFollowerRegistrationState,
-    "setRegistered"
+    "getTarget" | "getSlot" | "getThreadName" | "setRegistered"
   >;
   getRegistrationRuntime: () => TelegramBusFollowerRegistrationRuntime<TContext>;
   getLeaderState: () => TelegramBusFollowerLeaderState;
   setLifecyclePhase: (phase: "electing" | undefined) => void;
   updateStatus: (ctx: TContext) => void;
-  promoteToLeader: (ctx: TContext) => Promise<void> | void;
+  promoteToLeader: (
+    ctx: TContext,
+    binding: TelegramBusFollowerPromotedBinding,
+  ) => Promise<void> | void;
   sleep: (ms: number) => Promise<void>;
   promotionGraceMs: number;
   recordRuntimeEvent: (
@@ -511,7 +520,16 @@ export function createTelegramBusFollowerHeartbeatRecoveryHandler<TContext>(
       return false;
     }
   };
-  const promoteToLeader = async (reason: unknown, ctx: TContext) => {
+  const snapshotBinding = (): TelegramBusFollowerPromotedBinding => ({
+    target: deps.registrationState.getTarget(),
+    slot: deps.registrationState.getSlot(),
+    threadName: deps.registrationState.getThreadName(),
+  });
+  const promoteToLeader = async (
+    reason: unknown,
+    ctx: TContext,
+    binding = snapshotBinding(),
+  ) => {
     deps.setLifecyclePhase("electing");
     safeUpdateStatus(ctx);
     deps.recordRuntimeEvent("bus", reason, {
@@ -523,7 +541,7 @@ export function createTelegramBusFollowerHeartbeatRecoveryHandler<TContext>(
     deps.recordRuntimeEvent("bus", "Telegram follower elected for promotion", {
       phase: "follower-promotion-electing",
     });
-    await deps.promoteToLeader(ctx);
+    await deps.promoteToLeader(ctx, binding);
     deps.setLifecyclePhase(undefined);
     safeUpdateStatus(ctx);
     deps.recordRuntimeEvent("bus", "Telegram follower promotion completed", {
@@ -534,6 +552,7 @@ export function createTelegramBusFollowerHeartbeatRecoveryHandler<TContext>(
     if (promotionPending) return;
     promotionPending = true;
     try {
+      const initialBinding = snapshotBinding();
       const state = deps.getLeaderState();
       if (state.kind === "active-elsewhere") {
         clearRegisteredState(ctx);
@@ -565,16 +584,16 @@ export function createTelegramBusFollowerHeartbeatRecoveryHandler<TContext>(
           ) {
             return;
           }
-          await promoteToLeader(error, ctx);
+          await promoteToLeader(error, ctx, initialBinding);
           return;
         }
         if (graceState.kind === "stale" || graceState.kind === "inactive") {
-          await promoteToLeader(error, ctx);
+          await promoteToLeader(error, ctx, initialBinding);
         }
         return;
       }
       if (state.kind === "stale" || state.kind === "inactive") {
-        await promoteToLeader(error, ctx);
+        await promoteToLeader(error, ctx, initialBinding);
       }
     } catch (promotionError) {
       deps.setLifecyclePhase(undefined);

package/lib/bus-leader.ts

@@ -163,6 +163,17 @@ export interface TelegramBusFollowerRegistryRestoreDeps {
   getNowMs?: () => number;
 }
 
+export interface TelegramBusFollowerMessageOwnershipRecord {
+  follower: TelegramBusFollowerView;
+  chatId: number;
+  messageId: number;
+  target?: TelegramTarget;
+}
+
+export type TelegramBusFollowerMessageOwnershipRecorder = (
+  record: TelegramBusFollowerMessageOwnershipRecord,
+) => void;
+
 export interface TelegramBusLeaderRuntimeDeps<TContext> {
   socketPath: string;
   followerRegistry: TelegramBusFollowerRegistry;
@@ -175,6 +186,7 @@ export interface TelegramBusLeaderRuntimeDeps<TContext> {
     method: string;
     args: unknown[];
   }) => boolean;
+  recordFollowerMessageOwnership?: TelegramBusFollowerMessageOwnershipRecorder;
   provisionFollowerTarget?: (
     registration: TelegramBusInstanceRegistration,
   ) => Promise<TelegramTarget | undefined> | TelegramTarget | undefined;
@@ -325,30 +337,74 @@ export function createTelegramBusFollowerTargetProvisioner(
       registration.profileKey ?? `manual:${registration.instanceId}`;
     const followerOwner =
       Threads.getTelegramThreadOwnerFromProfileKey(followerProfileKey);
-    deps.onProvisioningStart?.();
-    let result: Threads.TelegramTopicTargetProvisionResult;
-    try {
-      result = await provision({
-        instanceId: registration.instanceId,
-        owner:
-          followerOwner.kind === "manual-follower"
-            ? followerOwner
-            : {
-                kind: "manual-follower",
-                instanceId: registration.instanceId,
-              },
-        profileKey: followerProfileKey,
-        threadName: registration.threadName,
-      });
-    } finally {
-      deps.onProvisioningEnd?.();
-    }
+    const provisionTarget = async () => {
+      deps.onProvisioningStart?.();
+      try {
+        return await provision({
+          instanceId: registration.instanceId,
+          owner:
+            followerOwner.kind === "manual-follower"
+              ? followerOwner
+              : {
+                  kind: "manual-follower",
+                  instanceId: registration.instanceId,
+                },
+          profileKey: followerProfileKey,
+          threadName: registration.threadName,
+        });
+      } finally {
+        deps.onProvisioningEnd?.();
+      }
+    };
+    let result = await provisionTarget();
     deps.setSyncState(
       Sync.markTelegramSyncSliceFresh(deps.getSyncState(), "target-bindings", {
         nowMs: getNowMs(),
         action: "follower-register",
       }),
     );
+    let connectedAnnouncement =
+      createTelegramBusInstanceLifecycleAnnouncement({
+        target: result.target,
+        threadName: result.record.threadName,
+        slot: result.record.slot,
+        state: "connected",
+      });
+    let connectedAnnouncementSent = false;
+    if (result.reused && connectedAnnouncement) {
+      try {
+        await deps.callApi("sendMessage", {
+          chat_id: connectedAnnouncement.target.chatId,
+          message_thread_id: connectedAnnouncement.target.threadId,
+          text: connectedAnnouncement.text,
+          parse_mode: connectedAnnouncement.parseMode,
+        });
+        connectedAnnouncementSent = true;
+      } catch (error) {
+        deps.recordRuntimeEvent("telegram", error, {
+          phase: "follower-topic-reuse-probe",
+          instanceId: registration.instanceId,
+          chatId: result.target.chatId,
+          threadId: result.target.threadId,
+        });
+        if (Threads.isTelegramTopicTargetStaleError(error)) {
+          deps.topicTargetStore.markStaleByTarget(
+            result.target,
+            "deleted",
+            "Follower registration found the reusable thread target stale.",
+          );
+          await deps.topicTargetStore.persist();
+          result = await provisionTarget();
+          connectedAnnouncement = createTelegramBusInstanceLifecycleAnnouncement({
+            target: result.target,
+            threadName: result.record.threadName,
+            slot: result.record.slot,
+            state: "connected",
+          });
+          connectedAnnouncementSent = false;
+        }
+      }
+    }
     recordSlowTelegramBusFollowerRegistrationStep(deps, {
       phase: "follower-register-critical",
       elapsedMs: Date.now() - registrationStartedAtMs,
@@ -356,16 +412,9 @@ export function createTelegramBusFollowerTargetProvisioner(
       target: result.target,
       reused: result.reused,
     });
-    const connectedAnnouncement =
-      createTelegramBusInstanceLifecycleAnnouncement({
-        target: result.target,
-        threadName: result.record.threadName,
-        slot: result.record.slot,
-        state: "connected",
-      });
     scheduleTelegramBusLeaderBackgroundTask(async () => {
       const backgroundStartedAtMs = Date.now();
-      if (connectedAnnouncement) {
+      if (connectedAnnouncement && !connectedAnnouncementSent) {
         try {
           await deps.callApi("sendMessage", {
             chat_id: connectedAnnouncement.target.chatId,
@@ -579,6 +628,7 @@ export function createTelegramBusLeaderEnvelopeHandler(deps: {
     method: string;
     args: unknown[];
   }) => boolean;
+  recordFollowerMessageOwnership?: TelegramBusFollowerMessageOwnershipRecorder;
   provisionFollowerTarget?: (
     registration: TelegramBusInstanceRegistration,
   ) => Promise<TelegramTarget | undefined> | TelegramTarget | undefined;
@@ -706,6 +756,72 @@ export function createTelegramBusLeaderEnvelopeHandler(deps: {
   };
 }
 
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as Record<string, unknown>)
+    : undefined;
+}
+
+function asInteger(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isInteger(value)) return value;
+  if (typeof value !== "string" || value.trim() === "") return undefined;
+  const parsed = Number(value);
+  return Number.isInteger(parsed) ? parsed : undefined;
+}
+
+function getFollowerApiMethodAndBody(envelope: Extract<TelegramBusEnvelope, { kind: "follower.callApi" }>): {
+  apiMethod: string;
+  body?: Record<string, unknown>;
+} {
+  if (envelope.method === "call" || envelope.method === "callMultipart") {
+    return {
+      apiMethod:
+        typeof envelope.args[0] === "string" ? envelope.args[0] : "",
+      body: asRecord(envelope.args[1]),
+    };
+  }
+  return { apiMethod: envelope.method, body: asRecord(envelope.args[0]) };
+}
+
+function getSentMessageIds(result: unknown): number[] {
+  const values = Array.isArray(result) ? result : [result];
+  return values
+    .map((value) => asInteger(asRecord(value)?.message_id))
+    .filter((messageId): messageId is number => messageId !== undefined);
+}
+
+function recordFollowerApiMessageOwnership(input: {
+  envelope: Extract<TelegramBusEnvelope, { kind: "follower.callApi" }>;
+  follower: TelegramBusFollowerView;
+  result: unknown;
+  record?: TelegramBusFollowerMessageOwnershipRecorder;
+}): void {
+  if (!input.record) return;
+  const { apiMethod, body } = getFollowerApiMethodAndBody(input.envelope);
+  if (
+    apiMethod !== "sendMessage" &&
+    apiMethod !== "sendRichMessage" &&
+    apiMethod !== "sendPhoto" &&
+    apiMethod !== "sendDocument" &&
+    apiMethod !== "sendVoice" &&
+    apiMethod !== "sendMediaGroup"
+  ) {
+    return;
+  }
+  const chatId = asInteger(body?.chat_id) ?? input.follower.target?.chatId;
+  if (chatId === undefined) return;
+  const threadId = asInteger(body?.message_thread_id) ?? input.follower.target?.threadId;
+  const target = threadId !== undefined ? { chatId, threadId } : { chatId };
+  for (const messageId of getSentMessageIds(input.result)) {
+    input.record({
+      follower: input.follower,
+      chatId,
+      messageId,
+      target,
+    });
+  }
+}
+
 async function handleFollowerApiCall(
   envelope: Extract<TelegramBusEnvelope, { kind: "follower.callApi" }>,
   deps: {
@@ -717,6 +833,7 @@ async function handleFollowerApiCall(
       method: string;
       args: unknown[];
     }) => boolean;
+    recordFollowerMessageOwnership?: TelegramBusFollowerMessageOwnershipRecorder;
   },
 ): Promise<TelegramBusEnvelope> {
   const follower = deps.followerRegistry.get(envelope.instanceId);
@@ -753,11 +870,18 @@ async function handleFollowerApiCall(
     };
   }
   try {
+    const result = await deps.callApi(envelope.method, envelope.args);
+    recordFollowerApiMessageOwnership({
+      envelope,
+      follower,
+      result,
+      record: deps.recordFollowerMessageOwnership,
+    });
     return {
       kind: "bus.ack",
       requestId: envelope.requestId,
       ok: true,
-      result: await deps.callApi(envelope.method, envelope.args),
+      result,
     };
   } catch (error) {
     return {
@@ -882,6 +1006,7 @@ export function createTelegramBusLeaderRuntime<TContext>(
       getNowMs,
       callApi: deps.callApi,
       authorizeFollowerApiCall: deps.authorizeFollowerApiCall,
+      recordFollowerMessageOwnership: deps.recordFollowerMessageOwnership,
       provisionFollowerTarget: deps.provisionFollowerTarget,
     }),
   });

package/lib/bus.ts

@@ -79,6 +79,8 @@ export function getTelegramFollowerTargetOwnership(input: {
   activeThreadRecords?: Array<{
     status?: string;
     instanceId?: string;
+    profileKey?: string;
+    owner?: { kind?: string };
     target: TelegramTarget;
   }>;
   currentInstanceId?: string;
@@ -91,7 +93,11 @@ export function getTelegramFollowerTargetOwnership(input: {
   });
   if (liveFollower) return { instanceId: liveFollower.instanceId };
   const record = input.activeThreadRecords?.find((candidate) => {
+    const isFollowerRecord = candidate.owner?.kind
+      ? candidate.owner.kind === "manual-follower"
+      : candidate.profileKey?.startsWith("manual:") === true;
     return (
+      isFollowerRecord &&
       candidate.status === "active" &&
       candidate.instanceId &&
       candidate.instanceId !== input.currentInstanceId &&
@@ -144,6 +150,28 @@ export function isTelegramFollowerApiCallAllowed(input: {
     const record = body as Record<string, unknown>;
     return matchesId(record.chat_id, target.chatId);
   };
+  const isTargetMessageScoped = (body: unknown): boolean => {
+    if (!isTargetChatScoped(body)) return false;
+    const messageId = (body as Record<string, unknown>).message_id;
+    const parsedMessageId =
+      typeof messageId === "number" ? messageId : Number(messageId);
+    return Number.isInteger(parsedMessageId) && matchesId(messageId, parsedMessageId);
+  };
+  const isBotCommandRegistration = (body: unknown): boolean => {
+    if (!body || typeof body !== "object" || Array.isArray(body)) return false;
+    const commands = (body as Record<string, unknown>).commands;
+    return (
+      Array.isArray(commands) &&
+      commands.every(
+        (command) =>
+          command &&
+          typeof command === "object" &&
+          !Array.isArray(command) &&
+          typeof (command as Record<string, unknown>).command === "string" &&
+          typeof (command as Record<string, unknown>).description === "string",
+      )
+    );
+  };
   if (input.method === "downloadFile") return true;
   if (input.method === "call") {
     const apiMethod = input.args[0];
@@ -155,7 +183,12 @@ export function isTelegramFollowerApiCallAllowed(input: {
       return true;
     }
     if (apiMethod === "getMe") return true;
+    if (apiMethod === "setMyCommands")
+      return isBotCommandRegistration(input.args[1]);
     if (apiMethod === "sendChatAction") return isTargetChatScoped(input.args[1]);
+    if (apiMethod === "deleteMessage" || apiMethod === "editMessageText") {
+      return isTargetMessageScoped(input.args[1]);
+    }
     return allowedCallMethods.has(apiMethod) && isTargetScoped(input.args[1]);
   }
   if (input.method === "callMultipart") {
@@ -728,6 +761,17 @@ export function createTelegramBusFollowerRegistry(): TelegramBusFollowerRegistry
   return {
     register: (registration) => {
       const existing = followers.get(registration.instanceId);
+      for (const [instanceId, follower] of followers.entries()) {
+        if (instanceId === registration.instanceId) continue;
+        const sameProfile =
+          registration.profileKey !== undefined &&
+          registration.profileKey === follower.profileKey;
+        const sameTarget =
+          registration.target !== undefined &&
+          follower.target?.chatId === registration.target.chatId &&
+          follower.target.threadId === registration.target.threadId;
+        if (sameProfile || sameTarget) followers.delete(instanceId);
+      }
       const next: TelegramBusFollowerView = {
         ...registration,
         target: registration.target ? { ...registration.target } : undefined,

package/lib/config.ts

@@ -57,6 +57,7 @@ export interface TelegramConfig {
   attachmentHandlers?: TelegramInboundHandlerConfig[];
   outboundHandlers?: TelegramOutboundHandlerConfig[];
   proactivePush?: boolean;
+  richDraftPreviews?: boolean;
   voice?: {
     replyMode?: "manual" | "mirror" | "always";
     /** Whether to attach the provider's transcriptText as caption on voice messages */
@@ -259,6 +260,23 @@ export function createTelegramProactivePushSetter(
   };
 }
 
+export function createTelegramRichDraftPreviewsChecker(
+  configStore: Pick<TelegramConfigStore, "get">,
+): () => boolean {
+  return () => configStore.get().richDraftPreviews ?? false;
+}
+
+export function createTelegramRichDraftPreviewsSetter(
+  configStore: TelegramMutableConfigStore,
+): (enabled: boolean) => Promise<void> {
+  return async (enabled) => {
+    await loadLatestTelegramConfig(configStore);
+    const config = { ...configStore.get(), richDraftPreviews: enabled };
+    configStore.set(config);
+    await configStore.persist(config);
+  };
+}
+
 export function createTelegramVoiceReplyModeGetter(
   configStore: Pick<TelegramConfigStore, "get">,
 ): () => "manual" | "mirror" | "always" {
@@ -394,6 +412,10 @@ export function createTelegramConfigControls(
   return {
     isProactivePushEnabled: createTelegramProactivePushChecker(configStore),
     setProactivePushEnabled: createTelegramProactivePushSetter(configStore),
+    areRichDraftPreviewsEnabled:
+      createTelegramRichDraftPreviewsChecker(configStore),
+    setRichDraftPreviewsEnabled:
+      createTelegramRichDraftPreviewsSetter(configStore),
     getVoiceReplyMode: createTelegramVoiceReplyModeGetter(configStore),
     isVoiceReplyModeConfigured:
       createTelegramVoiceReplyModeConfiguredChecker(configStore),