@llblab/pi-telegram 0.27.11 → 0.28.0

package/lib/lifecycle.ts

@@ -229,6 +229,7 @@ export interface TelegramBridgeSessionServiceRuntime {
       ctx: ExtensionContext,
     ): Promise<void>;
   };
+  inboundWorker: { onSessionShutdown(): Promise<void> };
   capabilityMonitor: { start(ctx: ExtensionContext): void; stop(): void };
   queueWatchdog: { start(ctx: ExtensionContext): void; stop(): void };
 }
@@ -283,6 +284,7 @@ export interface TelegramBridgeSessionLifecyclePorts<
     };
     delivery: TelegramBridgeSessionServiceRuntime["delivery"];
     polling: TelegramBridgeSessionServiceRuntime["polling"];
+    inboundWorker: TelegramBridgeSessionServiceRuntime["inboundWorker"];
     capabilityMonitor: TelegramBridgeSessionServiceRuntime["capabilityMonitor"];
     queueWatchdog: TelegramBridgeSessionServiceRuntime["queueWatchdog"];
   };
@@ -309,6 +311,7 @@ export function createTelegramBridgeSessionLifecycleDeps<
       }),
       delivery: ports.services.delivery,
       polling: ports.services.polling,
+      inboundWorker: ports.services.inboundWorker,
       capabilityMonitor: ports.services.capabilityMonitor,
       queueWatchdog: ports.services.queueWatchdog,
     },
@@ -349,6 +352,7 @@ export function createTelegramBridgeSessionLifecycleAssembly<
         await deps.services.delivery.onSessionShutdown();
         deps.services.queueWatchdog.stop();
         deps.services.capabilityMonitor.stop();
+        await deps.services.inboundWorker.onSessionShutdown();
       },
     },
     isSessionActive,

package/lib/locks.ts

@@ -23,7 +23,8 @@ import { resolveTelegramOwnersPath } from "./paths.ts";
 
 export const TELEGRAM_LOCK_KEY = "default";
 export const TELEGRAM_BUS_LEADER_STALE_HEARTBEAT_MS = 8_000;
-const TELEGRAM_OWNERSHIP_REFRESH_MS = 2_000;
+export const TELEGRAM_OWNERSHIP_CHECK_MS = 1_000;
+export const TELEGRAM_OWNERSHIP_REFRESH_MS = 2_000;
 const TELEGRAM_LOCK_WRITE_RETRY_ATTEMPTS = 5;
 const TELEGRAM_LOCK_WRITE_RETRY_DELAY_MS = 25;
 const TELEGRAM_LOCK_TRANSACTION_ATTEMPTS = 80;
@@ -276,20 +277,15 @@ function createLockTransactionContentionError(path: string): Error {
   );
 }
 
-function isLockTransactionContentionError(
-  error: unknown,
-  path: string,
-): boolean {
+function isLockTransactionContentionError(error: unknown): boolean {
   const code = (error as { code?: unknown })?.code;
-  if (
+  return (
     code === "EEXIST" ||
     code === "ENOTEMPTY" ||
     code === "ENOTDIR" ||
-    code === "EISDIR"
-  ) {
-    return true;
-  }
-  return existsSync(path) && (code === "EPERM" || code === "EACCES");
+    code === "EISDIR" ||
+    isRetryableLockWriteError(error)
+  );
 }
 
 function removeLockTransactionGuard(path: string): void {
@@ -298,6 +294,7 @@ function removeLockTransactionGuard(path: string): void {
 
 function createLockTransactionGuard(
   path: string,
+  options: TelegramFileTransactionOptions = {},
 ): TelegramLockTransactionOwner {
   const owner: TelegramLockTransactionOwner = {
     pid: process.pid,
@@ -313,7 +310,7 @@ function createLockTransactionGuard(
       { encoding: "utf8", flag: "wx", mode: 0o600 },
     );
     if (existsSync(path)) throw createLockTransactionContentionError(path);
-    renameSync(stagedPath, path);
+    (options.publishRename ?? renameSync)(stagedPath, path);
     return owner;
   } finally {
     try {
@@ -368,6 +365,7 @@ type TelegramTransactionGlobal = typeof globalThis & {
 
 export interface TelegramFileTransactionOptions {
   recoveryRename?: typeof renameSync;
+  publishRename?: typeof renameSync;
   attempts?: number;
   retryDelayMs?: number;
 }
@@ -465,9 +463,9 @@ function acquireRecoverableDirectoryGuard(
 ): TelegramLockTransactionOwner | undefined {
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
-      return createLockTransactionGuard(path);
+      return createLockTransactionGuard(path, options);
     } catch (error) {
-      if (!isLockTransactionContentionError(error, path)) throw error;
+      if (!isLockTransactionContentionError(error)) throw error;
       if (!reclaimAbandonedDirectoryGuard(path, options)) return undefined;
     }
   }
@@ -528,11 +526,12 @@ function acquireLegacyRecoveryGuard(
 
 function createRecoveredLockTransactionGuard(
   path: string,
+  options: TelegramFileTransactionOptions = {},
 ): TelegramLockTransactionOwner | undefined {
   try {
-    return createLockTransactionGuard(path);
+    return createLockTransactionGuard(path, options);
   } catch (error) {
-    if (isLockTransactionContentionError(error, path)) return undefined;
+    if (isLockTransactionContentionError(error)) return undefined;
     throw error;
   }
 }
@@ -550,7 +549,7 @@ function recoverAbandonedLockTransaction(
   }
   if (isDirectory) {
     if (!reclaimAbandonedDirectoryGuard(path, options)) return undefined;
-    const recoveredOwner = createRecoveredLockTransactionGuard(path);
+    const recoveredOwner = createRecoveredLockTransactionGuard(path, options);
     try {
       reclaimAbandonedDirectoryGuard(`${path}.recovery`, options);
       return recoveredOwner;
@@ -584,7 +583,7 @@ function recoverAbandonedLockTransaction(
     } catch {
       /* stale debris cannot retain transaction authority */
     }
-    recoveredOwner = createRecoveredLockTransactionGuard(path);
+    recoveredOwner = createRecoveredLockTransactionGuard(path, options);
     return recoveredOwner;
   } finally {
     try {
@@ -617,9 +616,9 @@ function acquireLockTransaction(
   mkdirSync(dirname(path), { recursive: true });
   for (let attempt = 0; attempt < attempts; attempt += 1) {
     try {
-      return createLockTransactionGuard(path);
+      return createLockTransactionGuard(path, options);
     } catch (error) {
-      if (!isLockTransactionContentionError(error, path)) throw error;
+      if (!isLockTransactionContentionError(error)) throw error;
       const recoveredOwner = recoverAbandonedLockTransaction(path, options);
       if (recoveredOwner !== undefined) return recoveredOwner;
       if (attempt === attempts - 1) {
@@ -1163,7 +1162,8 @@ export function createTelegramLockedPollingRuntime<
   let takeoverCandidate: TelegramLockEntry | undefined;
   let sessionAutoStartRun: Promise<void> | undefined;
   let sessionAutoStartGeneration = 0;
-  const ownershipCheckMs = deps.ownershipCheckMs ?? 1000;
+  const ownershipCheckMs =
+    deps.ownershipCheckMs ?? TELEGRAM_OWNERSHIP_CHECK_MS;
   const ownershipRefreshMs =
     deps.ownershipRefreshMs ?? TELEGRAM_OWNERSHIP_REFRESH_MS;
   const stopOwnershipWatcher = () => {

package/lib/media.ts

@@ -101,6 +101,8 @@ export interface TelegramMediaGroupState<TMessage, TContext = unknown> {
   context?: TContext;
   flushTimer?: ReturnType<typeof setTimeout>;
   dispatching?: boolean;
+  dispatchPromise?: Promise<void>;
+  dispatchNow?: () => Promise<void>;
   suspended?: boolean;
   reschedule?: () => void;
 }
@@ -118,6 +120,7 @@ export interface TelegramMediaGroupController<
     ) => unknown | Promise<unknown>;
   }) => boolean;
   removeMessages: (messageIds: number[]) => number;
+  flushMessage: (messageId: number) => Promise<boolean>;
   suspend: () => void;
   resume: (context: TContext) => void;
   clear: () => void;
@@ -129,6 +132,7 @@ export interface TelegramMediaGroupDispatchRuntimeDeps<
 > {
   mediaGroups: TelegramMediaGroupController<TMessage, TContext>;
   dispatchMessages: (messages: TMessage[], ctx: TContext) => Promise<void>;
+  onDeferredMessage?: (message: TMessage) => void;
 }
 
 export interface TelegramMediaGroupDispatchRuntime<
@@ -504,45 +508,59 @@ export function queueTelegramMediaGroupMessage<
   const key = getTelegramMediaGroupKey(options.message);
   if (!key) return false;
   const existing = options.groups.get(key) ?? { messages: [] };
-  existing.messages.push(options.message);
+  const duplicateIndex = existing.messages.findIndex(
+    (message) => message.message_id === options.message.message_id,
+  );
+  if (duplicateIndex >= 0) {
+    existing.messages[duplicateIndex] = options.message;
+  } else {
+    existing.messages.push(options.message);
+  }
   existing.context = options.context;
+  const dispatchQueued = (): Promise<void> => {
+    existing.flushTimer = undefined;
+    const state = options.groups.get(key);
+    if (!state) return Promise.resolve();
+    if (state.dispatching) return state.dispatchPromise ?? Promise.resolve();
+    const dispatchedMessages = [...state.messages];
+    const dispatchedIds = new Set(
+      dispatchedMessages.map((message) => message.message_id),
+    );
+    state.dispatching = true;
+    const operation = Promise.resolve(
+      options.dispatchMessages(dispatchedMessages, state.context),
+    ).then(
+      () => {
+        if (options.groups.get(key) !== state) return;
+        state.messages = state.messages.filter(
+          (message) => !dispatchedIds.has(message.message_id),
+        );
+        state.dispatching = false;
+        state.dispatchPromise = undefined;
+        if (state.messages.length === 0) options.groups.delete(key);
+        else if (!state.flushTimer) scheduleDispatch();
+      },
+      (error) => {
+        if (options.groups.get(key) === state) {
+          state.dispatching = false;
+          state.dispatchPromise = undefined;
+          if (!state.flushTimer) scheduleDispatch();
+        }
+        throw error;
+      },
+    );
+    state.dispatchPromise = operation;
+    return operation;
+  };
   const scheduleDispatch = (): void => {
     if (existing.suspended) return;
     existing.flushTimer = options.setTimer(() => {
-      existing.flushTimer = undefined;
-      const state = options.groups.get(key);
-      if (!state) return;
-      if (state.dispatching) {
-        scheduleDispatch();
-        return;
-      }
-      const dispatchedMessages = [...state.messages];
-      const dispatchedIds = new Set(
-        dispatchedMessages.map((message) => message.message_id),
-      );
-      state.dispatching = true;
-      void Promise.resolve(
-        options.dispatchMessages(dispatchedMessages, state.context),
-      ).then(
-        () => {
-          if (options.groups.get(key) !== state) return;
-          state.messages = state.messages.filter(
-            (message) => !dispatchedIds.has(message.message_id),
-          );
-          state.dispatching = false;
-          if (state.messages.length === 0) options.groups.delete(key);
-          else if (!state.flushTimer) scheduleDispatch();
-        },
-        () => {
-          if (options.groups.get(key) !== state) return;
-          state.dispatching = false;
-          if (!state.flushTimer) scheduleDispatch();
-        },
-      );
+      void dispatchQueued().catch(() => undefined);
     }, options.debounceMs);
     existing.flushTimer.unref?.();
   };
   existing.reschedule = scheduleDispatch;
+  existing.dispatchNow = dispatchQueued;
   if (existing.flushTimer) options.clearTimer(existing.flushTimer);
   scheduleDispatch();
   options.groups.set(key, existing);
@@ -575,6 +593,24 @@ export function createTelegramMediaGroupController<
       }),
     removeMessages: (messageIds) =>
       removePendingTelegramMediaGroupMessages(groups, messageIds, clearTimer),
+    async flushMessage(messageId) {
+      for (const state of groups.values()) {
+        if (!state.messages.some((message) => message.message_id === messageId)) {
+          continue;
+        }
+        if (state.flushTimer) clearTimer(state.flushTimer);
+        state.flushTimer = undefined;
+        await state.dispatchNow?.();
+        if (
+          state.messages.some((message) => message.message_id === messageId) &&
+          !state.dispatching
+        ) {
+          await state.dispatchNow?.();
+        }
+        return true;
+      }
+      return false;
+    },
     suspend: () => {
       for (const state of groups.values()) {
         state.suspended = true;
@@ -614,7 +650,10 @@ export function createTelegramMediaGroupDispatchRuntime<
             ? Promise.resolve()
             : deps.dispatchMessages(messages, queuedCtx),
       });
-      if (queuedMediaGroup) return;
+      if (queuedMediaGroup) {
+        deps.onDeferredMessage?.(message);
+        return;
+      }
       await deps.dispatchMessages([message], ctx);
     },
   };

package/lib/menu-queue.ts

@@ -34,6 +34,7 @@ interface TelegramQueueMenuItem {
   queuePosition: number;
   isPriority: boolean;
   priorityEmoji?: string;
+  reactionSuppressionEmoji?: string;
   hasAttachments: boolean;
   statusSummary: string;
   promptText: string;
@@ -62,6 +63,8 @@ function toTelegramQueueMenuItems<Context>(
       queuePosition: index + 1,
       isPriority: item.queueLane === "priority",
       priorityEmoji: item.kind === "prompt" ? item.priorityEmoji : undefined,
+      reactionSuppressionEmoji:
+        item.kind === "prompt" ? item.reactionSuppressionEmoji : undefined,
       hasAttachments:
         item.kind === "prompt" && item.queuedAttachments.length > 0,
       statusSummary: item.statusSummary,
@@ -84,11 +87,13 @@ function buildTelegramQueueMenuReplyMarkup(
   const refreshRow = [{ text: "🌀 Refresh", callback_data: refreshData }];
   if (items.length === 0) return { inline_keyboard: [backRow, refreshRow] };
   const rows = items.map((item, index) => {
-    const prefix = item.isPriority
-      ? `${item.priorityEmoji ?? "⚡"} `
-      : item.hasAttachments
-        ? "📎 "
-        : "";
+    const prefix = item.reactionSuppressionEmoji
+      ? `${item.reactionSuppressionEmoji} suppressed · `
+      : item.isPriority
+        ? `${item.priorityEmoji ?? "⚡"} `
+        : item.hasAttachments
+          ? "📎 "
+          : "";
     const label = `${index + 1}. ${prefix}${item.statusSummary}`;
     return [
       {
@@ -152,10 +157,17 @@ function escapeTelegramQueueMenuHtmlPreview(text: string): string {
 }
 
 function getTelegramQueueMenuItemText(item: TelegramQueueMenuItem): string {
-  const badge = item.isPriority ? ` ${item.priorityEmoji ?? "⚡"}` : "";
+  const badge = item.reactionSuppressionEmoji
+    ? ` ${item.reactionSuppressionEmoji}`
+    : item.isPriority
+      ? ` ${item.priorityEmoji ?? "⚡"}`
+      : "";
   const heading = `<b>${item.queuePosition}.</b>${badge}`;
+  const suppression = item.reactionSuppressionEmoji
+    ? "\n<i>Suppressed by reaction. Remove it to restore this turn.</i>"
+    : "";
   const preview = `<pre>${escapeTelegramQueueMenuHtmlPreview(item.promptText)}</pre>`;
-  return `${heading}\n${preview}`;
+  return `${heading}${suppression}\n${preview}`;
 }
 
 function buildTelegramQueueItemSubmenuReplyMarkup(
@@ -820,11 +832,13 @@ function toggleQueuedTelegramPromptPriority<Context>(
     replyToMessageId,
   );
   if (!item) return false;
-  if (item.queueLane === "priority") {
-    deps.queueMutationRuntime.clearPriorityByMessageId(replyToMessageId, ctx);
-  } else {
-    deps.queueMutationRuntime.prioritizeByMessageId(replyToMessageId, ctx);
-  }
+  deps.queueMutationRuntime.applyReactionByMessageId(
+    replyToMessageId,
+    item.queueLane === "priority"
+      ? { kind: "default" }
+      : { kind: "priority", emoji: "⚡" },
+    ctx,
+  );
   return true;
 }
 
@@ -844,11 +858,11 @@ function setQueuedTelegramPromptPriority<Context>(
     replyToMessageId,
   );
   if (!item) return false;
-  if (enabled) {
-    deps.queueMutationRuntime.prioritizeByMessageId(replyToMessageId, ctx);
-  } else {
-    deps.queueMutationRuntime.clearPriorityByMessageId(replyToMessageId, ctx);
-  }
+  deps.queueMutationRuntime.applyReactionByMessageId(
+    replyToMessageId,
+    enabled ? { kind: "priority", emoji: "⚡" } : { kind: "default" },
+    ctx,
+  );
   return true;
 }
 

package/lib/menu.ts

@@ -229,6 +229,7 @@ export interface TelegramMenuCallbackRuntimeDeps<
     prompt: string,
     ctx: TContext,
     target?: { chatId: number; threadId?: number },
+    source?: unknown,
   ) => Promise<void>;
   deleteMessage?: (chatId: number, messageId: number) => Promise<void>;
   isVoiceReplyActive?: () => boolean;
@@ -478,6 +479,7 @@ export interface TelegramMenuCallbackRuntimeAdapterDeps<
     prompt: string,
     ctx: TContext,
     target?: { chatId: number; threadId?: number },
+    source?: unknown,
   ) => Promise<void>;
   deleteMessage?: (chatId: number, messageId: number) => Promise<void>;
 }
@@ -588,7 +590,7 @@ export async function handleTelegramMenuCallbackRuntime<
                 deps.sendInteractiveMessage ?? (async () => undefined),
               enqueuePrompt: deps.enqueueSectionPrompt
                 ? (prompt: string) =>
-                    deps.enqueueSectionPrompt!(prompt, ctx, target)
+                    deps.enqueueSectionPrompt!(prompt, ctx, target, query)
                 : async () => {},
               deleteMessage: deps.deleteMessage ?? (async () => {}),
             },
@@ -611,7 +613,7 @@ export async function handleTelegramMenuCallbackRuntime<
                   deps.sendInteractiveMessage ?? (async () => undefined),
                 enqueuePrompt: deps.enqueueSectionPrompt
                   ? (prompt: string) =>
-                      deps.enqueueSectionPrompt!(prompt, ctx, target)
+                      deps.enqueueSectionPrompt!(prompt, ctx, target, query)
                   : async () => {},
                 deleteMessage: deps.deleteMessage ?? (async () => {}),
               },
@@ -636,7 +638,7 @@ export async function handleTelegramMenuCallbackRuntime<
                 deps.sendInteractiveMessage ?? (async () => undefined),
               enqueuePrompt: deps.enqueueSectionPrompt
                 ? (prompt: string) =>
-                    deps.enqueueSectionPrompt!(prompt, ctx, target)
+                    deps.enqueueSectionPrompt!(prompt, ctx, target, query)
                 : async () => {},
               deleteMessage: deps.deleteMessage ?? (async () => {}),
             },

package/lib/model.ts

@@ -188,6 +188,19 @@ function isAliasModelId(id: string): boolean {
   return !/-\d{8}$/.test(id);
 }
 
+function findUniqueModelMatch<TModel extends MenuModel>(
+  availableModels: TModel[],
+  matches: (model: TModel) => boolean,
+): { model?: TModel; ambiguous: boolean } {
+  let model: TModel | undefined;
+  for (const candidate of availableModels) {
+    if (!matches(candidate)) continue;
+    if (model) return { ambiguous: true };
+    model = candidate;
+  }
+  return { model, ambiguous: false };
+}
+
 function findExactModelReferenceMatch<TModel extends MenuModel = MenuModel>(
   modelReference: string,
   availableModels: TModel[],
@@ -195,29 +208,35 @@ function findExactModelReferenceMatch<TModel extends MenuModel = MenuModel>(
   const trimmedReference = modelReference.trim();
   if (!trimmedReference) return undefined;
   const normalizedReference = trimmedReference.toLowerCase();
-  const canonicalMatches = availableModels.filter(
+  const canonicalMatch = findUniqueModelMatch(
+    availableModels,
     (model) => getCanonicalModelId(model).toLowerCase() === normalizedReference,
   );
-  if (canonicalMatches.length === 1) return canonicalMatches[0];
-  if (canonicalMatches.length > 1) return undefined;
+  if (canonicalMatch.model || canonicalMatch.ambiguous) {
+    return canonicalMatch.model;
+  }
   const slashIndex = trimmedReference.indexOf("/");
   if (slashIndex !== -1) {
     const provider = trimmedReference.substring(0, slashIndex).trim();
     const modelId = trimmedReference.substring(slashIndex + 1).trim();
     if (provider && modelId) {
-      const providerMatches = availableModels.filter(
+      const normalizedProvider = provider.toLowerCase();
+      const normalizedModelId = modelId.toLowerCase();
+      const providerMatch = findUniqueModelMatch(
+        availableModels,
         (model) =>
-          model.provider.toLowerCase() === provider.toLowerCase() &&
-          model.id.toLowerCase() === modelId.toLowerCase(),
+          model.provider.toLowerCase() === normalizedProvider &&
+          model.id.toLowerCase() === normalizedModelId,
       );
-      if (providerMatches.length === 1) return providerMatches[0];
-      if (providerMatches.length > 1) return undefined;
+      if (providerMatch.model || providerMatch.ambiguous) {
+        return providerMatch.model;
+      }
     }
   }
-  const idMatches = availableModels.filter(
+  return findUniqueModelMatch(
+    availableModels,
     (model) => model.id.toLowerCase() === normalizedReference,
-  );
-  return idMatches.length === 1 ? idMatches[0] : undefined;
+  ).model;
 }
 
 function tryMatchScopedModel<TModel extends MenuModel = MenuModel>(
@@ -229,20 +248,28 @@ function tryMatchScopedModel<TModel extends MenuModel = MenuModel>(
     availableModels,
   );
   if (exactMatch) return exactMatch;
-  const matches = availableModels.filter(
-    (model) =>
-      model.id.toLowerCase().includes(modelPattern.toLowerCase()) ||
-      model.name?.toLowerCase().includes(modelPattern.toLowerCase()),
-  );
-  if (matches.length === 0) return undefined;
-  const aliases = matches.filter((model) => isAliasModelId(model.id));
-  const datedVersions = matches.filter((model) => !isAliasModelId(model.id));
-  if (aliases.length > 0) {
-    aliases.sort((a, b) => b.id.localeCompare(a.id));
-    return aliases[0];
+  const normalizedPattern = modelPattern.toLowerCase();
+  let bestAlias: TModel | undefined;
+  let bestDatedVersion: TModel | undefined;
+  for (const model of availableModels) {
+    if (
+      !model.id.toLowerCase().includes(normalizedPattern) &&
+      !model.name?.toLowerCase().includes(normalizedPattern)
+    ) {
+      continue;
+    }
+    if (isAliasModelId(model.id)) {
+      if (!bestAlias || model.id.localeCompare(bestAlias.id) > 0) {
+        bestAlias = model;
+      }
+    } else if (
+      !bestDatedVersion ||
+      model.id.localeCompare(bestDatedVersion.id) > 0
+    ) {
+      bestDatedVersion = model;
+    }
   }
-  datedVersions.sort((a, b) => b.id.localeCompare(a.id));
-  return datedVersions[0];
+  return bestAlias ?? bestDatedVersion;
 }
 
 function parseScopedModelPattern<TModel extends MenuModel = MenuModel>(

package/lib/ownership.ts

@@ -13,6 +13,7 @@ export interface TelegramMessageOwnershipRecord {
   instanceId: string;
   profileKey?: string;
   ownerGeneration?: string;
+  recipientBindingKey?: string;
   createdAt: number;
   updatedAt: number;
 }
@@ -25,6 +26,7 @@ export interface TelegramMessageOwnershipStore {
     instanceId: string;
     profileKey?: string;
     ownerGeneration?: string;
+    recipientBindingKey?: string;
     now?: number;
   }) => TelegramMessageOwnershipRecord;
   get: (
@@ -45,6 +47,7 @@ export interface TelegramMessageOwnershipStore {
 export interface TelegramFollowerOwnershipView {
   instanceId: string;
   connectedAtMs: number;
+  profileKey?: string;
   registrationGeneration?: string;
 }
 
@@ -100,6 +103,22 @@ export function createTelegramBusMessageOwnershipRuntime(deps: {
         );
       });
     },
+    resolveOwnerReplacement(record) {
+      if (!record.recipientBindingKey) return undefined;
+      const follower = deps
+        .listFollowers()
+        .find(
+          (candidate) =>
+            candidate.profileKey === record.recipientBindingKey,
+        );
+      return follower
+        ? {
+            instanceId: follower.instanceId,
+            ownerGeneration: getTelegramFollowerOwnershipGeneration(follower),
+            recipientBindingKey: record.recipientBindingKey,
+          }
+        : undefined;
+    },
   });
   const recordFollower = function (input: {
     chatId: number;
@@ -113,6 +132,7 @@ export function createTelegramBusMessageOwnershipRuntime(deps: {
       target: input.target,
       instanceId: input.follower.instanceId,
       ownerGeneration: getTelegramFollowerOwnershipGeneration(input.follower),
+      recipientBindingKey: input.follower.profileKey,
     });
   };
   return {
@@ -155,6 +175,7 @@ function createTelegramMessageOwnershipRecord(input: {
   instanceId: string;
   profileKey?: string;
   ownerGeneration?: string;
+  recipientBindingKey?: string;
   now: number;
   previous?: TelegramMessageOwnershipRecord;
 }): TelegramMessageOwnershipRecord {
@@ -167,6 +188,9 @@ function createTelegramMessageOwnershipRecord(input: {
     ...(input.ownerGeneration
       ? { ownerGeneration: input.ownerGeneration }
       : {}),
+    ...(input.recipientBindingKey
+      ? { recipientBindingKey: input.recipientBindingKey }
+      : {}),
     createdAt: input.previous?.createdAt ?? input.now,
     updatedAt: input.now,
   };
@@ -176,6 +200,14 @@ export function createTelegramMessageOwnershipStore(
   options: {
     getProfileKey?: () => string | undefined;
     isOwnerGenerationLive?: (record: TelegramMessageOwnershipRecord) => boolean;
+    resolveOwnerReplacement?: (
+      record: TelegramMessageOwnershipRecord,
+    ) =>
+      | Pick<
+          TelegramMessageOwnershipRecord,
+          "instanceId" | "ownerGeneration" | "recipientBindingKey"
+        >
+      | undefined;
   } = {},
 ): TelegramMessageOwnershipStore {
   const records = new Map<string, TelegramMessageOwnershipRecord>();
@@ -198,20 +230,23 @@ export function createTelegramMessageOwnershipStore(
       return record;
     },
     get: (chatId, messageId) => {
-      const record = records.get(
-        getTelegramMessageOwnershipKey(
-          chatId,
-          messageId,
-          options.getProfileKey?.(),
-        ),
+      const key = getTelegramMessageOwnershipKey(
+        chatId,
+        messageId,
+        options.getProfileKey?.(),
       );
+      const record = records.get(key);
       if (!record) return undefined;
       if (
         record.ownerGeneration &&
         options.isOwnerGenerationLive &&
         !options.isOwnerGenerationLive(record)
       ) {
-        return undefined;
+        const replacement = options.resolveOwnerReplacement?.(record);
+        if (!replacement) return undefined;
+        const rebound = { ...record, ...replacement };
+        records.set(key, rebound);
+        return rebound;
       }
       return record;
     },