@llblab/pi-telegram 0.52.2 → 0.53.0

package/dist/lib/thread-display.d.ts

@@ -1,6 +1,6 @@
 import type { TelegramThreadDisplayMode } from "./config.ts";
-import type { TelegramTopicTargetStore, TelegramWorkspaceDisplayBinding, TelegramWorkspaceThreadBinding } from "./threads.ts";
 import type { TelegramApiCallOptions } from "./telegram-api.ts";
+import type { TelegramTopicTargetStore, TelegramWorkspaceDisplayBinding, TelegramWorkspaceThreadBinding } from "./threads.ts";
 /** Pure directory tokenization shared by previews, initial titles, and reconciliation. */
 export declare function tokenizeTelegramDirectorySegment(segment: string): string[];
 /** Maps one leader-captured authenticated owner roster onto retained binding identities. */
@@ -13,7 +13,6 @@ export declare function resolveTelegramLiveWorkspaceBindingKeys(bindings: readon
         threadId?: number;
     };
 }[]): ReadonlySet<string>;
-/** Missing or ambiguous metadata yields no label rather than inventing identity. */
 export declare function resolveTelegramWorkspaceDisplayNames(bindings: readonly TelegramWorkspaceDisplayBinding[], mode: TelegramThreadDisplayMode, liveBindingKeys?: ReadonlySet<string>): Map<string, string>;
 export declare function resolveTelegramInitialWorkspaceDisplayName(input: {
     bindings: readonly TelegramWorkspaceDisplayBinding[];

package/dist/lib/thread-display.js

@@ -27,8 +27,7 @@ function distinguishingDirectorySegments(cwd, directories) {
     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(directorySegments(other).slice(-depth).join("/")).toLowerCase() === candidate.toLowerCase());
         if (!collides)
             return parts.slice(-depth);
     }
@@ -50,16 +49,20 @@ function formatDirectoryLabel(cwd, directories, mode) {
     const segments = distinguishingDirectorySegments(cwd, directories);
     if (!segments.length)
         return "/";
-    const formatted = segments.map((segment) => {
+    const formatted = segments
+        .map((segment) => {
         const tokens = tokenizeTelegramDirectorySegment(segment);
         if (!tokens.length)
             return "";
         if (mode === "directory-snake")
             return tokens.map((token) => token.toLowerCase()).join("_");
-        return tokens.map((token) => /\p{L}/u.test(token) && token === token.toUpperCase()
+        return tokens
+            .map((token) => /\p{L}/u.test(token) && token === token.toUpperCase()
             ? token
-            : `${token.slice(0, 1).toUpperCase()}${token.slice(1).toLowerCase()}`).join(" ");
-    }).filter(Boolean);
+            : `${token.slice(0, 1).toUpperCase()}${token.slice(1).toLowerCase()}`)
+            .join(" ");
+    })
+        .filter(Boolean);
     if (!formatted.length)
         return directoryLabel(cwd, directories);
     return formatted.join(mode === "directory-snake" ? "_" : " / ");
@@ -75,9 +78,25 @@ export function resolveTelegramLiveWorkspaceBindingKeys(bindings, leaderTarget,
     add(leaderTarget);
     for (const follower of followers)
         add(follower.target);
-    return new Set(bindings.filter((binding) => targets.has(`${binding.target.chatId}:${binding.target.threadId}`)).map((binding) => binding.bindingKey));
+    return new Set(bindings
+        .filter((binding) => targets.has(`${binding.target.chatId}:${binding.target.threadId}`))
+        .map((binding) => binding.bindingKey));
 }
 /** Missing or ambiguous metadata yields no label rather than inventing identity. */
+/** Case-insensitive label occurrences; directory modes count only live bindings. */
+function countTelegramDisplayLabels(bindings, labels, mode, liveBindingKeys) {
+    const counts = new Map();
+    for (const binding of bindings) {
+        const label = labels.get(binding.bindingKey);
+        if (!label ||
+            ((mode === "directory-snake" || mode === "directory-title") &&
+                !liveBindingKeys.has(binding.bindingKey)))
+            continue;
+        const key = label.toLowerCase();
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+}
 export function resolveTelegramWorkspaceDisplayNames(bindings, mode, liveBindingKeys = new Set()) {
     const labels = new Map();
     const directories = Array.from(new Set(bindings.map((binding) => binding.cwd)));
@@ -111,30 +130,29 @@ export function resolveTelegramWorkspaceDisplayNames(bindings, mode, liveBinding
                 : formatDirectoryLabel(binding.cwd, directories, mode);
             bases.set(binding.bindingKey, base);
             const showSuffix = mode === "directories"
-                ? binding.showSlotSuffix || bindings.filter((candidate) => candidate.cwd === binding.cwd).length > 1
+                ? binding.showSlotSuffix ||
+                    bindings.filter((candidate) => candidate.cwd === binding.cwd)
+                        .length > 1
                 : (liveDirectoryCounts.get(binding.cwd) ?? 0) > 1;
             if (showSuffix && !slot)
                 continue;
-            const suffix = !showSuffix ? "" : mode === "directory-title"
-                ? ` ${slot}`
-                : `_${slot.toLowerCase()}`;
+            const suffix = !showSuffix
+                ? ""
+                : mode === "directory-title"
+                    ? ` ${slot}`
+                    : `_${slot.toLowerCase()}`;
             labels.set(binding.bindingKey, boundedLabel(base, suffix));
         }
     }
     // Long or whitespace-normalized paths can collide even after qualification.
-    if (mode === "directories" || mode === "directory-snake" || mode === "directory-title") {
-        const counts = new Map();
-        for (const binding of bindings) {
-            const label = labels.get(binding.bindingKey);
-            if (!label || ((mode === "directory-snake" || mode === "directory-title") &&
-                !liveBindingKeys.has(binding.bindingKey)))
-                continue;
-            const key = label.toLowerCase();
-            counts.set(key, (counts.get(key) ?? 0) + 1);
-        }
+    if (mode === "directories" ||
+        mode === "directory-snake" ||
+        mode === "directory-title") {
+        const counts = countTelegramDisplayLabels(bindings, labels, mode, liveBindingKeys);
         for (const binding of bindings) {
             const label = labels.get(binding.bindingKey);
-            if (binding.manualThreadName || !label ||
+            if (binding.manualThreadName ||
+                !label ||
                 (counts.get(label.toLowerCase()) ?? 0) < 2)
                 continue;
             if ((mode === "directory-snake" || mode === "directory-title") &&
@@ -146,18 +164,12 @@ export function resolveTelegramWorkspaceDisplayNames(bindings, mode, liveBinding
                 labels.delete(binding.bindingKey);
                 continue;
             }
-            labels.set(binding.bindingKey, boundedLabel(bases.get(binding.bindingKey), mode === "directory-title" ? ` ${binding.slot}` : `_${binding.slot.toLowerCase()}`));
+            labels.set(binding.bindingKey, boundedLabel(bases.get(binding.bindingKey), mode === "directory-title"
+                ? ` ${binding.slot}`
+                : `_${binding.slot.toLowerCase()}`));
         }
     }
-    const counts = new Map();
-    for (const binding of bindings) {
-        const label = labels.get(binding.bindingKey);
-        if (!label || ((mode === "directory-snake" || mode === "directory-title") &&
-            !liveBindingKeys.has(binding.bindingKey)))
-            continue;
-        const key = label.toLowerCase();
-        counts.set(key, (counts.get(key) ?? 0) + 1);
-    }
+    const counts = countTelegramDisplayLabels(bindings, labels, mode, liveBindingKeys);
     for (const [key, label] of labels) {
         if ((counts.get(label.toLowerCase()) ?? 0) > 1)
             labels.delete(key);
@@ -170,7 +182,8 @@ export function resolveTelegramInitialWorkspaceDisplayName(input) {
         ? {
             ...input.binding,
             ...(retained.showSlotSuffix ? { showSlotSuffix: true } : {}),
-            ...(input.preserveRetainedManualName !== false && retained.manualThreadName
+            ...(input.preserveRetainedManualName !== false &&
+                retained.manualThreadName
                 ? { manualThreadName: retained.manualThreadName }
                 : {}),
         }
@@ -182,7 +195,9 @@ export function resolveTelegramInitialWorkspaceDisplayName(input) {
 }
 export async function applyTelegramThreadDisplaySetting(mode, deps) {
     const profile = deps.getProfileKey();
-    const setter = deps.ownsLeader() ? deps.getLeaderSetter() : deps.getFollowerSetter();
+    const setter = deps.ownsLeader()
+        ? deps.getLeaderSetter()
+        : deps.getFollowerSetter();
     if (!setter)
         throw new Error("Thread display settings require a connected compatible instance.");
     await setter(mode);
@@ -196,7 +211,8 @@ export function createTelegramThreadDisplaySettingsRuntime(deps) {
     return {
         isCustom() {
             const target = deps.getTarget();
-            return !!target && typeof deps.getBinding(target)?.manualThreadName === "string";
+            return (!!target &&
+                typeof deps.getBinding(target)?.manualThreadName === "string");
         },
         async setMode(mode) {
             const target = deps.getTarget();
@@ -220,8 +236,10 @@ export function createTelegramThreadDisplayReconciler(deps) {
         const profile = deps.getProfileKey();
         const mode = deps.getMode();
         const assertAuthority = () => {
-            if (epoch === undefined || deps.getLeaderEpoch() !== epoch ||
-                deps.getProfileKey() !== profile || deps.getMode() !== mode) {
+            if (epoch === undefined ||
+                deps.getLeaderEpoch() !== epoch ||
+                deps.getProfileKey() !== profile ||
+                deps.getMode() !== mode) {
                 throw new Error("Telegram Thread display update lost profile, mode, or leader authority.");
             }
         };
@@ -239,7 +257,9 @@ export function createTelegramThreadDisplayReconciler(deps) {
                 throw new Error("Telegram Thread display identity is missing or ambiguous.");
             const assertBinding = (expected) => {
                 assertAuthority();
-                const current = deps.store.listWorkspaceBindings().find((candidate) => candidate.bindingKey === expected.bindingKey);
+                const current = deps.store
+                    .listWorkspaceBindings()
+                    .find((candidate) => candidate.bindingKey === expected.bindingKey);
                 if (!isDeepStrictEqual(current, expected) || !isBindingCurrent()) {
                     throw new Error("Telegram Thread display binding changed.");
                 }

package/dist/lib/thread-naming.d.ts

@@ -14,10 +14,38 @@ export interface TelegramThreadNameDialogCandidate {
     phase: "input";
     expiresAtMs: number;
 }
+export interface TelegramThreadNameDialogLifetime {
+    /** Independent recipient effect authority; never the input handle's deadline or ownership. */
+    readonly assertAuthority?: () => void;
+    isCurrent(): boolean;
+    publish(dialogMessageId: number, assertPublicationCurrent?: () => void): TelegramThreadNameDialogCandidate | undefined;
+    select(action: TelegramThreadNameDialogAction): {
+        kind: "reset" | "cancel" | "expired";
+    };
+    consumeName(text: string): {
+        kind: "name";
+        name: string;
+    } | {
+        kind: "none" | "empty";
+    };
+    reopen(): TelegramThreadNameDialogCandidate | undefined;
+    finish(): void;
+}
 export declare function createTelegramThreadNameDialogRuntime(options?: {
     ttlMs?: number;
     nowMs?: () => number;
 }): {
+    prepare(input: {
+        scope: string;
+        target: TelegramTarget;
+        isCurrent?: () => boolean;
+        assertAuthority?: () => void;
+    }): TelegramThreadNameDialogLifetime | undefined;
+    capture(input: {
+        scope: string;
+        target: TelegramTarget;
+        dialogMessageId: number;
+    }): TelegramThreadNameDialogLifetime | undefined;
     open(input: {
         scope: string;
         target: TelegramTarget;
@@ -49,14 +77,6 @@ export interface TelegramThreadTitleInput {
     profileKey: string;
     threadName?: string;
 }
-export interface TelegramThreadNameInput {
-    seed: string;
-    cwd?: string;
-    role?: "leader" | "follower";
-    peers?: readonly string[];
-    slot?: string;
-}
-export declare function createTelegramThreadName(input: TelegramThreadNameInput): string;
 export declare function normalizeTelegramTopicTargetThreadName(threadName: string): string;
 export declare function getTelegramTopicIdentityName(threadName: string): string;
 export declare function chooseTelegramThreadName(input: {

package/dist/lib/thread-naming.js

@@ -4,7 +4,7 @@
  * Owns name/title value policy and one expiring exact-target dialog per session scope.
  * Excludes occupancy/slot allocation, display-mode projection, transport and API/store effects.
  */
-import { areTelegramTargetsEqual as sameTarget } from "./target.js";
+import { areTelegramTargetsEqual as sameTarget, } from "./target.js";
 export const TELEGRAM_THREAD_NAME_DIALOG_TTL_MS = 5 * 60_000;
 function targetKey(target) {
     return `${target.chatId}:${target.threadId ?? "chat"}`;
@@ -16,99 +16,208 @@ export function createTelegramThreadNameDialogRuntime(options) {
     const ttlMs = options?.ttlMs ?? TELEGRAM_THREAD_NAME_DIALOG_TTL_MS;
     const nowMs = options?.nowMs ?? Date.now;
     const candidates = new Map();
+    const recipientCurrent = (entry) => {
+        try {
+            return entry.isCurrent ? entry.isCurrent() === true : true;
+        }
+        catch {
+            return false;
+        }
+    };
+    const view = (entry) => cloneCandidate({
+        scope: entry.scope,
+        target: entry.target,
+        dialogMessageId: entry.dialogMessageId,
+        phase: "input",
+        expiresAtMs: entry.expiresAtMs,
+    });
+    const createLifetime = (entry) => {
+        const key = targetKey(entry.target);
+        const claim = {};
+        let ended = false;
+        const finish = () => {
+            ended = true;
+            if (candidates.get(key) === entry &&
+                (!entry.consumedBy || entry.consumedBy === claim))
+                candidates.delete(key);
+        };
+        const isCurrent = () => {
+            if (ended ||
+                candidates.get(key) !== entry ||
+                (entry.consumedBy && entry.consumedBy !== claim)) {
+                ended = true;
+                return false;
+            }
+            const current = entry.expiresAtMs > nowMs() && recipientCurrent(entry);
+            // Supplied authority/clock observations may synchronously replace this dialog.
+            if (!current ||
+                entry.expiresAtMs <= nowMs() ||
+                candidates.get(key) !== entry ||
+                (entry.consumedBy && entry.consumedBy !== claim)) {
+                finish();
+                return false;
+            }
+            return true;
+        };
+        return {
+            assertAuthority: entry.assertAuthority,
+            isCurrent,
+            publish(dialogMessageId, assertPublicationCurrent) {
+                if (!isCurrent() || entry.phase !== "delivery")
+                    return undefined;
+                // Source authority is needed for this publication only, never retained by future input/effects.
+                if (assertPublicationCurrent) {
+                    assertPublicationCurrent();
+                    if (entry.expiresAtMs <= nowMs())
+                        return undefined;
+                    assertPublicationCurrent();
+                    if (ended ||
+                        candidates.get(key) !== entry ||
+                        entry.phase !== "delivery")
+                        return undefined;
+                }
+                if (!Number.isSafeInteger(dialogMessageId) || dialogMessageId <= 0) {
+                    finish();
+                    return undefined;
+                }
+                entry.dialogMessageId = dialogMessageId;
+                entry.phase = "input";
+                return view(entry);
+            },
+            select(action) {
+                if (!isCurrent() || entry.phase !== "input")
+                    return { kind: "expired" };
+                if (action === "cancel")
+                    finish();
+                else {
+                    entry.phase = "consumed";
+                    entry.consumedBy = claim;
+                }
+                return { kind: action };
+            },
+            consumeName(text) {
+                if (!isCurrent() || entry.phase !== "input")
+                    return { kind: "none" };
+                const name = text.trim();
+                if (!name)
+                    return { kind: "empty" };
+                entry.phase = "consumed";
+                entry.consumedBy = claim;
+                return { kind: "name", name };
+            },
+            reopen() {
+                if (!isCurrent() ||
+                    entry.phase !== "consumed" ||
+                    entry.consumedBy !== claim) {
+                    return undefined;
+                }
+                // A failed effect may restore input, never renew its deadline or issued handle.
+                const replacement = {
+                    ...entry,
+                    phase: "input",
+                    consumedBy: undefined,
+                };
+                candidates.set(key, replacement);
+                ended = true;
+                return view(replacement);
+            },
+            finish,
+        };
+    };
     const current = (scope, target) => {
-        const key = targetKey(target);
-        const candidate = candidates.get(key);
-        if (!candidate || candidate.scope !== scope ||
-            !sameTarget(candidate.target, target))
+        const entry = candidates.get(targetKey(target));
+        if (!entry ||
+            entry.scope !== scope ||
+            entry.phase !== "input" ||
+            !sameTarget(entry.target, target) ||
+            !createLifetime(entry).isCurrent())
             return undefined;
-        if (candidate.expiresAtMs <= nowMs()) {
-            candidates.delete(key);
+        return entry;
+    };
+    const capture = (input) => {
+        const { scope, dialogMessageId } = input;
+        const target = { ...input.target };
+        const entry = current(scope, target);
+        if (!entry || entry.dialogMessageId !== dialogMessageId)
             return undefined;
-        }
-        return candidate;
+        return createLifetime(entry);
     };
     return {
+        prepare(input) {
+            const scope = input.scope;
+            const target = { ...input.target };
+            const isCurrent = input.isCurrent, assertAuthority = input.assertAuthority;
+            const key = targetKey(target);
+            const previous = candidates.get(key);
+            const entry = {
+                scope,
+                target,
+                phase: "delivery",
+                expiresAtMs: nowMs() + ttlMs,
+                isCurrent,
+                assertAuthority,
+            };
+            if (!recipientCurrent(entry) ||
+                entry.expiresAtMs <= nowMs() ||
+                candidates.get(key) !== previous)
+                return undefined;
+            candidates.set(key, entry);
+            return createLifetime(entry);
+        },
+        capture,
         open(input) {
-            const candidate = {
+            const entry = {
                 scope: input.scope,
                 target: { ...input.target },
-                dialogMessageId: input.dialogMessageId,
                 phase: "input",
+                dialogMessageId: input.dialogMessageId,
                 expiresAtMs: nowMs() + ttlMs,
             };
-            candidates.set(targetKey(input.target), candidate);
-            return cloneCandidate(candidate);
+            candidates.set(targetKey(entry.target), entry);
+            return view(entry);
         },
         select(input) {
-            const candidate = current(input.scope, input.target);
-            if (!candidate || candidate.dialogMessageId !== input.dialogMessageId) {
+            const action = input.action;
+            const lifetime = capture(input);
+            if (!lifetime)
                 return { kind: "expired" };
-            }
-            candidates.delete(targetKey(input.target));
-            return { kind: input.action };
+            const result = lifetime.select(action);
+            lifetime.finish();
+            return result;
         },
         consumeName(input) {
-            const candidate = current(input.scope, input.target);
-            if (!candidate || candidate.phase !== "input")
+            const text = input.text;
+            const entry = current(input.scope, input.target);
+            if (!entry)
                 return { kind: "none" };
-            const name = input.text.trim();
-            if (!name)
-                return { kind: "empty" };
-            candidates.delete(targetKey(input.target));
-            return { kind: "name", name };
+            const lifetime = createLifetime(entry);
+            const result = lifetime.consumeName(text);
+            if (result.kind === "name")
+                lifetime.finish();
+            return result;
         },
         clearScope(scope) {
-            for (const [key, candidate] of candidates) {
-                if (candidate.scope === scope)
+            for (const [key, entry] of candidates) {
+                if (entry.scope === scope)
                     candidates.delete(key);
             }
         },
         inspect(target) {
-            const candidate = candidates.get(targetKey(target));
-            if (!candidate || candidate.expiresAtMs <= nowMs()) {
-                candidates.delete(targetKey(target));
+            const key = targetKey(target);
+            const entry = candidates.get(key);
+            if (!entry)
+                return undefined;
+            if (entry.expiresAtMs <= nowMs()) {
+                if (candidates.get(key) === entry)
+                    candidates.delete(key);
                 return undefined;
             }
-            return cloneCandidate(candidate);
+            if (entry.phase !== "input" || !createLifetime(entry).isCurrent())
+                return undefined;
+            return view(entry);
         },
     };
 }
-function hashString(value) {
-    let hash = 2166136261;
-    for (let index = 0; index < value.length; index += 1) {
-        hash ^= value.charCodeAt(index);
-        hash = Math.imul(hash, 16777619);
-    }
-    return hash >>> 0;
-}
-function getWorkspaceHint(cwd) {
-    if (!cwd)
-        return undefined;
-    const parts = cwd.split("/").filter(Boolean);
-    const last = parts.at(-1)?.trim();
-    if (!last)
-        return undefined;
-    return (last
-        .replace(/[^\p{L}\p{N}._-]+/gu, " ")
-        .trim()
-        .slice(0, 32) || undefined);
-}
-export function createTelegramThreadName(input) {
-    const workspace = getWorkspaceHint(input.cwd);
-    const roleMark = input.role === "leader"
-        ? "Leader"
-        : input.role === "follower"
-            ? "Follower"
-            : undefined;
-    const slot = input.slot ? `Thread ${input.slot}` : undefined;
-    const peerSalt = input.peers?.slice().sort().join("|") ?? "";
-    const fallback = `Instance ${hashString(`${input.seed}|${input.cwd ?? ""}|${input.role ?? ""}|${peerSalt}|${input.slot ?? ""}`)
-        .toString(36)
-        .slice(0, 4)}`;
-    return ([slot, workspace, roleMark].filter(Boolean).join(" ").slice(0, 96) ||
-        fallback);
-}
 export function normalizeTelegramTopicTargetThreadName(threadName) {
     return threadName.replace(/\s+/g, " ").trim().slice(0, 96);
 }

package/dist/lib/thread-reconciler.d.ts

@@ -126,15 +126,6 @@ export type ThreadReconciliationAction = {
     instanceId?: string;
     messageId?: number;
     leaderEpoch?: number | string;
-} | {
-    kind: "close-delete-disconnected-instance-topic";
-    target: TelegramTarget & {
-        threadId: number;
-    };
-    reason: "manual-disconnect";
-    instanceId?: string;
-    messageId?: number;
-    leaderEpoch?: number | string;
 } | {
     kind: "close-delete-graceful-shutdown-topic";
     target: TelegramTarget & {
@@ -220,6 +211,14 @@ export interface ThreadReconciliationInput {
     previousState?: ThreadReconciliationMachineState;
     freshCreationGraceMs?: number;
 }
+/** A Thread record still claims its slot/target while active, starting or pending. */
+export declare function isCurrentThreadRecord(record: {
+    readonly status: string;
+}): boolean;
+/** Pure Bot API vocabulary for a deleted/missing Thread; callers own their HTTP-status policy. */
+export declare function isTelegramTopicDeletedErrorMessage(message: string): boolean;
+/** Pure Bot API vocabulary for a closed Thread; closure is not deletion evidence. */
+export declare function isTelegramTopicClosedErrorMessage(message: string): boolean;
 export interface ThreadReconciliationRuntime {
     getState: () => ThreadReconciliationMachineState | undefined;
     recordPlan: (plan: ThreadReconciliationPlan) => void;
@@ -229,13 +228,40 @@ export declare function createThreadReconciliationRuntime(deps: {
     recordRuntimeEvent: (category: string, message: unknown, details?: Record<string, unknown>) => void;
     scheduleSnapshotPersist: () => void;
 }): ThreadReconciliationRuntime;
-export declare function planDisconnectedInstanceThreadCleanup(input: {
-    target: TelegramTarget & {
-        threadId: number;
-    };
-    instanceId?: string;
-    leaderEpoch?: number | string;
-}): ThreadReconciliationPlan;
+/** Momentary preparation evidence only: not an action, lease, issued effect or reusable deletion grant. */
+export interface TelegramLiveRebindCleanupPreparation {
+    status: "prepared";
+    operationId: string;
+    target: ThreadTarget;
+    recipientTarget: ThreadTarget;
+    leaderEpoch: string;
+}
+export declare function prepareLiveRebindThreadCleanup(input: {
+    operationId: string;
+    oldTarget: ThreadTarget;
+    recipientTarget: ThreadTarget;
+    leaderEpoch: string;
+    targetProtected: boolean;
+    /** Narrow body-free current-work projection; no cached idle or historical disposition proof. */
+    work: Readonly<{
+        sessionBusy: boolean;
+        targetWork: boolean;
+        deliveryPending: boolean;
+        unknown: boolean;
+    }> | undefined;
+}): TelegramLiveRebindCleanupPreparation | undefined;
+export type TelegramLiveRebindCleanupOutcome = "confirmed" | "failed" | "unknown";
+/**
+ * One unretried deletion for an already issued live-rebind cleanup grant. Success or confirmed absence is `confirmed`;
+ * protection or authority loss before the request and a definite request rejection are `failed`; every other outcome is
+ * `unknown`. The caller owns the durable issue marker and terminal record; this never repeats or rolls back.
+ */
+export declare function issueLiveRebindThreadCleanup(prepared: TelegramLiveRebindCleanupPreparation, ports: {
+    /** Throws when the issuer's current recipient/work/ownership authority no longer holds. */
+    assertCurrent(): void;
+    deleteTopic(target: ThreadTarget): Promise<unknown>;
+    classifyFailure(error: unknown): "absent" | "rejected" | "unknown";
+}): Promise<TelegramLiveRebindCleanupOutcome>;
 export declare function applyThreadReconciliationPlan(plan: ThreadReconciliationPlan, ports: ThreadReconciliationApplyPorts): Promise<ThreadReconciliationApplyResult>;
 export declare function planThreadReconciliation(input: ThreadReconciliationInput): ThreadReconciliationPlan;
 export {};