@llblab/pi-kit 0.36.1 → 0.36.2

package/node_modules/@llblab/pi-telegram/dist/lib/prompts.d.ts

@@ -1,9 +1,9 @@
 /**
  * Telegram prompt injection helpers
  * Zones: pi agent prompts, telegram guidance
- * Owns Telegram-specific system prompt suffixes injected into pi agent turns
+ * Owns stable Telegram guidance, turn-scoped context, and compatibility fallback hooks
  */
-import type { BeforeAgentStartEvent } from "./pi.ts";
+import type { BeforeAgentStartEvent, BeforeAgentStartEventResult } from "./pi.ts";
 export declare const TELEGRAM_CONNECTED_CONTEXT_MESSAGE = "Telegram session connected. Use Telegram features for Telegram-originated turns or explicit Telegram requests; connectivity alone is not user intent.";
 export declare const TELEGRAM_DISCONNECTED_CONTEXT_MESSAGE = "Telegram session disconnected. Do not use Telegram delivery, actions, or Telegram-specific reply features unless the user reconnects it.";
 export declare const TELEGRAM_ATTACH_PROMPT_SNIPPET = "Queue files for the active Telegram reply; outside Telegram turns, send files directly to Telegram.";
@@ -37,6 +37,9 @@ type TelegramBeforeAgentStartEvent = Omit<BeforeAgentStartEvent, "systemPrompt"
 type TelegramBeforeAgentStartResult = {
     systemPrompt: TelegramSystemPrompt;
 };
+type TelegramProactiveBeforeAgentStartResult = Omit<BeforeAgentStartEventResult, "systemPrompt"> & {
+    systemPrompt?: TelegramSystemPrompt;
+};
 type TelegramBeforeAgentStartHook = (event: TelegramBeforeAgentStartEvent) => TelegramBeforeAgentStartResult;
 export declare function buildTelegramBridgeSystemPrompt(options: {
     prompt?: string;
@@ -55,5 +58,5 @@ export interface TelegramProactivePromptHookDeps<TContext> {
     reconcileAvailability?: () => void;
     isAvailable: (ctx: TContext) => boolean;
 }
-export declare function createTelegramProactiveBeforeAgentStartHook<TContext>(deps: TelegramProactivePromptHookDeps<TContext>): (event: TelegramBeforeAgentStartEvent, ctx: TContext) => Promise<TelegramBeforeAgentStartResult>;
+export declare function createTelegramProactiveBeforeAgentStartHook<TContext>(deps: TelegramProactivePromptHookDeps<TContext>): (event: TelegramBeforeAgentStartEvent, ctx: TContext) => Promise<TelegramProactiveBeforeAgentStartResult | undefined>;
 export {};

package/node_modules/@llblab/pi-telegram/dist/lib/prompts.js

@@ -1,7 +1,7 @@
 /**
  * Telegram prompt injection helpers
  * Zones: pi agent prompts, telegram guidance
- * Owns Telegram-specific system prompt suffixes injected into pi agent turns
+ * Owns stable Telegram guidance, turn-scoped context, and compatibility fallback hooks
  */
 import { TELEGRAM_PREFIX } from "./turns.js";
 export const TELEGRAM_CONNECTED_CONTEXT_MESSAGE = "Telegram session connected. Use Telegram features for Telegram-originated turns or explicit Telegram requests; connectivity alone is not user intent.";
@@ -107,8 +107,17 @@ export function createTelegramModelContextAvailabilityRuntime(deps) {
         },
     };
 }
-export function buildTelegramBridgeSystemPrompt(options) {
-    const basePrompt = options.systemPrompt ?? "";
+// Returning any systemPrompt makes Pi replace its prompt, which defeats prompt
+// caching; return an override only when the computed prompt actually differs.
+function overrideSystemPromptIfChanged(incoming, computed) {
+    const base = incoming ?? "";
+    const unchanged = Array.isArray(base) && Array.isArray(computed)
+        ? base.length === computed.length &&
+            base.every((block, index) => block === computed[index])
+        : base === computed;
+    return unchanged ? undefined : { systemPrompt: computed };
+}
+function buildTelegramTurnSuffix(options) {
     const telegramPrefix = options.telegramPrefix ?? TELEGRAM_PREFIX;
     const telegramHead = telegramPrefix.endsWith("]")
         ? telegramPrefix.slice(0, -1)
@@ -116,9 +125,13 @@ export function buildTelegramBridgeSystemPrompt(options) {
     const trimmedPrompt = options.prompt?.trimStart() ?? "";
     const telegramTurn = trimmedPrompt.startsWith(`${telegramHead}]`) ||
         trimmedPrompt.startsWith(`${telegramHead}|`);
-    const telegramSuffix = telegramTurn
+    return telegramTurn
         ? `${options.telegramTurnSystemPromptSuffix}\n- The current user message came from Telegram.`
         : "";
+}
+export function buildTelegramBridgeSystemPrompt(options) {
+    const basePrompt = options.systemPrompt ?? "";
+    const telegramSuffix = buildTelegramTurnSuffix(options);
     return {
         systemPrompt: Array.isArray(basePrompt)
             ? [...basePrompt, options.localSystemPromptSuffix + telegramSuffix]
@@ -148,15 +161,43 @@ function stripTelegramToolMetadataFromSystemPrompt(systemPrompt) {
         ? systemPrompt.map(stripTelegramToolMetadataFromString)
         : stripTelegramToolMetadataFromString(systemPrompt);
 }
+const TELEGRAM_TOOL_NAMES = ["telegram_attach", "telegram_message"];
+// Sections cannot modify an opaque prompt owned by an earlier handler.
+// Preserve append/strip compatibility there instead of silently losing guidance.
+function applyTelegramPromptSections(event, available) {
+    const options = event.systemPromptOptions;
+    const sections = options?.sections;
+    if (typeof sections !== "object" || sections === null || options?.forceSystemPrompt !== undefined)
+        return false;
+    if (available) {
+        sections.telegram = LOCAL_SYSTEM_PROMPT_SUFFIX.trim();
+        return true;
+    }
+    delete sections.telegram;
+    for (const name of TELEGRAM_TOOL_NAMES) {
+        if (options?.toolSnippets)
+            delete options.toolSnippets[name];
+        if (options?.toolGuidelines)
+            delete options.toolGuidelines[name];
+    }
+    return true;
+}
 export function createTelegramProactiveBeforeAgentStartHook(deps) {
     const baseHook = deps.baseHook ?? createTelegramBeforeAgentStartHook();
     return async (event, ctx) => {
         deps.reconcileAvailability?.();
-        if (!deps.isAvailable(ctx)) {
-            return {
-                systemPrompt: stripTelegramToolMetadataFromSystemPrompt(event.systemPrompt),
-            };
+        const available = deps.isAvailable(ctx);
+        // A caller-supplied baseHook owns its own prompt text, so it stays on the forced-prompt path.
+        if (!deps.baseHook && applyTelegramPromptSections(event, available)) {
+            const turnSuffix = available ? buildTelegramTurnSuffix({
+                prompt: event.messageType === "custom" ? undefined : event.prompt,
+                telegramTurnSystemPromptSuffix: TELEGRAM_TURN_SYSTEM_PROMPT_SUFFIX,
+            }).trim() : "";
+            return turnSuffix ? { message: { customType: "telegram-turn", content: turnSuffix, display: false } } : undefined;
+        }
+        if (!available) {
+            return overrideSystemPromptIfChanged(event.systemPrompt, stripTelegramToolMetadataFromSystemPrompt(event.systemPrompt));
         }
-        return baseHook(event);
+        return overrideSystemPromptIfChanged(event.systemPrompt, baseHook(event).systemPrompt);
     };
 }

package/node_modules/@llblab/pi-telegram/dist/lib/routing.js

@@ -1052,6 +1052,8 @@ export function createTelegramInboundRouteRuntime(deps) {
     /** A frozen destination pauses All-command expiry until routing finishes or releases it. */
     const isPendingRerouteDestinationHeld = (pending) => pending.phase.kind !== "waiting" && pending.phase.kind !== "released";
     const pendingUnboundReroutes = new Map();
+    // Body-free, bounded warm deduplication: album members can expire through the same chooser.
+    const expiredRoutingViews = new Set();
     const implicitThreadCreations = new Map();
     const guidedUnboundTopicKeys = new Set();
     let nextUnboundRerouteId = 0;
@@ -1409,6 +1411,20 @@ export function createTelegramInboundRouteRuntime(deps) {
                         return result;
                     }
                     catch (error) {
+                        const missingTarget = TelegramApi.getTelegramApiErrorRequestTarget(error);
+                        if (method === "deleteForumTopic" && missingTarget && error instanceof Error &&
+                            TelegramApi.isTelegramApiRequestRejected(error, method) &&
+                            TelegramApi.isTelegramStaleTargetHttpError(error) &&
+                            ThreadReconciler.isTelegramTopicDeletedErrorMessage(error.message) &&
+                            missingTarget?.chatId === temporaryCleanup.target?.chatId &&
+                            missingTarget?.threadId === temporaryCleanup.target?.threadId &&
+                            missingTarget?.chatId === body.chat_id && missingTarget?.threadId === body.message_thread_id) {
+                            // Only the client's parsed exact-target HTTP 400 absence closes the one-shot grant.
+                            // Closed/denied/foreign/forged responses remain uncertain and never license another request.
+                            assertExecutionCurrent?.();
+                            temporaryDeleteConfirmed = true;
+                            return true;
+                        }
                         temporaryTransportUncertain = true;
                         throw error;
                     }
@@ -5524,7 +5540,8 @@ export function createTelegramInboundRouteRuntime(deps) {
         return formatTelegramRoutingInputPreview(message);
     };
     const expireRoutingInput = async (source, ctx, signal) => {
-        const operator = deps.configStore.getAllowedUserId(), epoch = deps.getCurrentLeaderEpoch?.();
+        const operator = deps.configStore.getAllowedUserId(), epoch = deps.getCurrentLeaderEpoch?.(), generation = deps.getSessionGeneration?.(), instanceId = deps.getCurrentInstanceId?.(), scope = deps.getAdmissionScope?.();
+        const sendTextReply = deps.sendTextReply, editInteractiveMessage = deps.editInteractiveMessage;
         const message = source.original.update.message;
         const runtimeCurrent = () => !signal.aborted &&
             operator !== undefined &&
@@ -5532,6 +5549,9 @@ export function createTelegramInboundRouteRuntime(deps) {
             deps.isContextActive?.(ctx) === true &&
             deps.configStore.getAllowedUserId() === operator &&
             deps.getCurrentLeaderEpoch?.() === epoch &&
+            deps.getSessionGeneration?.() === generation &&
+            deps.getCurrentInstanceId?.() === instanceId &&
+            deps.getAdmissionScope?.() === scope &&
             deps.getAdmissionJournalBinding?.() === source.journalBindingKey &&
             source.original.routingInput?.operatorUserId === operator &&
             message?.from?.id === operator &&
@@ -5559,27 +5579,73 @@ export function createTelegramInboundRouteRuntime(deps) {
                 return;
             // Expiry revokes the donor carrier; old controls and late ACKs cannot issue another delivery. No body is archived.
             let movedIntoTab = false;
+            let unissued = source.original.routingInput?.phase === "waiting" &&
+                (!temporary || temporary.forwardProtocol === "one-shot-v1") &&
+                ![...(temporary?.forwardedInputs ?? []), ...(temporary?.completedInputs ?? [])].some(input => input.journalBindingKey === source.journalBindingKey && input.updateIds.includes(source.original.updateId));
+            const views = new Map();
+            const chooser = source.original.routingInput?.chooser;
+            if (chooser)
+                views.set(`${chooser.chatId}:${chooser.messageId}`, { ...chooser });
             for (const [id, pending] of pendingUnboundReroutes) {
                 if (!Updates.collectTelegramAdmissionSourceUpdateIds(pending.messages).includes(source.original.updateId))
                     continue;
                 movedIntoTab ||= pending.allTabCopiesForwarded !== undefined;
+                unissued &&= isPendingRerouteUntouched(pending) || pending.phase.kind === "released";
+                if (pending.chooserMessageId !== undefined)
+                    views.set(`${pending.sourceTarget.chatId}:${pending.chooserMessageId}`, {
+                        ...pending.sourceTarget, messageId: pending.chooserMessageId,
+                    });
                 removePendingReroute(id);
-                if (signal.aborted ||
-                    deps.isContextActive?.(ctx) !== true ||
-                    deps.configStore.getAllowedUserId() !== operator ||
-                    deps.getCurrentLeaderEpoch?.() !== epoch ||
-                    deps.getAdmissionJournalBinding?.() !== source.journalBindingKey)
-                    continue;
-                if (deps.editInteractiveMessage &&
-                    pending.chooserMessageId !== undefined) {
+            }
+            const notice = unissued
+                ? "<b>⌛ Routing expired; input was not delivered.</b>"
+                : "<b>⌛ Routing expired; delivery is unconfirmed.</b>\nPreviously accepted work may continue.";
+            const noticeKey = `${source.journalBindingKey}:${source.original.routingInput?.expiresAtMs}:${chooser ? `${chooser.chatId}:${chooser.messageId}` : source.original.updateId}`;
+            if (runtimeCurrent() && !expiredRoutingViews.has(noticeKey)) {
+                if (expiredRoutingViews.size >= 100)
+                    expiredRoutingViews.delete(expiredRoutingViews.values().next().value);
+                expiredRoutingViews.add(noticeKey);
+                let visible = false;
+                const assertNoticeAuthority = () => {
+                    if (!runtimeCurrent())
+                        throw new Error("Routing expiry notice authority changed.");
+                };
+                for (const view of views.values()) {
+                    if (!runtimeCurrent() || !editInteractiveMessage || deps.editInteractiveMessage !== editInteractiveMessage)
+                        break;
+                    if (view.chatId !== message.chat.id || !Number.isSafeInteger(view.threadId) || view.threadId <= 0)
+                        continue;
                     try {
-                        await deps.editInteractiveMessage(pending.sourceTarget.chatId, pending.chooserMessageId, "<b>⌛ Routing choice expired.</b>", "html", { inline_keyboard: [] });
+                        await editInteractiveMessage(view.chatId, view.messageId, notice, "html", { inline_keyboard: [] }, {
+                            target: { chatId: view.chatId, threadId: view.threadId }, assertAuthority: assertNoticeAuthority,
+                        });
+                        visible = true;
                     }
                     catch (error) {
-                        deps.recordRuntimeEvent?.("routing", error, {
-                            phase: "routing-input-expiry-view",
-                        });
+                        deps.recordRuntimeEvent?.("routing", error, { phase: "routing-input-expiry-view" });
+                    }
+                }
+                // A temporary tab is about to disappear; a cold/missing chooser also needs an independent owned destination.
+                const leader = instanceId ? deps.threadStore?.getActiveByInstanceId(instanceId) : undefined;
+                if ((!visible || temporary?.target) && runtimeCurrent() && leader &&
+                    leader.target.chatId === message.chat.id && Number.isSafeInteger(leader.target.threadId) && leader.target.threadId > 0) {
+                    const target = { chatId: leader.target.chatId, threadId: leader.target.threadId };
+                    try {
+                        const assertFallback = () => {
+                            assertNoticeAuthority();
+                            const active = deps.threadStore?.getActiveByInstanceId(instanceId);
+                            if (deps.sendTextReply !== sendTextReply || active?.target.chatId !== target.chatId || active.target.threadId !== target.threadId)
+                                throw new Error("Routing expiry notice destination changed.");
+                        };
+                        assertFallback();
+                        await sendTextReply(target.chatId, 0, notice, { parseMode: "HTML", target, assertAuthority: assertFallback });
                     }
+                    catch (error) {
+                        deps.recordRuntimeEvent?.("routing", error, { phase: "routing-input-expiry-notice" });
+                    }
+                }
+                else if (!visible && runtimeCurrent()) {
+                    deps.recordRuntimeEvent?.("routing", "Routing expiry notice has no current owned Thread.", { phase: "routing-input-expiry-notice-unavailable" });
                 }
             }
             // The scheduled stage captures only context/epoch and a tab token. It reconstructs disposition from body-free proof,
@@ -5780,7 +5846,8 @@ export function createTelegramInboundRouteRuntime(deps) {
                         if (!recordRecoveredRerouteSource(pending, source.original.updateId, source.result))
                             continue;
                         try {
-                            await retireCancellationChooser(id, pending, isCurrent);
+                            if (await retireCancellationChooser(id, pending, isCurrent))
+                                await deleteCancelledOrphanTab(pending, pending.abandonment, isCurrent);
                         }
                         catch (error) {
                             deps.recordRuntimeEvent?.("routing", error, {
@@ -5809,6 +5876,43 @@ export function createTelegramInboundRouteRuntime(deps) {
         }
         return true;
     };
+    /**
+     * A cancelled input in an unbound (non-temporary) tab leaves nothing to route: once no chooser, queue, live owner,
+     * Workspace/Restore record or retained journal arrival still names the tab, it is deleted like a routing tab. Any
+     * missing proof or failure keeps the tab; this never retries and never blocks the Cancel outcome.
+     */
+    const deleteCancelledOrphanTab = async (pending, cancellation, isAuthorityCurrent) => {
+        const { chatId, threadId } = pending.sourceTarget;
+        if (threadId === undefined ||
+            pending.temporaryThread ||
+            isTemporaryTabTarget({ chatId, threadId }) ||
+            hasPendingRerouteForTarget({ chatId, threadId }) ||
+            !deps.inspectTemporaryThreadSources)
+            return;
+        const target = { chatId, threadId };
+        try {
+            const own = {
+                journalBindingKey: cancellation.journalBindingKey,
+                updateIds: Updates.collectTelegramAdmissionSourceUpdateIds(pending.messages),
+            };
+            const assertCurrent = () => {
+                if (!isAuthorityCurrent())
+                    throw new Error("Unbound tab cleanup authority changed.");
+            };
+            assertCurrent();
+            if (deps.inspectTemporaryThreadSources(target, [cancellation.journalBindingKey], [own])?.length !== 0)
+                return;
+            assertCurrent();
+            await closeReroutedUnboundTopic(target, pending.chooserMessageId, assertCurrent);
+        }
+        catch (error) {
+            deps.recordRuntimeEvent?.("routing", error, {
+                phase: "unbound-cancel-tab-cleanup",
+                chatId: target.chatId,
+                threadId: target.threadId,
+            });
+        }
+    };
     const handleUnboundRerouteCancelCallback = async (query, ctx) => {
         if (!query.data?.startsWith(TELEGRAM_UNBOUND_REROUTE_CANCEL_CALLBACK_PREFIX))
             return false;
@@ -5890,6 +5994,7 @@ export function createTelegramInboundRouteRuntime(deps) {
                 await Promise.all([
                     deps.answerCallbackQuery(query.id, "Routing cancelled"),
                     deleteAllTabCopies(pending),
+                    deleteCancelledOrphanTab(pending, cancellation, isAuthorityCurrent),
                 ]);
         }
         catch (error) {

package/node_modules/@llblab/pi-telegram/dist/lib/telegram-api.d.ts

@@ -505,6 +505,17 @@ export declare class TelegramApiStaleTargetError extends Error {
         threadId: number;
     });
 }
+/** The leader's exact refusal of a follower API call outside that follower's own Thread; carries only the requested target. */
+export declare class TelegramApiFollowerNotAllowedError extends Error {
+    readonly requestTarget: {
+        chatId: number;
+        threadId: number;
+    } | undefined;
+    constructor(message: string, requestTarget?: {
+        chatId: number;
+        threadId: number;
+    });
+}
 export declare function getTelegramApiErrorRequestTarget(error: unknown): {
     chatId: number;
     threadId: number;

package/node_modules/@llblab/pi-telegram/dist/lib/telegram-api.js

@@ -338,6 +338,15 @@ export class TelegramApiStaleTargetError extends Error {
         this.requestTarget = { ...requestTarget };
     }
 }
+/** The leader's exact refusal of a follower API call outside that follower's own Thread; carries only the requested target. */
+export class TelegramApiFollowerNotAllowedError extends Error {
+    requestTarget;
+    constructor(message, requestTarget) {
+        super(message);
+        this.name = "TelegramApiFollowerNotAllowedError";
+        this.requestTarget = requestTarget ? { ...requestTarget } : undefined;
+    }
+}
 export function getTelegramApiErrorRequestTarget(error) {
     const target = error instanceof TelegramApiHttpError ||
         error instanceof TelegramApiStaleTargetError

package/node_modules/@llblab/pi-telegram/dist/lib/thread-cleanup-manager.d.ts

@@ -3,7 +3,11 @@
  * Zones: telegram threads, workspace lifecycle
  * Owns fail-closed cleanup eligibility projection without persistence or Bot API effects
  */
-import type { TelegramWorkspaceDeletionPermit, TelegramWorkspaceDestructiveFence, TelegramWorkspaceRetirementFence } from "./workspace-admission.ts";
+import type { TelegramWorkspaceDeletionPermit, TelegramWorkspaceDestructiveFence, TelegramWorkspaceRetirementFence, TelegramWorkspaceAdmissionLedger, TelegramWorkspaceAdmissionOwner } from "./workspace-admission.ts";
+import type { TelegramTopicTargetStore, TelegramWorkspaceThreadBinding } from "./threads.ts";
+import type { TelegramWorkspaceOperationRunner } from "./workspace-retirement.ts";
+import type { TelegramWorkspaceThreadDeletionTransport } from "./telegram-api.ts";
+import type { TelegramProcessLiveness } from "./process-identity.ts";
 export interface TelegramThreadCleanupBindingSnapshot {
     cwd: string;
     workspaceKey: string;
@@ -38,7 +42,8 @@ export interface TelegramThreadCleanupCandidate {
     sessionId?: string;
     sessionKey?: string;
     instanceSlot: string;
-    slot: string;
+    /** Null is explicit absence in reviewed work; it never denotes a reusable letter. */
+    slot: string | null;
     target: {
         chatId: number;
         threadId: number;
@@ -155,6 +160,8 @@ export declare function createTelegramThreadCleanupWorkStore(options: {
     runtimeDir?: string;
     profileName: string;
     tokenSha256: string;
+    /** Exact captured ledger identity; standalone fixtures may use the plain profile identity. */
+    admissionProfileKey?: string;
     maxWorkSets?: number;
     maxBytes?: number;
     getNowMs?: () => number;
@@ -185,6 +192,7 @@ export declare function executeTelegramInactiveThreadCleanup(input: {
 }>;
 export declare function createTelegramThreadCleanupPermitRuntime(deps: {
     ledger: {
+        getProfileKey(): string;
         read(): {
             fence?: TelegramWorkspaceDestructiveFence;
         };
@@ -192,7 +200,7 @@ export declare function createTelegramThreadCleanupPermitRuntime(deps: {
             operationId: string;
             cleanupWorkSetId: string;
             bindingKey: string;
-            slot: string;
+            slot: string | null;
             target: {
                 chatId: number;
                 threadId: number;
@@ -256,6 +264,34 @@ export interface TelegramInactiveThreadCleanupCoordinatorDeps<TBinding> {
     deleteWithPermit(permit: TelegramThreadCleanupDeletionPermit, candidate: TelegramThreadCleanupCandidate): Promise<void>;
     commitBinding(candidate: TelegramThreadCleanupCandidate, currentBinding?: TBinding): Promise<boolean>;
 }
+export interface TelegramInactiveThreadCleanupAuthority {
+    profileName: string;
+    leaderEpoch: number | string;
+    ledger: TelegramWorkspaceAdmissionLedger;
+    isCurrent(): boolean;
+}
+/** Review owns ordinary admission; confirmed cleanup uses the shared gate and its exclusive manual fence instead. */
+export declare function createTelegramInactiveThreadCleanupRuntime(deps: {
+    store: Pick<TelegramTopicTargetStore, "load" | "listWorkspaceBindings" | "listReservations" | "listPendingProvisions" | "listPendingCleanups" | "commitInactiveWorkspaceCleanup">;
+    captureAuthority(): TelegramInactiveThreadCleanupAuthority | undefined;
+    getWorkStore(authority: TelegramInactiveThreadCleanupAuthority): TelegramThreadCleanupWorkStore;
+    getProtection(binding: TelegramWorkspaceThreadBinding): {
+        liveOwner: TelegramThreadCleanupProtectionState;
+        acceptedWork: TelegramThreadCleanupProtectionState;
+        deliveryAuthority: TelegramThreadCleanupProtectionState;
+    };
+    getProcessLiveness(owner: TelegramWorkspaceAdmissionOwner): TelegramProcessLiveness;
+    runExclusive<T>(operation: () => Promise<T>): Promise<T>;
+    runWorkspaceOperation: TelegramWorkspaceOperationRunner;
+    deleteThread: TelegramWorkspaceThreadDeletionTransport;
+    onError?: (error: unknown) => void;
+}): {
+    review(): Promise<{
+        count: number;
+        operationId?: string;
+    }>;
+    clean(operationId: string): Promise<TelegramInactiveThreadCleanupResult>;
+};
 export declare function createTelegramInactiveThreadCleanupSettingsPort<TBinding>(deps: TelegramInactiveThreadCleanupCoordinatorDeps<TBinding>): (operationId: string) => Promise<TelegramInactiveThreadCleanupResult>;
 export interface TelegramInactiveThreadCleanupResult {
     deleted: number;