@llblab/pi-telegram 0.52.2 → 0.53.1

package/dist/lib/bus-api.js

@@ -3,8 +3,8 @@
  * Zones: multi-instance bus, telegram api transport, live instance routing
  * Wraps the direct Telegram Bot API runtime so follower instances can route outbound calls through the bus leader
  */
-import { markTelegramBusCrossTargetDelivery, stripTelegramBusApiMetadata, } from "./bus.js";
-import { buildTelegramAnswerGuestQueryBody, formatTelegramCallbackAnswerText, isTelegramMessageNotModifiedError, } from "./telegram-api.js";
+import { markTelegramBusCrossTargetDelivery, parseTelegramBusSelectedMenuTextEffect, stripTelegramBusApiMetadata, } from "./bus.js";
+import { buildTelegramAnswerGuestQueryBody, isTelegramApiCommitUnknownError, isTelegramMessageNotModifiedError, TelegramApiAuthorityError, TelegramApiCommitUnknownError, } from "./telegram-api.js";
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -37,28 +37,147 @@ function markFollowerCrossTargetDelivery(body, defaultTarget) {
 function rejectTelegramDirectOwnership(method) {
     return Promise.reject(new Error(`Telegram ${method} requires direct transport ownership.`));
 }
+/** Bound selected-menu projection only; no ordinary/raw API fallback and no activation during preparation. */
+export function createTelegramSelectedMenuTextApi(deps) {
+    const { operationId, registrationGeneration, assertAuthority, deliver } = deps, target = { ...deps.target };
+    if (typeof assertAuthority !== "function" ||
+        typeof deliver !== "function" ||
+        !operationId?.trim() ||
+        operationId.length > 128 ||
+        !registrationGeneration?.trim() ||
+        registrationGeneration.length > 128 ||
+        !Number.isSafeInteger(target.chatId) ||
+        target.chatId <= 0 ||
+        !Number.isSafeInteger(target.threadId) ||
+        target.threadId <= 0)
+        throw new TelegramApiAuthorityError(false);
+    const invoke = async (edit, raw, options) => {
+        let issued = false;
+        const assertCurrent = () => {
+            try {
+                assertAuthority();
+            }
+            catch {
+                throw new TelegramApiAuthorityError(issued);
+            }
+        };
+        try {
+            if (options?.assertAuthority !== assertAuthority ||
+                Reflect.ownKeys(raw).some((key) => typeof key !== "string" ||
+                    ![
+                        "chat_id",
+                        "message_thread_id",
+                        "text",
+                        "parse_mode",
+                        "reply_markup",
+                        ...(edit ? ["message_id"] : ["reply_parameters"]),
+                    ].includes(key)))
+                throw new TelegramApiAuthorityError(false);
+            const body = structuredClone(raw), reply = body.reply_parameters;
+            if (body.chat_id !== target.chatId ||
+                body.message_thread_id !== target.threadId ||
+                (reply !== undefined &&
+                    (!reply ||
+                        typeof reply !== "object" ||
+                        Array.isArray(reply) ||
+                        Object.keys(reply).some((key) => !["message_id", "allow_sending_without_reply"].includes(key)) ||
+                        reply.allow_sending_without_reply !==
+                            true ||
+                        !Number.isSafeInteger(reply.message_id) ||
+                        reply.message_id <= 0)))
+                throw new TelegramApiAuthorityError(false);
+            const effect = parseTelegramBusSelectedMenuTextEffect({
+                kind: edit ? "edit-text" : "send-text",
+                text: body.text,
+                ...(body.parse_mode !== undefined
+                    ? { parseMode: body.parse_mode }
+                    : {}),
+                ...(body.reply_markup !== undefined
+                    ? { replyMarkup: body.reply_markup }
+                    : {}),
+                ...(edit
+                    ? { messageId: body.message_id }
+                    : reply !== undefined
+                        ? {
+                            replyToMessageId: reply.message_id,
+                        }
+                        : {}),
+            });
+            if (!effect)
+                throw new TelegramApiAuthorityError(false);
+            assertCurrent();
+            issued = true;
+            const observed = await deliver.call(deps, effect, assertAuthority);
+            assertCurrent();
+            if (observed.operationId !== operationId ||
+                observed.registrationGeneration !== registrationGeneration ||
+                observed.effect !== effect.kind ||
+                observed.recipient.target.chatId !== target.chatId ||
+                observed.recipient.target.threadId !== target.threadId ||
+                !Number.isSafeInteger(observed.messageId) ||
+                observed.messageId <= 0 ||
+                (effect.kind === "edit-text" && observed.messageId !== effect.messageId))
+                throw new Error("Selected-menu transport result is unconfirmed.");
+            assertCurrent();
+            return observed.messageId;
+        }
+        catch (error) {
+            if (error instanceof TelegramApiAuthorityError ||
+                isTelegramApiCommitUnknownError(error))
+                throw error;
+            if (issued)
+                throw new TelegramApiCommitUnknownError(edit ? "editMessageText" : "sendMessage", error);
+            throw new TelegramApiAuthorityError(false);
+        }
+    };
+    return {
+        sendMessage: async (body, options) => ({
+            message_id: await invoke(false, body, options),
+        }),
+        editMessageText: async (body, options) => {
+            await invoke(true, body, options);
+            return "edited";
+        },
+    };
+}
+/** Followers route every chat action through the leader's generic `sendChatAction` call. */
+function sendTelegramFollowerChatAction(deps, chatId, action, options) {
+    const body = withDefaultThreadTarget({
+        chat_id: chatId,
+        action,
+        ...(options?.message_thread_id !== undefined
+            ? { message_thread_id: options.message_thread_id }
+            : {}),
+    }, deps.getDefaultTarget?.());
+    return deps.callFollowerApi("call", ["sendChatAction", body]).then(asBoolean);
+}
 export function createTelegramBusAwareApiRuntime(deps) {
     return {
         call(method, body, options) {
-            return deps.ownsDirect()
-                ? deps.directRuntime.call(method, body, options)
-                : deps.callFollowerApi("call", [
-                    method,
-                    body,
-                    options,
-                ]);
+            if (deps.ownsDirect())
+                return deps.directRuntime.call(method, body, options);
+            // A process-local authority callback cannot cross IPC as an enforceable grant.
+            if (options?.assertAuthority)
+                return Promise.reject(new TelegramApiAuthorityError(false));
+            return deps.callFollowerApi("call", [
+                method,
+                body,
+                options,
+            ]);
         },
         callMultipart(method, fields, fileField, filePath, fileName, options) {
-            return deps.ownsDirect()
-                ? deps.directRuntime.callMultipart(method, fields, fileField, filePath, fileName, options)
-                : deps.callFollowerApi("callMultipart", [
-                    method,
-                    fields,
-                    fileField,
-                    filePath,
-                    fileName,
-                    options,
-                ]);
+            if (deps.ownsDirect())
+                return deps.directRuntime.callMultipart(method, fields, fileField, filePath, fileName, options);
+            if (options?.assertAuthority)
+                return Promise.reject(new TelegramApiAuthorityError(false));
+            return deps.callFollowerApi("callMultipart", [
+                method,
+                fields,
+                fileField,
+                filePath,
+                fileName,
+                options,
+            ]);
         },
         downloadFile(fileId, suggestedName, source) {
             // The source names the file (kind-scope-message); dropping it falls back to the bare generated name.
@@ -80,54 +199,29 @@ export function createTelegramBusAwareApiRuntime(deps) {
                 ? deps.directRuntime.getUpdates(body, signal)
                 : rejectTelegramDirectOwnership("getUpdates");
         },
-        setMyCommands(commands) {
-            return deps.ownsDirect()
-                ? deps.directRuntime.setMyCommands(commands)
-                : deps
-                    .callFollowerApi("call", ["setMyCommands", { commands }])
-                    .then(asBoolean);
+        setMyCommands(commands, options) {
+            if (deps.ownsDirect())
+                return deps.directRuntime.setMyCommands(commands, options);
+            if (options?.assertAuthority)
+                return Promise.reject(new TelegramApiAuthorityError(false));
+            return deps
+                .callFollowerApi("call", ["setMyCommands", { commands }])
+                .then(asBoolean);
         },
         sendChatAction(chatId, action, options) {
-            const body = withDefaultThreadTarget({
-                chat_id: chatId,
-                action,
-                ...(options?.message_thread_id !== undefined
-                    ? { message_thread_id: options.message_thread_id }
-                    : {}),
-            }, deps.getDefaultTarget?.());
             return deps.ownsDirect()
                 ? deps.directRuntime.sendChatAction(chatId, action, options)
-                : deps
-                    .callFollowerApi("call", ["sendChatAction", body])
-                    .then(asBoolean);
+                : sendTelegramFollowerChatAction(deps, chatId, action, options);
         },
         sendTypingAction(chatId, options) {
-            const body = withDefaultThreadTarget({
-                chat_id: chatId,
-                action: "typing",
-                ...(options?.message_thread_id !== undefined
-                    ? { message_thread_id: options.message_thread_id }
-                    : {}),
-            }, deps.getDefaultTarget?.());
             return deps.ownsDirect()
                 ? deps.directRuntime.sendTypingAction(chatId, options)
-                : deps
-                    .callFollowerApi("call", ["sendChatAction", body])
-                    .then(asBoolean);
+                : sendTelegramFollowerChatAction(deps, chatId, "typing", options);
         },
         sendRecordVoiceAction(chatId, options) {
-            const body = withDefaultThreadTarget({
-                chat_id: chatId,
-                action: "record_voice",
-                ...(options?.message_thread_id !== undefined
-                    ? { message_thread_id: options.message_thread_id }
-                    : {}),
-            }, deps.getDefaultTarget?.());
             return deps.ownsDirect()
                 ? deps.directRuntime.sendRecordVoiceAction(chatId, options)
-                : deps
-                    .callFollowerApi("call", ["sendChatAction", body])
-                    .then(asBoolean);
+                : sendTelegramFollowerChatAction(deps, chatId, "record_voice", options);
         },
         sendMessageDraft(chatId, draftId, text, options) {
             const body = {
@@ -150,25 +244,29 @@ export function createTelegramBusAwareApiRuntime(deps) {
                     .callFollowerApi("call", ["sendMessageDraft", scopedBody])
                     .then(asBoolean);
         },
-        sendMessage(body) {
-            return deps.ownsDirect()
-                ? deps.directRuntime.sendMessage(stripTelegramBusApiMetadata(body))
-                : deps
-                    .callFollowerApi("call", [
-                    "sendMessage",
-                    markFollowerCrossTargetDelivery(body, deps.getDefaultTarget?.()),
-                ])
-                    .then(asSentMessage);
+        sendMessage(body, options) {
+            if (deps.ownsDirect())
+                return deps.directRuntime.sendMessage(stripTelegramBusApiMetadata(body), options);
+            if (options?.assertAuthority)
+                return Promise.reject(new TelegramApiAuthorityError(false));
+            return deps
+                .callFollowerApi("call", [
+                "sendMessage",
+                markFollowerCrossTargetDelivery(body, deps.getDefaultTarget?.()),
+            ])
+                .then(asSentMessage);
         },
-        sendRichMessage(body) {
-            return deps.ownsDirect()
-                ? deps.directRuntime.sendRichMessage(stripTelegramBusApiMetadata(body))
-                : deps
-                    .callFollowerApi("call", [
-                    "sendRichMessage",
-                    markFollowerCrossTargetDelivery(body, deps.getDefaultTarget?.()),
-                ])
-                    .then(asSentMessage);
+        sendRichMessage(body, options) {
+            if (deps.ownsDirect())
+                return deps.directRuntime.sendRichMessage(stripTelegramBusApiMetadata(body), options);
+            if (options?.assertAuthority)
+                return Promise.reject(new TelegramApiAuthorityError(false));
+            return deps
+                .callFollowerApi("call", [
+                "sendRichMessage",
+                markFollowerCrossTargetDelivery(body, deps.getDefaultTarget?.()),
+            ])
+                .then(asSentMessage);
         },
         sendRichMessageDraft(body) {
             return deps.ownsDirect()
@@ -177,9 +275,11 @@ export function createTelegramBusAwareApiRuntime(deps) {
                     .callFollowerApi("call", ["sendRichMessageDraft", body])
                     .then(asBoolean);
         },
-        async editMessageText(body) {
+        async editMessageText(body, options) {
             if (deps.ownsDirect())
-                return deps.directRuntime.editMessageText(body);
+                return deps.directRuntime.editMessageText(body, options);
+            if (options?.assertAuthority)
+                throw new TelegramApiAuthorityError(false);
             try {
                 await deps.callFollowerApi("call", ["editMessageText", body]);
                 return "edited";
@@ -200,17 +300,20 @@ export function createTelegramBusAwareApiRuntime(deps) {
                 { chat_id: chatId, message_id: messageId, reply_markup: replyMarkup },
             ]);
         },
-        async answerCallbackQuery(callbackQueryId, text) {
-            const answer = formatTelegramCallbackAnswerText(text);
+        async answerCallbackQuery(callbackQueryId, text, options) {
+            const assertAuthority = options?.assertAuthority;
             if (deps.ownsDirect()) {
-                await deps.directRuntime.answerCallbackQuery(callbackQueryId, answer);
+                const authorityOptions = assertAuthority ? [{ assertAuthority }] : [];
+                await deps.directRuntime.answerCallbackQuery(callbackQueryId, text, ...authorityOptions);
                 return;
             }
+            if (assertAuthority)
+                throw new TelegramApiAuthorityError(false);
             await deps.callFollowerApi("call", [
                 "answerCallbackQuery",
                 {
                     callback_query_id: callbackQueryId,
-                    ...(answer !== undefined ? { text: answer } : {}),
+                    ...(text !== undefined ? { text } : {}),
                 },
             ]);
         },

package/dist/lib/bus-follower.d.ts

@@ -5,14 +5,16 @@
  * heartbeat, forwarded-update receiving, and follower-routed API calls.
  * It must not spawn Pi processes or create hidden Telegram-originated instances.
  */
+import type { TelegramPreparedHeldCommand } from "./commands.ts";
 import type { TelegramWorkspaceRestoreExecutor, TelegramWorkspaceRestoreIntent } from "./threads.ts";
-import * as Threads from "./threads.ts";
+import type { TelegramLiveSourceCompletionReadiness, TelegramUpdateAdmissionLifecycleRuntime } from "./updates.ts";
+import { TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY, TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY, TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE, type TelegramBusAgentMessage, type TelegramBusAgentTargetSelector, type TelegramBusEnvelope, type TelegramBusFollowerQueueHandoffOffer, type TelegramBusForwardOwnership, type TelegramBusLiveRebindApplyObservation, type TelegramBusLiveRebindCommandObservation, type TelegramBusLiveRebindSaveObservation, type TelegramBusLiveRebindSettlementObservation, type TelegramBusLiveRebindWorkObservation, type TelegramBusLiveRebindWorkState, type TelegramBusProtocolIdentity, type TelegramBusSelectedMenuDeliveryObservation, type TelegramBusSelectedMenuTextEffect, type TelegramBusSocketPathSource, type TelegramBusWorkspaceRestoreObservation } from "./bus.ts";
+import type { TelegramConfigStore, TelegramThreadDisplayMode } from "./config.ts";
 import { type TelegramUpdateJournalStoreOptions } from "./journal.ts";
 import { type TelegramLockEntry, type TelegramLockState } from "./locks.ts";
-import type { TelegramQueueHandoffPayload, TelegramQueueHandoffStageResult } from "./queue.ts";
-import type { TelegramTarget } from "./target.ts";
-import { type TelegramBusAgentMessage, type TelegramBusAgentTargetSelector, type TelegramBusEnvelope, type TelegramBusWorkspaceRestoreObservation, type TelegramBusForwardOwnership, type TelegramBusProtocolIdentity, type TelegramBusSocketPathSource } from "./bus.ts";
-import type { TelegramConfigStore, TelegramThreadDisplayMode } from "./config.ts";
+import type { TelegramQueueHandoffStageResult } from "./queue.ts";
+import { type TelegramTarget } from "./target.ts";
+import * as Threads from "./threads.ts";
 import { type TelegramWorkspaceAdmissionLedger } from "./workspace-admission.ts";
 export declare const TELEGRAM_BUS_FOLLOWER_HEARTBEAT_TIMEOUT_MS = 8000;
 export interface TelegramFollowerSessionHandoff {
@@ -233,6 +235,8 @@ export interface TelegramBusForwardedUpdateReceiverRuntimeDeps<TContext> {
     getAuthSecret?: () => string | undefined;
     getRegistrationGeneration: () => string | undefined;
     getRecipientBindingKey: () => string | undefined;
+    /** Live preparation names the current journal, not the stable forwarding/profile identity. */
+    getLiveRebindJournalBindingKey?: () => string | undefined;
     durableAdmission: TelegramBusFollowerDurableAdmissionPort<TContext>;
     sourceReferenceAdmission?: TelegramBusFollowerDurableAdmissionPort<TContext>;
     isSourceReferenceAdmissionEnabled?: () => boolean;
@@ -244,6 +248,23 @@ export interface TelegramBusForwardedUpdateReceiverRuntimeDeps<TContext> {
     handleQueueHandoff?: (envelope: Extract<TelegramBusEnvelope, {
         kind: "leader.offerQueueHandoff";
     }>, ctx: TContext) => Promise<TelegramQueueHandoffStageResult> | TelegramQueueHandoffStageResult;
+    getSessionId?: () => string | undefined;
+    getLeaderProtocol?: () => TelegramBusProtocolIdentity | undefined;
+    getLocalProtocol?: () => TelegramBusProtocolIdentity | undefined;
+    isLiveRebindSaveEnabled?: () => boolean;
+    isLiveRebindApplyEnabled?: () => boolean;
+    isLiveRebindSettleEnabled?: () => boolean;
+    handleLiveRebindSettle?: (envelope: Extract<TelegramBusEnvelope, {
+        kind: "leader.settleLiveRebind";
+    }>, ctx: TContext, isCurrent: () => boolean) => Promise<TelegramBusLiveRebindSettlementObservation | TelegramBusLiveRebindWorkObservation | TelegramBusLiveRebindCommandObservation>;
+    handleLiveRebindApply?: (envelope: Extract<TelegramBusEnvelope, {
+        kind: "leader.applyLiveRebind";
+    }>, ctx: TContext, isCurrent: () => boolean) => Promise<TelegramBusLiveRebindApplyObservation>;
+    /** Availability only; never future recipient activation or a command execution grant. */
+    isLiveRebindCommandSetEnabled?: () => boolean;
+    handleLiveRebindSave?: (envelope: Extract<TelegramBusEnvelope, {
+        kind: "leader.prepareLiveRebind";
+    }>, ctx: TContext, isCurrent: () => boolean) => TelegramBusLiveRebindSaveObservation | Promise<TelegramBusLiveRebindSaveObservation>;
     isWorkspaceRestoreEnabled?: () => boolean;
     handleWorkspaceRestore?: (input: {
         operationId: string;
@@ -292,22 +313,47 @@ export declare function createTelegramBusFollowerRestoreContextGetter<TContext>(
     getLeaderState: () => TelegramLockState;
     getAuthenticatedSecret: () => string | undefined;
     getLeaderProtocol: () => TelegramBusProtocolIdentity | undefined;
+    capability?: typeof TELEGRAM_BUS_CAPABILITY_WORKSPACE_RESTORE | typeof TELEGRAM_BUS_CAPABILITY_LIVE_REBIND_APPLY | typeof TELEGRAM_BUS_CAPABILITY_SELECTED_MENU_DELIVERY;
 }): (ctx: TContext) => TelegramBusFollowerRestoreContext | undefined;
-/** Prepared receiver: its caller authenticates the envelope; no canonical writes, dispatch or cleanup. */
+/** Shared canonical/local target owner and scoped live-carrier hooks; caller authenticates transport, no canonical writes or cleanup. */
 export declare function createTelegramBusFollowerWorkspaceRestoreHandler<TContext>(deps: {
     instanceId: string;
     /** Captures actual Pi lifetime and authenticated leader/profile authority, never request-derived values. */
     getContextAuthority: (ctx: TContext) => TelegramBusFollowerRestoreContext | undefined;
     readRestoreIntent: (operationId: string, profileBindingKey: string) => TelegramWorkspaceRestoreIntent | undefined;
-    topicTargetStore: Pick<Threads.TelegramTopicTargetStore, "load" | "withWorkspaceRestoreSnapshot">;
+    readLiveRebindIntent?: (operationId: string, profileBindingKey: string) => Threads.TelegramWorkspaceLiveRebindIntent | undefined;
+    topicTargetStore: Pick<Threads.TelegramTopicTargetStore, "load" | "withWorkspaceRestoreSnapshot"> & Partial<Pick<Threads.TelegramTopicTargetStore, "withWorkspaceLiveRebindSnapshot">>;
     registrationState: Pick<TelegramBusFollowerRegistrationState, "getTarget" | "getSlot" | "getGeneration" | "setRegistered" | "getLeaderProtocol">;
     getWorkspaceAdmission: NonNullable<TelegramBusFollowerWorkspaceAdmissionDeps["getWorkspaceAdmission"]>;
     recordRuntimeEvent?: TelegramBusFollowerWorkspaceAdmissionDeps["recordRuntimeEvent"];
-}): (input: {
+}): ((input: {
     operationId: string;
     registrationGeneration: string;
     mode: "apply" | "inspect";
-}, ctx: TContext) => Promise<TelegramBusWorkspaceRestoreObservation>;
+    liveRebind?: {
+        sourceUpdateIds: readonly number[];
+        isCurrent(): boolean;
+        /** Captured prepared-branch target; equality must precede local apply or release grants. */
+        expectedTarget?: TelegramTarget & {
+            threadId: number;
+        };
+        release?: (canRelease: () => boolean) => void;
+        observeWork?: (oldTarget: TelegramTarget & {
+            threadId: number;
+        }) => void;
+    };
+}, ctx: TContext) => Promise<TelegramBusWorkspaceRestoreObservation>) & {
+    /** Capture availability only; asserting current recipient requires canonical released/local-applied ownership. */
+    prepareLiveCommandRecipient(input: {
+        operationId: string;
+        registrationGeneration: string;
+        sessionId: string;
+        sourceUpdateIds: readonly number[];
+        target: TelegramTarget & {
+            threadId: number;
+        };
+    }, ctx: TContext): Pick<TelegramBusFollowerCommandOwner<TContext>, "isCurrent" | "assertRecipientCurrent"> | undefined;
+};
 export declare function createTelegramBusFollowerClientRuntime<TContext, TReactionUpdate, TCallbackQuery, TMessage = unknown>(deps: TelegramBusFollowerClientRuntimeDeps<TMessage>): {
     createRequestId: () => string;
     callApi: (method: string, args: unknown[]) => Promise<unknown>;
@@ -339,29 +385,29 @@ export declare function createTelegramBusFollowerClientRuntime<TContext, TReacti
             ctx: TContext;
         }) => Promise<import("./bus.ts").TelegramBusForeignUpdateSettlement>;
     };
-    queueHandoff: (input: {
-        recipientInstanceId: string;
-        recipientRegistrationGeneration: string;
-        donorProcessId: number;
-        donorProcessBirthId: string;
-        donorSessionGeneration: number;
-        donorAcquisitionId: string;
-        donorAcquiredAtMs: number;
-        handoffToken: string;
-        payload: TelegramQueueHandoffPayload;
-    }) => Promise<TelegramQueueHandoffStageResult>;
+    queueHandoff: (input: TelegramBusFollowerQueueHandoffOffer) => Promise<TelegramQueueHandoffStageResult>;
 };
-export declare function createTelegramBusFollowerQueueHandoffClient(deps: TelegramBusFollowerApiCallerDeps): (input: {
-    recipientInstanceId: string;
-    recipientRegistrationGeneration: string;
-    donorProcessId: number;
-    donorProcessBirthId: string;
-    donorSessionGeneration: number;
-    donorAcquisitionId: string;
-    donorAcquiredAtMs: number;
-    handoffToken: string;
-    payload: TelegramQueueHandoffPayload;
-}) => Promise<TelegramQueueHandoffStageResult>;
+export declare function createTelegramBusFollowerQueueHandoffClient(deps: TelegramBusFollowerApiCallerDeps): (input: TelegramBusFollowerQueueHandoffOffer) => Promise<TelegramQueueHandoffStageResult>;
+/** Private selected text-effect caller; not a guarded ordinary API adapter or follower command admission grant. */
+export declare function createTelegramBusFollowerSelectedMenuCaller<TContext>(deps: {
+    client: TelegramBusFollowerApiCallerDeps;
+    protocolIdentity: TelegramBusProtocolIdentity;
+    recipient: {
+        getContextAuthority(ctx: TContext): TelegramBusFollowerRestoreContext | undefined;
+        getJournalBindingKey(ctx: TContext): string | undefined;
+        getProcessIdentity(): {
+            processId: number;
+            processBirthId: string;
+        };
+        registrationState: Pick<TelegramBusFollowerRegistrationState, "getTarget" | "getSlot" | "getGeneration" | "getLeaderProtocol">;
+    };
+}): (input: {
+    ctx: TContext;
+    operationId: string;
+    registrationGeneration: string;
+    effect: TelegramBusSelectedMenuTextEffect;
+    assertAuthority: () => void;
+}) => Promise<TelegramBusSelectedMenuDeliveryObservation>;
 export declare function createTelegramBusFollowerApiCaller(deps: TelegramBusFollowerApiCallerDeps): (method: string, args: unknown[]) => Promise<unknown>;
 export declare function createTelegramBusFollowerSessionReplacementSuspender(deps: TelegramBusFollowerSessionReplacementSuspenderDeps): (preserveTarget?: boolean) => Promise<void>;
 export declare function createTelegramBusFollowerSessionRefreshHook<TContext>(deps: TelegramBusFollowerSessionRefreshHookDeps<TContext>): (_event: unknown, ctx: TContext) => Promise<void>;
@@ -383,6 +429,40 @@ export declare function createTelegramBusFollowerPairedAdmission(deps: {
 export declare function prepareTelegramBusFollowerJournaledUpdateForExecution<TUpdate extends {
     message?: unknown;
 } & Record<string, unknown>>(update: TUpdate, prepareForwardedMessage: (message: NonNullable<TUpdate["message"]>, position: "comment" | "forward") => void): TUpdate;
+/** Existing Commands/menu assembly preflights the copied input and captures independent recipient/transport owners. */
+export interface TelegramBusFollowerCommandOwner<TContext> {
+    isCurrent(): boolean;
+    assertRecipientCurrent(): void;
+    prepare(readiness: TelegramLiveSourceCompletionReadiness, ctx: TContext, input: {
+        target: TelegramTarget & {
+            threadId: number;
+        };
+        assertSourceCurrent(): void;
+        assertRecipientCurrent(): void;
+    }): TelegramPreparedHeldCommand | undefined;
+}
+/** One current warm preparation, not a prompt queue or restart recovery record. */
+export declare function createTelegramBusFollowerLiveRebindRuntime<TContext>(deps: {
+    getAdmission(ctx: TContext): Pick<TelegramUpdateAdmissionLifecycleRuntime<TContext>, "prepareLiveInput" | "appendBatch" | "getJournalBindingKey"> | undefined;
+    applyTarget?: (...args: Parameters<ReturnType<typeof createTelegramBusFollowerWorkspaceRestoreHandler<TContext>>>) => ReturnType<ReturnType<typeof createTelegramBusFollowerWorkspaceRestoreHandler<TContext>>>;
+    observeWork?: (oldTarget: TelegramTarget & {
+        threadId: number;
+    }, ctx: TContext) => TelegramBusLiveRebindWorkState;
+    /** Pure preflight: undefined refuses before hold/append; this port never activates future recipient authority. */
+    getCommandOwner?: (input: Readonly<Omit<Extract<TelegramBusEnvelope, {
+        kind: "leader.prepareLiveRebind";
+    }>, "kind" | "auth" | "requestId" | "sentAtMs">>, ctx: TContext) => TelegramBusFollowerCommandOwner<TContext> | undefined;
+}): {
+    save(envelope: Extract<TelegramBusEnvelope, {
+        kind: "leader.prepareLiveRebind";
+    }>, ctx: TContext, isCurrent: () => boolean): TelegramBusLiveRebindSaveObservation;
+    apply(envelope: Extract<TelegramBusEnvelope, {
+        kind: "leader.applyLiveRebind";
+    }>, ctx: TContext, isCurrent: () => boolean): Promise<TelegramBusLiveRebindApplyObservation>;
+    settle(envelope: Extract<TelegramBusEnvelope, {
+        kind: "leader.settleLiveRebind";
+    }>, ctx: TContext, isCurrent: () => boolean): Promise<TelegramBusLiveRebindSettlementObservation | TelegramBusLiveRebindWorkObservation | TelegramBusLiveRebindCommandObservation>;
+};
 export declare function createTelegramBusFollowerDurableAdmissionRuntime<TContext>(deps: {
     journal: {
         appendBatch(updates: readonly ({