@llblab/pi-telegram 0.54.4 → 0.55.0

package/dist/lib/telegram-api.js

@@ -68,7 +68,24 @@ function parseTelegramApiTargetInteger(value) {
         ? parsed
         : undefined;
 }
-export function createTelegramApiTargetActivityRuntime() {
+/** Optional drain hints are not transport outcomes or request authority. */
+function captureApiDrainObserver(capture) {
+    try {
+        const notify = capture?.();
+        return () => {
+            try {
+                const emitted = notify?.();
+                if (emitted)
+                    void Promise.resolve(emitted).catch(() => undefined);
+            }
+            catch { /* Observer failure is inert. */ }
+        };
+    }
+    catch {
+        return () => { };
+    }
+}
+export function createTelegramApiTargetActivityRuntime(deps = {}) {
     const pending = new Map();
     const pendingChats = new Map();
     const messageScopedMethods = new Set([
@@ -103,6 +120,7 @@ export function createTelegramApiTargetActivityRuntime() {
             else {
                 pendingChats.set(chatId, (pendingChats.get(chatId) ?? 0) + 1);
             }
+            const notifyDrained = captureApiDrainObserver(deps.captureDrain);
             let completed = false;
             return () => {
                 if (completed)
@@ -110,15 +128,19 @@ export function createTelegramApiTargetActivityRuntime() {
                 completed = true;
                 if (!key) {
                     const count = pendingChats.get(chatId);
-                    if (!count || count <= 1)
+                    if (!count || count <= 1) {
                         pendingChats.delete(chatId);
+                        notifyDrained();
+                    }
                     else
                         pendingChats.set(chatId, count - 1);
                     return;
                 }
                 const current = pending.get(key);
-                if (!current || current.count <= 1)
+                if (!current || current.count <= 1) {
                     pending.delete(key);
+                    notifyDrained();
+                }
                 else
                     current.count -= 1;
             };
@@ -953,6 +975,7 @@ export function buildTelegramAnswerGuestQueryBody(guestQueryId, text, options) {
 export function createDefaultTelegramBridgeApiRuntime(deps) {
     const client = createTelegramApiClient(deps.getBotToken, {
         recordRuntimeEvent: deps.recordRuntimeEvent,
+        isThreadedMode: deps.isThreadedMode,
     });
     const admittedClient = deps.workspaceAdmission
         ? createTelegramApiWorkspaceAdmissionClient(client, deps.workspaceAdmission, {
@@ -1064,6 +1087,8 @@ export function createTelegramBridgeApiRuntime(deps) {
             request = Promise.resolve()
                 .then(() => deps.client.call(method, body, {
                 ...options,
+                // Presence is replaceable, not a queued body to replay after its session/loop owner ends.
+                ...(body.action === "typing" ? { maxAttempts: 1, retrySafety: "non-idempotent" } : {}),
                 retryRateLimit: false,
             }))
                 .then((result) => {
@@ -1164,7 +1189,7 @@ export function createTelegramBridgeApiRuntime(deps) {
             ...(options?.message_thread_id !== undefined
                 ? { message_thread_id: options.message_thread_id }
                 : {}),
-        }), "typing"),
+        }, { assertAuthority: options?.assertAuthority }), "typing"),
         sendRecordVoiceAction: createTelegramChatActionSender((chatId, action, options) => callRecorded("sendChatAction", {
             chat_id: chatId,
             action,
@@ -1266,9 +1291,31 @@ export function createTelegramBridgeApiRuntime(deps) {
 export function createTelegramApiClient(getBotToken, options = {}) {
     const now = options.now ?? Date.now;
     const recordRuntimeEvent = options.recordRuntimeEvent;
+    const isThreadedMode = options.isThreadedMode;
+    const fenceOutput = (method, body, callOptions) => {
+        if (!isThreadedMode || !/^(send[A-Z]|copyMessages?$|forwardMessages?$)/.test(method))
+            return callOptions;
+        const assertAuthority = () => {
+            const chatId = typeof body.chat_id === "number" || typeof body.chat_id === "string"
+                ? Number(body.chat_id) : undefined;
+            const thread = body.message_thread_id;
+            const threadId = typeof thread === "number" || (typeof thread === "string" && /^[1-9][0-9]*$/.test(thread))
+                ? Number(thread) : undefined;
+            // Business connections and channels are distinct from the bot's private-chat All namespace.
+            if (isThreadedMode() && chatId !== undefined && Number.isSafeInteger(chatId) && chatId > 0 &&
+                !(typeof body.business_connection_id === "string" && body.business_connection_id.length > 0) &&
+                (threadId === undefined || !Number.isSafeInteger(threadId) || threadId <= 0))
+                throw new Error("Telegram All is input-only in Threaded Mode; an explicit Thread target is required.");
+            callOptions?.assertAuthority?.();
+        };
+        assertAuthority();
+        return { ...callOptions, assertAuthority };
+    };
     const draftRetryNotBeforeByTarget = new Map();
     return {
         call: async (method, body, options) => {
+            body = { ...body };
+            options = fenceOutput(method, body, options);
             const token = getBotToken();
             // Cooldown keys retain only the public bot-id prefix, not the credential.
             const botId = token?.match(/^(\d+):/)?.[1];
@@ -1316,6 +1363,8 @@ export function createTelegramApiClient(getBotToken, options = {}) {
             }
         },
         callMultipart: async (method, fields, fileField, filePath, fileName, options) => {
+            fields = { ...fields };
+            options = fenceOutput(method, fields, options);
             return callTelegramMultipart(getBotToken(), method, fields, fileField, filePath, fileName, options);
         },
         downloadFile: async (fileId, suggestedName, tempDir, options) => {

package/dist/lib/text-groups.d.ts

@@ -22,18 +22,6 @@ export interface TelegramTextGroupMessage {
     forward_from?: TelegramMessageUser;
     forward_sender_name?: string;
 }
-export interface TelegramTextGroupState<TMessage, TContext = unknown> {
-    messages: TMessage[];
-    context?: TContext;
-    flushTimer?: ReturnType<typeof setTimeout>;
-    dispatching?: boolean;
-    suspended?: boolean;
-    reschedule?: (delayMs?: number) => void;
-    dispatchNow?: () => Promise<void>;
-    dispatchPromise?: Promise<void>;
-    dispatchLimit?: number;
-    forwardPairCandidate?: TelegramForwardCommentBatchPosition;
-}
 export type TelegramForwardCommentBatchPosition = "comment" | "forward";
 export interface TelegramTextGroupController<TMessage, TContext = unknown> {
     prepareUpdateBatch: (updates: readonly {
@@ -65,20 +53,6 @@ export interface TelegramGroupedInputClearerDeps {
     clearMediaGroups: () => void;
     clearTextGroups: () => void;
 }
-export declare function queueTelegramTextGroupMessage<TMessage extends TelegramTextGroupMessage, TContext = unknown>(options: {
-    message: TMessage;
-    context: TContext;
-    groups: Map<string, TelegramTextGroupState<TMessage, TContext>>;
-    debounceMs: number;
-    minSplitLength: number;
-    setTimer: (callback: () => void, ms: number) => ReturnType<typeof setTimeout>;
-    clearTimer: (timer: ReturnType<typeof setTimeout>) => void;
-    dispatchMessages: (messages: TMessage[], ctx: TContext) => unknown | Promise<unknown>;
-    forceStart?: boolean;
-    dispatchImmediately?: boolean;
-    forwardPairCandidate?: TelegramForwardCommentBatchPosition;
-    delayMs?: number;
-}): boolean;
 export declare function createTelegramTextGroupController<TMessage extends TelegramTextGroupMessage, TContext = unknown>(options?: TelegramTextGroupControllerOptions): TelegramTextGroupController<TMessage, TContext>;
 export declare function createTelegramTextGroupDispatchRuntime<TMessage extends TelegramTextGroupMessage, TContext>(deps: {
     textGroups: TelegramTextGroupController<TMessage, TContext>;

package/dist/lib/text-groups.js

@@ -4,7 +4,7 @@
  * Owns conservative delayed grouping for Telegram text messages that look like automatic long-message splits
  */
 import { setTimeout as waitForTimeout } from "node:timers/promises";
-import { createTelegramPendingGroupLifecycle, extractTelegramMessageText, } from "./media.js";
+import { createTelegramPendingGroups, extractTelegramMessageText, } from "./media.js";
 const TELEGRAM_TEXT_GROUP_DEBOUNCE_MS = 1000;
 const TELEGRAM_TEXT_GROUP_MIN_SPLIT_LENGTH = 3600;
 const TELEGRAM_TEXT_GROUP_MAX_MESSAGE_ID_GAP = 12;
@@ -47,9 +47,9 @@ function canStartTelegramTextGroup(message, minSplitLength) {
     const text = extractTelegramTextGroupText(message);
     return text.length >= minSplitLength && !isTelegramTextGroupCommand(text);
 }
-function canAppendTelegramTextGroupMessage(state, message) {
+function canAppendTelegramTextGroupMessage(group, message) {
     const text = extractTelegramTextGroupText(message);
-    const previous = state.messages.at(-1);
+    const previous = group.messages.at(-1);
     return (!!previous &&
         message.message_id > previous.message_id &&
         message.message_id <=
@@ -57,83 +57,7 @@ function canAppendTelegramTextGroupMessage(state, message) {
         (text.length > 0 || isTelegramForwardedMessage(message)) &&
         !isTelegramTextGroupCommand(text));
 }
-export function queueTelegramTextGroupMessage(options) {
-    const key = getTelegramTextGroupKey(options.message);
-    if (!key)
-        return false;
-    const existing = options.groups.get(key);
-    const duplicateIndex = existing?.messages.findIndex((message) => message.message_id === options.message.message_id);
-    if (existing && duplicateIndex !== undefined && duplicateIndex >= 0) {
-        existing.messages[duplicateIndex] = options.message;
-        existing.context = options.context;
-        existing.forwardPairCandidate = options.forwardPairCandidate;
-        if (!existing.suspended && !existing.dispatching && !existing.flushTimer) {
-            existing.reschedule?.();
-        }
-        return true;
-    }
-    if (!existing &&
-        !options.forceStart &&
-        !canStartTelegramTextGroup(options.message, options.minSplitLength))
-        return false;
-    if (existing && !canAppendTelegramTextGroupMessage(existing, options.message))
-        return false;
-    const state = existing ?? { messages: [] };
-    state.messages.push(options.message);
-    state.context = options.context;
-    state.forwardPairCandidate = options.forwardPairCandidate;
-    const dispatchQueued = () => {
-        state.flushTimer = undefined;
-        const queued = options.groups.get(key);
-        if (!queued || queued.context === undefined)
-            return Promise.resolve();
-        if (queued.dispatching)
-            return queued.dispatchPromise ?? Promise.resolve();
-        const dispatchCount = queued.dispatchLimit ?? queued.messages.length;
-        queued.dispatchLimit = undefined;
-        const dispatchedMessages = queued.messages.slice(0, dispatchCount);
-        const dispatchedIds = new Set(dispatchedMessages.map((message) => message.message_id));
-        queued.dispatching = true;
-        const operation = Promise.resolve(options.dispatchMessages(dispatchedMessages, queued.context)).then(() => {
-            if (options.groups.get(key) !== queued)
-                return;
-            queued.messages = queued.messages.filter((message) => !dispatchedIds.has(message.message_id));
-            queued.dispatching = false;
-            queued.dispatchPromise = undefined;
-            if (queued.messages.length === 0)
-                options.groups.delete(key);
-            else if (!queued.flushTimer)
-                scheduleDispatch();
-        }, (error) => {
-            if (options.groups.get(key) === queued) {
-                queued.dispatching = false;
-                queued.dispatchPromise = undefined;
-                if (!queued.flushTimer)
-                    scheduleDispatch();
-            }
-            throw error;
-        });
-        queued.dispatchPromise = operation;
-        return operation;
-    };
-    const scheduleDispatch = (delayMs = options.debounceMs) => {
-        if (state.suspended)
-            return;
-        state.flushTimer = options.setTimer(() => {
-            void dispatchQueued().catch(() => undefined);
-        }, delayMs);
-        state.flushTimer.unref?.();
-    };
-    state.reschedule = scheduleDispatch;
-    state.dispatchNow = dispatchQueued;
-    if (state.flushTimer)
-        options.clearTimer(state.flushTimer);
-    scheduleDispatch(options.dispatchImmediately ? 0 : (options.delayMs ?? options.debounceMs));
-    options.groups.set(key, state);
-    return true;
-}
 export function createTelegramTextGroupController(options = {}) {
-    const groups = new Map();
     const plannedForwardCommentStarts = new Set();
     const plannedForwardCommentEnds = new Set();
     const debounceMs = options.debounceMs ?? TELEGRAM_TEXT_GROUP_DEBOUNCE_MS;
@@ -155,7 +79,40 @@ export function createTelegramTextGroupController(options = {}) {
             : (timer) => {
                 timer.abort();
             });
-    const lifecycle = createTelegramPendingGroupLifecycle(groups, clearTimer);
+    const groups = createTelegramPendingGroups({ debounceMs, requireContext: true, setTimer, clearTimer });
+    /** Admission policy for one message; the shared group machine owns timers, batches and dispatch. */
+    const queueTextGroupMessage = (options) => {
+        const existing = groups.get(options.key);
+        const dispatchMessages = (messages, ctx) => options.dispatchMessages(messages, ctx);
+        const queued = {
+            key: options.key,
+            message: options.message,
+            context: options.context,
+            ...(options.forwardPairCandidate === undefined
+                ? {}
+                : { meta: options.forwardPairCandidate }),
+            dispatchMessages,
+        };
+        if (existing?.messages.some((message) => message.message_id === options.message.message_id)) {
+            groups.queue({ ...queued, delayMs: debounceMs, rearm: "ifIdle" });
+            return true;
+        }
+        if (!existing &&
+            !options.forceStart &&
+            !canStartTelegramTextGroup(options.message, minSplitLength))
+            return false;
+        if (existing &&
+            !canAppendTelegramTextGroupMessage(existing, options.message))
+            return false;
+        groups.queue({
+            ...queued,
+            delayMs: options.dispatchImmediately
+                ? 0
+                : (options.delayMs ?? debounceMs),
+            rearm: "always",
+        });
+        return true;
+    };
     return {
         prepareUpdateBatch(updates) {
             for (let index = 0; index + 1 < updates.length; index += 1) {
@@ -203,22 +160,18 @@ export function createTelegramTextGroupController(options = {}) {
             const forwarded = isTelegramForwardedMessage(message);
             const existing = key ? groups.get(key) : undefined;
             const text = extractTelegramTextGroupText(message);
-            if (existing && isTelegramTextGroupClearingCommand(text)) {
-                if (existing.flushTimer)
-                    clearTimer(existing.flushTimer);
-                groups.delete(key);
-            }
+            if (existing && isTelegramTextGroupClearingCommand(text))
+                groups.clearKey(key);
             const candidatePosition = forwarded
                 ? "forward"
                 : "comment";
-            const existingCandidate = existing?.forwardPairCandidate;
+            const existingCandidate = existing?.meta;
             const pairCompleted = existingCandidate !== undefined &&
                 existingCandidate !== candidatePosition;
             const separateFromCandidate = existingCandidate === candidatePosition &&
                 !isTelegramTextGroupCommand(text);
-            if (separateFromCandidate && existing) {
-                existing.dispatchLimit = existing.messages.length;
-            }
+            if (separateFromCandidate && existing)
+                groups.closeBatch(key);
             const forceStart = plannedStart ||
                 (forwardCommentWaitMs !== false &&
                     !!key &&
@@ -228,15 +181,13 @@ export function createTelegramTextGroupController(options = {}) {
             const dispatchImmediately = pairCompleted ||
                 separateFromCandidate ||
                 plannedForwardCommentEnds.delete(identity) ||
-                (forwarded && !!key && groups.has(key));
-            return queueTelegramTextGroupMessage({
+                (forwarded && !!key && groups.get(key) !== undefined);
+            if (!key)
+                return false;
+            return queueTextGroupMessage({
+                key,
                 message,
                 context,
-                groups,
-                debounceMs,
-                minSplitLength,
-                setTimer,
-                clearTimer,
                 dispatchMessages,
                 forceStart,
                 dispatchImmediately,
@@ -250,9 +201,11 @@ export function createTelegramTextGroupController(options = {}) {
                     : undefined,
             });
         },
-        ...lifecycle,
+        flushMessage: groups.flushMessage,
+        suspend: groups.suspend,
+        resume: groups.resume,
         clear: () => {
-            lifecycle.clear();
+            groups.clear();
             plannedForwardCommentStarts.clear();
             plannedForwardCommentEnds.clear();
         },

package/dist/lib/thread-display.js

@@ -4,7 +4,9 @@
  * Owns mode-specific labels and serialized, authority-fenced title application.
  * Excludes routing, name allocation, profile mutation, and live-owner discovery.
  */
+import { homedir } from "node:os";
 import { isDeepStrictEqual } from "node:util";
+import { normalizeTelegramWorkspacePath } from "./workspace-identity.js";
 function labelText(value) {
     return value.replace(/\s+/gu, " ").trim();
 }
@@ -20,14 +22,16 @@ function boundedLabel(base, suffix = "") {
 function directorySegments(cwd) {
     return cwd.split("/").filter(Boolean);
 }
-function distinguishingDirectorySegments(cwd, directories) {
-    const parts = directorySegments(cwd);
+function distinguishingDirectorySegments(cwd, directories, homeDirectory) {
+    // Substitute only exact home identity; qualification must still distinguish ordinary folders named home.
+    const segments = (directory) => directory === homeDirectory ? ["home"] : directorySegments(directory);
+    const parts = segments(cwd);
     if (!parts.length)
         return [];
     for (let depth = 1; depth <= parts.length; depth++) {
         const candidate = labelText(parts.slice(-depth).join("/"));
         const collides = directories.some((other) => other !== cwd &&
-            labelText(directorySegments(other).slice(-depth).join("/")).toLowerCase() === candidate.toLowerCase());
+            labelText(segments(other).slice(-depth).join("/")).toLowerCase() === candidate.toLowerCase());
         if (!collides)
             return parts.slice(-depth);
     }
@@ -45,8 +49,8 @@ export function tokenizeTelegramDirectorySegment(segment) {
         .split(/[^\p{L}\p{N}]+|\u0000/gu)
         .filter(Boolean);
 }
-function formatDirectoryLabel(cwd, directories, mode) {
-    const segments = distinguishingDirectorySegments(cwd, directories);
+function formatDirectoryLabel(cwd, directories, mode, homeDirectory) {
+    const segments = distinguishingDirectorySegments(cwd, directories, homeDirectory);
     if (!segments.length)
         return "/";
     const formatted = segments
@@ -99,6 +103,10 @@ function countTelegramDisplayLabels(bindings, labels, mode, liveBindingKeys) {
 }
 export function resolveTelegramWorkspaceDisplayNames(bindings, mode, liveBindingKeys = new Set()) {
     const labels = new Map();
+    const homeDirectory = (mode === "directory-snake" || mode === "directory-title") &&
+        (process.platform === "linux" || process.platform === "darwin")
+        ? normalizeTelegramWorkspacePath(homedir())
+        : undefined;
     const directories = Array.from(new Set(bindings.map((binding) => binding.cwd)));
     const liveDirectoryCounts = new Map();
     for (const binding of bindings) {
@@ -127,7 +135,7 @@ export function resolveTelegramWorkspaceDisplayNames(bindings, mode, liveBinding
         else {
             const base = mode === "directories"
                 ? directoryLabel(binding.cwd, directories)
-                : formatDirectoryLabel(binding.cwd, directories, mode);
+                : formatDirectoryLabel(binding.cwd, directories, mode, homeDirectory);
             bases.set(binding.bindingKey, base);
             const showSuffix = mode === "directories"
                 ? binding.showSlotSuffix ||

package/dist/lib/threads.d.ts

@@ -248,6 +248,10 @@ export interface TelegramWorkspaceRestoreIntent {
 /** Live same-session metadata, never a legacy scoped ACK or permission to dispatch/delete. */
 export type TelegramWorkspaceLiveRebindIntent = Pick<TelegramWorkspaceRestoreIntent, "request" | "operatorUserId" | "executor" | "revision" | "createdAtMs" | "updatedAtMs"> & {
     kind: "live-rebind";
+    /** Versioned native input gate: terminal cleanup does not itself authorize or settle input. */
+    inputRelease?: "held" | "issued" | "accepted";
+    /** A session-replacing producer must not drop earlier old-target protection or carry its delete grant forward. */
+    oldTargetProtected?: true;
     recipient: TelegramWorkspaceRestoreRecipient;
 } & ({
     phase: "rebound";
@@ -324,9 +328,11 @@ export interface TelegramWorkspaceRestore {
     list(): TelegramWorkspaceRestoreIntent[];
     listLiveRebindings(): TelegramWorkspaceLiveRebindIntent[];
     /** Caller has saved and held the selected input; this publishes the binding, not dispatch readiness. */
-    commitLiveRebind(request: TelegramWorkspaceRestoreRequest, recipient: TelegramWorkspaceRestoreRecipient, authority: TelegramWorkspaceRestoreAuthority): Promise<TelegramWorkspaceLiveRebindIntent | undefined>;
+    commitLiveRebind(request: TelegramWorkspaceRestoreRequest, recipient: TelegramWorkspaceRestoreRecipient, authority: TelegramWorkspaceRestoreAuthority, options?: {
+        holdInput: true;
+    }): Promise<TelegramWorkspaceLiveRebindIntent | undefined>;
     /** Caller proves local apply for release or current live clearance for cleanup; unknown issuance never repeats. */
-    advanceLiveRebind(expected: TelegramWorkspaceLiveRebindIntent, step: "release" | "issue-cleanup" | Extract<TelegramWorkspaceLiveRebindIntent, {
+    advanceLiveRebind(expected: TelegramWorkspaceLiveRebindIntent, step: "release" | "issue-cleanup" | "issue-input" | "accept-input" | "protect-old-target" | Extract<TelegramWorkspaceLiveRebindIntent, {
         phase: "finished";
     }>["cleanup"], authority: TelegramWorkspaceRestoreAuthority): TelegramWorkspaceLiveRebindIntent | undefined;
     commit(request: TelegramWorkspaceRestoreRequest, authority: TelegramWorkspaceRestoreAuthority): Promise<TelegramWorkspaceRestoreIntent | undefined>;
@@ -359,8 +365,11 @@ export interface TelegramWorkspaceRestore {
     inspectTemporaryThreadTarget(expected: TelegramTemporaryThreadEntry, authority: TelegramWorkspaceRestoreAuthority): TelegramTemporaryThreadTargetObservation | undefined;
     /** Read-only veto for an already-granted in-flight attempt; never another grant, disposable classification or deletion ACK. */
     isTemporaryThreadCleanupCurrent(expected: TelegramTemporaryThreadEntry, authority: TelegramWorkspaceRestoreAuthority): boolean;
-    /** Publishes `creating` before the caller's single creation request; an existing source entry is returned, never recreated. */
-    reserveTemporaryThread(source: TelegramTemporaryThreadEntry["source"], token: string, authority: TelegramWorkspaceRestoreAuthority): {
+    /**
+     * Publishes `creating` before the caller's single creation request; an existing source entry is returned, never
+     * recreated. `group` records an album as the tab's one creating input; it must start at the source update.
+     */
+    reserveTemporaryThread(source: TelegramTemporaryThreadEntry["source"], token: string, authority: TelegramWorkspaceRestoreAuthority, group?: TelegramTemporaryThreadInput): {
         reserved: boolean;
         entry: TelegramTemporaryThreadEntry;
     } | undefined;
@@ -467,6 +476,8 @@ export interface TelegramTopicTargetStore {
     /** Exact synchronous live-operation snapshot, including a current publication frame; no mutation, lock or authority grant. */
     withWorkspaceLiveRebindSnapshot: (expected: TelegramWorkspaceLiveRebindIntent, observe: (snapshot: Readonly<Pick<TelegramTopicTargetFile, "threads" | "workspaceBindings">>) => undefined) => void;
     /** Current live-origin ownership veto; effect callers still require Workspace admission. False is not work/recipient/deletion authority. */
+    hasPreDispatchRebindEvidence: () => boolean;
+    listProtectedLiveRebindTargets: () => TelegramTarget[];
     isWorkspaceLiveRebindCleanupTargetProtected: (expected: TelegramWorkspaceLiveRebindIntent) => boolean;
     /** Read-only captured identity with an optional exact manual-name result fence; no transport/session/admission grant or lock. */
     captureWorkspaceThreadRenameObservation: (binding: TelegramWorkspaceThreadBinding, owner: TelegramTopicTargetRecord) => (expectedManualThreadName?: string) => boolean;
@@ -572,7 +583,7 @@ export interface TelegramTopicTargetStore {
     /** Claim the first reusable inactive thread for an instance, linking it to instanceId. */
     claimReusableTarget: (instanceId: string, threadName?: string) => TelegramTopicTargetRecord | undefined;
 }
-export declare function createTelegramCleanupTargetProtection(store: Pick<TelegramTopicTargetStore, "list"> & Partial<Pick<TelegramTopicTargetStore, "listReservations" | "listPendingProvisions" | "listPendingCleanups" | "listTemporaryThreadTargets">>, departingRecord?: TelegramTopicTargetRecord): NonNullable<ThreadReconciler.ThreadReconciliationApplyPorts["isCleanupTargetProtected"]>;
+export declare function createTelegramCleanupTargetProtection(store: Pick<TelegramTopicTargetStore, "list"> & Partial<Pick<TelegramTopicTargetStore, "listReservations" | "listPendingProvisions" | "listPendingCleanups" | "listTemporaryThreadTargets" | "listProtectedLiveRebindTargets">>, departingRecord?: TelegramTopicTargetRecord): NonNullable<ThreadReconciler.ThreadReconciliationApplyPorts["isCleanupTargetProtected"]>;
 export interface TelegramTopicTargetStoreOptions {
     path: string | (() => string);
     telegramProfile?: string | (() => string | undefined);
@@ -661,6 +672,8 @@ export declare function getTelegramWorkspaceRestoreSourceCompletionSha256(operat
 export declare function getTelegramTemporaryThreadInputs(entry: TelegramTemporaryThreadEntry): TelegramTemporaryThreadInput[];
 /** Every known group is durably cancelled or Forward-completed; still not deletion authority by itself. */
 export declare function isTelegramTemporaryThreadFullyResolved(entry: TelegramTemporaryThreadEntry): boolean;
+/** Canonical issuance is distinct from cleanup completion, source disposition and peer dispatch readiness. */
+export declare function isTelegramLiveRebindInputAuthorized(value: TelegramWorkspaceLiveRebindIntent): boolean;
 /** The unified section accepts only lossless current-format Workspace evidence, never tolerant legacy repair. */
 export declare function parseTelegramWorkspaceStateSection(value: unknown, profile: string): TelegramTopicTargetFile | undefined;
 export declare function resolveTelegramWorkspaceProvisionRecoveryPath(statePath: string, profileName?: string, layout?: "consolidated"): string;