@llblab/pi-telegram 0.18.5 → 0.18.6

package/AGENTS.md

@@ -126,6 +126,7 @@ The core product loop is mobile continuation: start or supervise work in the ter
 - Keep globally reusable rules as independent bullets in the most general applicable section of `AGENTS.md`; do not hide a cross-cutting rule inside one local feature paragraph just because that feature revealed it.
 - Local/domain bullets should state how a general rule applies there, or record domain-specific exceptions; they should not be the only source for a rule that applies to multiple tools, transports, domains, or docs surfaces.
 - Pi-facing tool results shown in compact tool rows should start with exactly one leading newline (`\nResult`) so the result is visually separated from the tool-call header by one blank line without excessive vertical spacing.
+- For non-trivial implementation, release, or architecture-audit work, run an `AGENTS.md` compliance pass: reread the durable principles and relevant project docs, map the changed behavior to the rules it touches, validate code/tests/docs against those rules, and explicitly surface any rule conflict, obsolete rule, or evidence-backed improvement. When the rules themselves drift from the product reality, update `AGENTS.md` or document a deliberate exception in the same pass instead of silently working around it.
 
 ## 6.2 Validation Hotspots
 
@@ -221,14 +222,14 @@ The canonical detailed ownership map lives in [`docs/architecture.md`](./docs/ar
 - `Section domain ownership`: `lib/sections.ts` owns the registry, token mapping, callback dispatch, and context building. `lib/menu.ts` dispatches `section:` callbacks before built-in handling. `lib/menu-status.ts` injects section rows. `lib/menu-settings.ts` injects settings rows and passes `sectionRegistry` through callback deps
 - `Callback routing order`: button actions → compact confirmations → queue menu → settings menu → section callbacks → built-in menu handling → `[callback]` fallback. Settings menu callbacks always pass `sectionRegistry` to `updateTelegramSettingsMenuMessage` and `handleTelegramSettingsMenuCallbackAction`
 
-## 9. Pre-Task Preparation Protocol
+## 10. Pre-Task Preparation Protocol
 
 - Read `README.md` for current user-facing behavior and fork positioning
 - Read `BACKLOG.md` before changing runtime behavior or documentation so open work stays truthful
 - Read `/docs/architecture.md` before restructuring queue, preview, rendering, or command-handling logic
 - Inspect the relevant `index.ts` section before editing because most bridge behavior is stateful and cross-linked
 
-## 10. Task Completion Protocol
+## 11. Task Completion Protocol
 
 - Run the smallest meaningful validation for the touched area; `npm test` is the default regression suite once rendering or queue logic changes
 - For rendering changes, ensure regressions still cover nested lists, code blocks, underscore-heavy text, and long-message chunking

package/BACKLOG.md

@@ -1,21 +1,16 @@
 # Project Backlog
 
-_Current deterministic status: Threaded Mode implementation, native typing/activity status, regression coverage, docs/context reconciliation, typecheck, full tests, pack check, audit, Domain DAG validation, context validation, core live Threaded Mode smoke, and native Windows classic↔Threaded Mode upgrade/downgrade smoke are green. This backlog intentionally tracks only release-relevant remaining work: evidence-gated Telegram client/runtime follow-ups and upstream Pi API blockers._
+_Current deterministic status: Threaded Mode implementation, native typing/activity status, regression coverage, docs/context reconciliation, typecheck, full tests, pack check, audit, Domain DAG validation, context validation, native Windows classic↔Threaded Mode upgrade/downgrade smoke, and live post-reload leader/follower prompt routing, follower Active parity, and unbound reroute/restore smoke are green. This backlog intentionally tracks only release-relevant remaining work: evidence-gated Telegram client/runtime follow-ups and upstream Pi API blockers._
 
-## P0 — Live Threaded Mode Regression Sweep
+## P0 — Promoted Follower Reload Smoke
 
-Context: live Linux testing exposed regressions around prompt dispatch readiness, visible thread rename noise during automatic leader reclaim, status thread-name fallback flicker, and follower voice/update forwarding health. These are local runtime correctness issues and must be validated before returning to Windows smoke.
+Context: deterministic coverage protects promoted follower thread preservation, and the latest live Linux smoke closed the reload routing, follower Active, and reroute/restore regressions. Keep one explicit live check for promoted-follower reload identity unless that exact path is covered in the release smoke pass.
 
 Open work:
 
-- [ ] Live smoke on Linux with one leader and one follower:
-  - [ ] dirty-state pass with old `state.json`/`logs.jsonl` present to prove live locks, bus registration, target ownership, and reconciliation override stale diagnostics;
-  - [ ] leader reload recovers without duplicate visible thread renames;
-  - [ ] prompts dispatch without a second command;
-  - [ ] status remains stable around thread name and role while active turns start/end.
-- [ ] Add/keep proactive race protections so `state.json` never becomes authoritative over live lock ownership, bus registration, or current target identity.
+- [ ] Close leader → follower promotes → `/reload` promoted leader preserves the same Telegram thread identity.
 
-Done when: local Linux live Threaded Mode smoke is stable for leader reload, follower connect, prompt dispatch, voice forwarding, and status naming without visible rename noise.
+Done when: promoted-follower reload identity has live Telegram evidence or is deliberately deferred out of the hotfix scope.
 
 ## P1 — Native Windows Threaded Mode Follow-Ups
 

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## Unreleased
+
+## 0.18.6: Threaded Mode parity hotfix
+
+- `[Threaded Mode]` Follower-routed prompts now record message ownership when the leader forwards them by thread target, and edited messages can route by stored message ownership when Telegram omits thread identity. Impact: later queue-control reactions and queued-prompt edits on the original Telegram message route back to the owning follower instead of being handled by the leader.
+- `[Native Activity Status]` Follower typing/activity startup now sends one thread-scoped action plus one aggregate action, and the default keepalive cadence is back to 2.5 seconds. Impact: follower `...active` status avoids duplicate chat-action bursts that can hit Telegram rate limits.
+- `[Threaded Mode]` Follower `/start` can now register the visible bot command menu through the leader bus without a warning before opening the local menu, follower-sent Bot API messages are recorded in the leader's ownership map, and follower message edit/delete calls used by menu surfaces are allowed as validated same-chat message operations. Impact: follower menu callbacks and interactive cleanup route back to the owning follower even when Telegram callback payloads omit thread identity, without false bus-allowlist failures.
+- `[Threaded Mode]` Follower promotion now snapshots the current follower thread binding before clearing registration state and converts that binding into the leader profile before forced lock acquisition. Impact: an elected follower keeps its existing thread identity across promotion and later reload instead of becoming disconnected or provisioning a fresh leader thread.
+- `[Threaded Mode]` Follower registration now probes a reused same-profile thread with the connected notice before reporting it as reusable, and recreates the thread when Telegram reports the old target as stale. Impact: reconnecting a follower after its Telegram tab was closed no longer leaves the terminal showing a follower thread name while no matching Telegram thread is visible.
+- `[Threaded Mode]` Unbound-thread reroute controls now expose replace/restore for the current live bus roster instead of requiring prior leader reroute confirmation. Impact: when a new unbound Telegram thread appears, the operator can choose any currently live leader/follower instance to route to or replace/restore into that source thread.
+- `[Status]` Follower terminal status now gives active/compacting processing labels precedence over the stable follower role, matching leader behavior. Impact: a follower shows its thread name plus `active` while processing a Telegram-originated prompt, then returns to `follower` when idle.
+- `[Threaded Mode]` Reload-time target ownership now classifies only follower-owned records as follower targets and replaces stale same-profile/same-target follower registry entries on registration. Impact: after leader or follower reload, Telegram prompts and reroutes no longer get forwarded to dead instance ids or report a live thread as unavailable.
+- `[Validation]` Live Linux Threaded Mode smoke now passes for post-reload leader/follower prompt routing, unbound reroute/restore, and leader/follower terminal Active status. Impact: the hotfix candidate has Telegram-client evidence for the regressions fixed after `0.18.5`.
+- `[Docs]` Added a leader/follower capability parity matrix covering prompts, queue reactions, edits, callbacks, replies, previews, attachments, native activity, command/menu bootstrap, and diagnostics. Impact: follower behavior now has an explicit parity checklist instead of being inferred from leader behavior.
+- `[Engineering]` Formalized an `AGENTS.md` compliance pass for non-trivial work and cleaned unused runtime/lifecycle test surfaces surfaced by strict no-unused diagnostics. Impact: future changes have an explicit project-rule audit step, and dead-code diagnostics stay actionable.
+
 ## 0.18.5: Windows Threaded Mode stabilization hotfix
 
 - `[Bus Transport]` Introduced an explicit local bus transport boundary for endpoint derivation, socket-vs-pipe detection, operation-aware retry policy, timeout/transient IPC error classification, endpoint reachability probes, request-scoped server/client transport events, and handler-failure ACKs instead of silent client timeouts. Impact: Unix socket behavior remains the stable baseline while Windows named-pipe readiness and retry behavior are contained in the transport layer instead of leaking into routing.

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

@@ -662,6 +662,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 +824,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 +923,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 +1306,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/routing.ts

@@ -217,21 +217,13 @@ function formatTelegramAllTabMenuChooserText(command: string): string {
 function buildTelegramUnboundRerouteChooserMarkup(
   rerouteId: string,
   records: readonly Threads.TelegramTopicTargetRecord[],
-  options: {
+  _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 canRestoreAnyLiveThread = activeRecords.length > 0;
   const rows = activeRecords.map((record) => [
     {
       text: getTelegramRouteThreadButtonLabel(record),
@@ -242,7 +234,7 @@ function buildTelegramUnboundRerouteChooserMarkup(
     },
   ]);
   return {
-    inline_keyboard: canRestoreCurrentLeader
+    inline_keyboard: canRestoreAnyLiveThread
       ? [
           ...rows,
           [
@@ -414,6 +406,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   getCurrentInstanceId?: () => string | undefined;
   getMessageOwnership?: Updates.TelegramMessageOwnershipLookup;
   getTargetOwnership?: Updates.TelegramTargetOwnershipLookup;
+  recordMessageOwnership?: Updates.TelegramMessageOwnershipRecorder;
   getLiveThreadTargets?: () => Queue.TelegramQueueTarget[];
   getLocalThreadLabelForTarget?: (
     target: Queue.TelegramQueueTarget,
@@ -1861,6 +1854,7 @@ export function createTelegramInboundRouteRuntime<
     getCurrentInstanceId: deps.getCurrentInstanceId,
     getMessageOwnership: deps.getMessageOwnership,
     getTargetOwnership: deps.getTargetOwnership,
+    recordMessageOwnership: deps.recordMessageOwnership,
     handleTelegramTopicLifecycleUpdate,
     foreignOwnedUpdateForwarder: deps.foreignOwnedUpdateForwarder,
     setAllowedUserId: deps.configStore.setAllowedUserId,

package/lib/runtime.ts

@@ -4,7 +4,7 @@
  * Owns small session-local runtime primitives that are shared by orchestration but are not specific to queueing, rendering, polling, or Telegram transport
  */
 
-const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 1500;
+const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 2500;
 const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 
 export interface TelegramRuntimeQueueCounters {
@@ -398,13 +398,9 @@ export function createTelegramTypingLoopStarter<TContext>(
       chatId: chatId ?? deps.getDefaultChatId(),
       target: options?.target,
       intervalMs: deps.intervalMs ?? TELEGRAM_TYPING_ACTION_INTERVAL_MS,
-      sendTypingAction: async (targetChatId) => {
+      sendTypingAction: async (targetChatId, actionOptions) => {
         try {
-          const threadParams = getTelegramTypingLoopThreadParams(options?.target);
-          await deps.sendTypingAction(targetChatId, threadParams);
-          if (threadParams?.message_thread_id !== undefined) {
-            await deps.sendAggregateTypingAction?.(targetChatId);
-          }
+          await deps.sendTypingAction(targetChatId, actionOptions);
         } catch (error) {
           const message =
             error instanceof Error ? error.message : String(error);
@@ -419,6 +415,26 @@ export function createTelegramTypingLoopStarter<TContext>(
           });
         }
       },
+      sendAggregateTypingAction: deps.sendAggregateTypingAction
+        ? async (targetChatId) => {
+            try {
+              await deps.sendAggregateTypingAction?.(targetChatId);
+            } catch (error) {
+              const message =
+                error instanceof Error ? error.message : String(error);
+              updateTelegramRuntimeStatusSafely(deps.updateStatus, ctx, {
+                error: message,
+                category: "typing",
+                phase: "status-update",
+                recordRuntimeEvent: deps.recordRuntimeEvent,
+              });
+              deps.recordRuntimeEvent?.("typing", error, {
+                chatId: targetChatId,
+                aggregate: true,
+              });
+            }
+          }
+        : undefined,
     });
   };
 }

package/lib/status.ts

@@ -771,8 +771,6 @@ export function buildTelegramStatusBarText(
     return `${label} ${theme.fg("warning", "electing")}${queued}`;
   if (!state.pollingActive && state.busRole !== "follower")
     return `${label} ${theme.fg("muted", "disconnected")}${queued}`;
-  if (state.busRole === "follower")
-    return `${label} ${theme.fg("success", "follower")}${queued}`;
   if (state.compactionInProgress) {
     return `${label} ${theme.fg("warning", "compacting")}${queued}`;
   }
@@ -784,6 +782,8 @@ export function buildTelegramStatusBarText(
       processingStatus === "active" ? "warning" : "accent";
     return `${label} ${theme.fg(processingToken, processingStatus)}${queued}`;
   }
+  if (state.busRole === "follower")
+    return `${label} ${theme.fg("success", "follower")}${queued}`;
   if (state.busRole === "leader")
     return `${label} ${theme.fg("success", "leader")}`;
   return `${label} ${theme.fg("success", "connected")}`;

package/lib/threads.ts

@@ -1438,7 +1438,7 @@ function getTelegramThreadNameEntropyIndex(
 
 export function getTelegramTopicThreadNameValidationError(
   threadName: string,
-  slot: string | undefined,
+  _slot: string | undefined,
 ): string | undefined {
   const identity = getTelegramTopicIdentityName(threadName);
   const reasons: string[] = [];
@@ -1501,6 +1501,60 @@ function asInteger(value: unknown): number | undefined {
   return Number.isInteger(parsed) ? parsed : undefined;
 }
 
+export interface TelegramPromoteFollowerBindingToLeaderDeps {
+  store: TelegramTopicTargetStore;
+  instanceId: string;
+  cwd?: string;
+  target?: TelegramTarget;
+  slot?: string;
+  threadName?: string;
+  nowMs?: number;
+}
+
+export async function promoteTelegramFollowerBindingToLeader(
+  deps: TelegramPromoteFollowerBindingToLeaderDeps,
+): Promise<TelegramTopicTargetRecord | undefined> {
+  const target = deps.target;
+  if (typeof target?.threadId !== "number") return undefined;
+  await deps.store.load();
+  const nowMs = deps.nowMs ?? Date.now();
+  const existing = deps.store
+    .list()
+    .find(
+      (record) =>
+        record.target.chatId === target.chatId &&
+        record.target.threadId === target.threadId,
+    );
+  const owner: TelegramThreadOwner = {
+    kind: "leader",
+    cwd: deps.cwd,
+    instanceId: deps.instanceId,
+  };
+  const record = deps.store.upsert({
+    profileKey: getTelegramThreadOwnerKey(owner),
+    owner,
+    target: { chatId: target.chatId, threadId: target.threadId },
+    status: "active",
+    createdAtMs: existing?.createdAtMs ?? nowMs,
+    updatedAtMs: nowMs,
+    ...(existing?.threadName ?? deps.threadName
+      ? { threadName: existing?.threadName ?? deps.threadName }
+      : {}),
+    instanceId: deps.instanceId,
+    ...(existing?.slot ?? deps.slot ? { slot: existing?.slot ?? deps.slot } : {}),
+    ...(existing?.syncStatus ? { syncStatus: existing.syncStatus } : {}),
+    ...(existing?.lastSyncObservedAtMs !== undefined
+      ? { lastSyncObservedAtMs: existing.lastSyncObservedAtMs }
+      : {}),
+    lastReconcileAction: "follower-promoted-to-leader",
+    ...(existing?.rerouteConfirmedAtMs !== undefined
+      ? { rerouteConfirmedAtMs: existing.rerouteConfirmedAtMs }
+      : {}),
+  });
+  await deps.store.persist();
+  return record;
+}
+
 export interface TelegramOwnTopicProvisionDeps {
   getAllowedUserId: () => number | undefined;
   instanceId: string;
@@ -2077,7 +2131,7 @@ export function createTelegramTopicTargetProvisioner(
           existing.threadName ?? identityThreadName ?? bakedThreadName,
         instanceId: request.instanceId,
         slot,
-        owner: existing.owner ?? request.owner,
+        owner: request.owner ?? existing.owner,
         lastError: undefined,
       });
       return { target: record.target, reused: true, record };

package/lib/updates.ts

@@ -9,6 +9,7 @@ import {
   createTelegramThreadTarget,
   type TelegramTarget,
 } from "./target.ts";
+import type { TelegramMessageOwnershipStore } from "./ownership.ts";
 import {
   createTelegramUserPairingRuntime,
   getTelegramAuthorizationState,
@@ -538,6 +539,14 @@ export function buildTelegramUpdateExecutionPlanFromUpdate<
 
 // --- Runtime ---
 
+export type TelegramMessageOwnershipRecorderInput = Parameters<
+  TelegramMessageOwnershipStore["record"]
+>[0];
+
+export type TelegramMessageOwnershipRecorder = (
+  input: TelegramMessageOwnershipRecorderInput,
+) => void;
+
 export interface TelegramUpdateRuntimeDeps<
   TContext = unknown,
   TReactionUpdate extends TelegramMessageReactionUpdated =
@@ -549,6 +558,7 @@ export interface TelegramUpdateRuntimeDeps<
   getCurrentInstanceId?: () => string | undefined;
   getMessageOwnership?: TelegramMessageOwnershipLookup;
   getTargetOwnership?: TelegramTargetOwnershipLookup;
+  recordMessageOwnership?: TelegramMessageOwnershipRecorder;
   foreignOwnedUpdateForwarder?: TelegramForeignOwnedUpdateForwarder<
     TContext,
     TReactionUpdate,
@@ -612,6 +622,7 @@ export interface TelegramUpdateRuntimeControllerDeps<
   getCurrentInstanceId?: () => string | undefined;
   getMessageOwnership?: TelegramMessageOwnershipLookup;
   getTargetOwnership?: TelegramTargetOwnershipLookup;
+  recordMessageOwnership?: TelegramMessageOwnershipRecorder;
   foreignOwnedUpdateForwarder?: TelegramForeignOwnedUpdateForwarder<
     TContext,
     TelegramMessageReactionUpdated,
@@ -824,6 +835,7 @@ export function createTelegramPairedUpdateRuntime<
     getCurrentInstanceId: deps.getCurrentInstanceId,
     getMessageOwnership: deps.getMessageOwnership,
     getTargetOwnership: deps.getTargetOwnership,
+    recordMessageOwnership: deps.recordMessageOwnership,
     handleTelegramTopicLifecycleUpdate: deps.handleTelegramTopicLifecycleUpdate,
     foreignOwnedUpdateForwarder: deps.foreignOwnedUpdateForwarder,
     removePendingMediaGroupMessages: deps.removePendingMediaGroupMessages,
@@ -890,6 +902,7 @@ export function createTelegramUpdateRuntime<
         getCurrentInstanceId: deps.getCurrentInstanceId,
         getMessageOwnership: deps.getMessageOwnership,
         getTargetOwnership: deps.getTargetOwnership,
+        recordMessageOwnership: deps.recordMessageOwnership,
         foreignOwnedUpdateForwarder: deps.foreignOwnedUpdateForwarder,
         removePendingMediaGroupMessages: deps.removePendingMediaGroupMessages,
         removeQueuedTelegramTurnsByMessageIds:
@@ -1109,11 +1122,40 @@ export async function executeTelegramUpdatePlan<
       }
       return;
     }
+    const foreignMessageOwnership = getForeignTelegramMessageOwnership(
+      getTelegramMessageReplyTarget(plan.message),
+      deps,
+    );
+    if (foreignMessageOwnership) {
+      if (plan.kind === "edited-message") {
+        await deps.foreignOwnedUpdateForwarder?.forwardEditedMessage?.({
+          message: plan.message,
+          ownership: foreignMessageOwnership,
+          ctx: deps.ctx,
+        });
+      } else {
+        await deps.foreignOwnedUpdateForwarder?.forwardMessage?.({
+          message: plan.message,
+          ownership: foreignMessageOwnership,
+          ctx: deps.ctx,
+        });
+      }
+      return;
+    }
+    const messageTarget = getTelegramMessageTarget(plan.message);
     const foreignTargetOwnership = getForeignTelegramTargetOwnership(
-      getTelegramMessageTarget(plan.message),
+      messageTarget,
       deps,
     );
     if (foreignTargetOwnership) {
+      if (typeof plan.message.message_id === "number") {
+        deps.recordMessageOwnership?.({
+          chatId: messageTarget!.chatId,
+          messageId: plan.message.message_id,
+          target: messageTarget,
+          instanceId: foreignTargetOwnership.instanceId,
+        });
+      }
       if (plan.kind === "edited-message") {
         await deps.foreignOwnedUpdateForwarder?.forwardEditedMessage?.({
           message: plan.message,
@@ -1129,7 +1171,6 @@ export async function executeTelegramUpdatePlan<
       }
       return;
     }
-    const messageTarget = getTelegramMessageTarget(plan.message);
     if (
       plan.kind === "message" &&
       messageTarget?.threadId != null &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@llblab/pi-telegram",
-  "version": "0.18.5",
+  "version": "0.18.6",
   "private": false,
   "publishConfig": {
     "access": "public"