@llblab/pi-telegram 0.50.1 → 0.51.1

package/dist/lib/queue.js

@@ -168,6 +168,18 @@ export function createTelegramActiveTurnStore() {
         clear: () => {
             activeTurn = undefined;
         },
+        markNextAbortAnnouncement: () => {
+            if (!activeTurn)
+                return false;
+            activeTurn.announceNextAbortOnEnd = true;
+            return true;
+        },
+        clearNextAbortAnnouncement: () => {
+            if (!activeTurn?.announceNextAbortOnEnd)
+                return false;
+            delete activeTurn.announceNextAbortOnEnd;
+            return true;
+        },
         getChatId: () => activeTurn?.chatId,
         getTarget: () => activeTurn?.target ? { ...activeTurn.target } : undefined,
         getReplyToMessageId: () => activeTurn?.replyToMessageId,
@@ -815,6 +827,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "no-turn",
             shouldClearPreview: false,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: false,
         };
@@ -824,6 +837,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "aborted",
             shouldClearPreview: true,
             shouldDispatchNext,
+            shouldSendAbortMessage: options.announceNextAbortOnEnd === true,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: false,
         };
@@ -833,6 +847,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "error",
             shouldClearPreview: true,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: true,
             shouldSendAttachmentNotice: false,
         };
@@ -842,6 +857,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "text",
             shouldClearPreview: false,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: false,
         };
@@ -851,6 +867,7 @@ export function buildTelegramAgentEndPlan(options) {
             kind: "attachments-only",
             shouldClearPreview: true,
             shouldDispatchNext,
+            shouldSendAbortMessage: false,
             shouldSendErrorMessage: false,
             shouldSendAttachmentNotice: true,
         };
@@ -859,6 +876,7 @@ export function buildTelegramAgentEndPlan(options) {
         kind: "empty",
         shouldClearPreview: true,
         shouldDispatchNext,
+        shouldSendAbortMessage: false,
         shouldSendErrorMessage: false,
         shouldSendAttachmentNotice: false,
     };
@@ -869,8 +887,7 @@ export function createTelegramAgentEndHook(deps) {
             return;
         const turn = deps.getActiveTurn();
         const extractedAssistant = assistantOverride ?? (turn ? deps.extractAssistant(event.messages) : {});
-        const assistant = extractedAssistant.recoveredFromEarlier &&
-            deps.isRecoveredAssistantAlreadyPublished?.(extractedAssistant)
+        const assistant = deps.isAssistantAlreadyPublished?.(extractedAssistant)
             ? { stopReason: extractedAssistant.stopReason }
             : extractedAssistant;
         const hasPublication = !!assistant.text || assistant.stopReason === "error" || !!turn?.queuedAttachments.length;
@@ -992,6 +1009,7 @@ export async function handleTelegramAgentEndRuntime(deps) {
         hasFinalText: !!finalText || hasOutboundArtifacts,
         hasQueuedAttachments: (turn?.queuedAttachments.length ?? 0) > 0,
         foldQueuedPromptsIntoHistory: deps.foldQueuedPromptsIntoHistory,
+        announceNextAbortOnEnd: turn?.announceNextAbortOnEnd === true,
     });
     if (!turn) {
         if (endPlan.shouldDispatchNext)
@@ -1117,17 +1135,26 @@ export async function handleTelegramAgentEndRuntime(deps) {
             if (!isDeliveryActive())
                 return;
         }
-        if (endPlan.shouldSendErrorMessage) {
+        if (endPlan.shouldSendAbortMessage || endPlan.shouldSendErrorMessage) {
             const errorMessage = assistant.errorMessage ||
                 "Telegram bridge: Pi failed while processing the request.";
-            const isOperationAborted = errorMessage.trim().replace(/\.$/, "") ===
-                "This operation was aborted";
-            await deps.sendTextReply(turn.chatId, turn.replyToMessageId, isOperationAborted
-                ? "<b>⏹️ This operation was aborted.</b>"
-                : errorMessage, {
-                target: turn.target,
-                ...(isOperationAborted ? { parseMode: "HTML" } : {}),
-            });
+            const isOperationAborted = endPlan.shouldSendAbortMessage ||
+                errorMessage.trim().replace(/\.$/, "") === "This operation was aborted";
+            try {
+                await deps.sendTextReply(turn.chatId, turn.replyToMessageId, isOperationAborted
+                    ? "<b>⏹️ This operation was aborted.</b>"
+                    : errorMessage, {
+                    target: turn.target,
+                    ...(isOperationAborted ? { parseMode: "HTML" } : {}),
+                });
+            }
+            catch (error) {
+                if (!isOperationAborted)
+                    throw error;
+                deps.recordRuntimeEvent?.("dispatch", error, {
+                    phase: "next-abort-announcement",
+                });
+            }
             if (!isDeliveryActive())
                 return;
             if (endPlan.shouldDispatchNext)
@@ -1268,7 +1295,7 @@ export async function handleTelegramAgentEndRuntime(deps) {
             deps.dispatchNextQueuedTelegramTurn();
     };
     if (deps.scheduleActiveTurnDelivery &&
-        (endPlan.kind === "text" || endPlan.kind === "attachments-only" || endPlan.shouldSendErrorMessage || endPlan.shouldClearPreview)) {
+        (endPlan.kind === "text" || endPlan.kind === "attachments-only" || endPlan.shouldSendAbortMessage || endPlan.shouldSendErrorMessage || endPlan.shouldClearPreview)) {
         deps.scheduleActiveTurnDelivery(deliverActiveTurn);
         return;
     }
@@ -1766,6 +1793,7 @@ export function createTelegramQueueDispatchRuntime(deps) {
         commitPromptDispatch: deps.commitPromptDispatch,
         sendUserMessage: deps.sendUserMessage,
         onPromptDispatchFailure: deps.onPromptDispatchFailure,
+        reconcileNextDispatchAnnouncementReplyOwnership: deps.reconcileNextDispatchAnnouncementReplyOwnership,
         isQueueItemTransportActive: deps.isQueueItemTransportActive,
         hasPendingInboundQueueMutationForItem: deps.hasPendingInboundQueueMutationForItem,
         isQueueItemAdmissionReady: deps.isQueueItemAdmissionReady,
@@ -1777,12 +1805,19 @@ export function createTelegramQueueDispatchRuntime(deps) {
 export function createTelegramQueueDispatchController(deps) {
     let controlDispatchPending = false;
     let nextDispatchAnnouncementRequested = false;
+    let nextDispatchAnnouncementGeneration = 0;
     let nextDispatchAnnouncementAnchor;
     const controller = {
         requestNextDispatchAnnouncement: () => {
+            nextDispatchAnnouncementGeneration += 1;
             nextDispatchAnnouncementRequested = true;
             nextDispatchAnnouncementAnchor = undefined;
         },
+        cancelNextDispatchAnnouncement: () => {
+            nextDispatchAnnouncementGeneration += 1;
+            nextDispatchAnnouncementRequested = false;
+            nextDispatchAnnouncementAnchor = undefined;
+        },
         dispatchNext: (ctx) => {
             if (deps.hasDispatchContext && !deps.hasDispatchContext())
                 return;
@@ -1973,11 +2008,22 @@ export function createTelegramQueueDispatchController(deps) {
             if (dispatchPlan.kind === "prompt" && nextDispatchAnnouncementRequested) {
                 nextDispatchAnnouncementRequested = false;
                 controlDispatchPending = true;
+                const announcementGeneration = nextDispatchAnnouncementGeneration;
                 const dispatchGeneration = deps.getDispatchGeneration?.();
                 deps.updateStatus(ctx);
                 void deps.sendTextReply(dispatchPlan.item.chatId, dispatchPlan.item.replyToMessageId, "<b>⏩ Dispatching next queued turn.</b>", { target: dispatchPlan.item.target }).catch((error) => {
-                    deps.recordRuntimeEvent?.("dispatch", error, { phase: "next-announcement" });
+                    deps.recordRuntimeEvent?.("dispatch", error, {
+                        phase: "next-announcement",
+                    });
                 }).finally(() => {
+                    try {
+                        deps.reconcileNextDispatchAnnouncementReplyOwnership?.(dispatchPlan.item);
+                    }
+                    catch (error) {
+                        deps.recordRuntimeEvent?.("dispatch", error, {
+                            phase: "next-announcement-reply-ownership",
+                        });
+                    }
                     controlDispatchPending = false;
                     if (deps.hasDispatchContext && !deps.hasDispatchContext())
                         return;
@@ -1985,6 +2031,11 @@ export function createTelegramQueueDispatchController(deps) {
                         deps.isDispatchGenerationActive &&
                         !deps.isDispatchGenerationActive(dispatchGeneration))
                         return;
+                    if (announcementGeneration !== nextDispatchAnnouncementGeneration) {
+                        if (nextDispatchAnnouncementRequested)
+                            controller.dispatchNext(ctx);
+                        return;
+                    }
                     executePlan();
                 });
                 return;

package/dist/lib/replies.d.ts

@@ -23,6 +23,10 @@ export interface ReplyDedupRuntime {
 }
 export declare function createReplyDedupRuntime(): ReplyDedupRuntime;
 export declare function resetTransportReplyDedup(): void;
+/** Keeps a successfully published transition notice as the first reply of the
+ * next agent turn. The following agent-start reset consumes this one-shot
+ * preservation, so later messages in that turn do not repeat the reply header. */
+export declare function preserveTransportReplyDedupOnNextReset(chatId: number, messageId: number, target?: TelegramTarget): void;
 export declare function buildTelegramReplyParameters(chatId: number, messageId: number | undefined, target?: TelegramTarget): TelegramReplyParameters | undefined;
 export declare function withTelegramReplyParameters<T>(chatId: number, messageId: number | undefined, target: TelegramTarget | undefined, send: (parameters: TelegramReplyParameters | undefined) => Promise<T>): Promise<T>;
 export declare function isAssistantAgentMessage(message: unknown): boolean;

package/dist/lib/replies.js

@@ -31,6 +31,7 @@ export function createReplyDedupRuntime() {
 }
 // --- Transport-level dedup ---
 const lastRepliedToMessageIdByTarget = new Map();
+const replyDedupPreservedOnNextReset = new Map();
 let replyDedupGeneration = 0;
 function getReplyDedupTargetKey(chatId, target) {
     const threadId = target?.threadId;
@@ -41,6 +42,19 @@ function getReplyDedupTargetKey(chatId, target) {
 export function resetTransportReplyDedup() {
     replyDedupGeneration += 1;
     lastRepliedToMessageIdByTarget.clear();
+    for (const [key, messageId] of replyDedupPreservedOnNextReset) {
+        lastRepliedToMessageIdByTarget.set(key, messageId);
+    }
+    replyDedupPreservedOnNextReset.clear();
+}
+/** Keeps a successfully published transition notice as the first reply of the
+ * next agent turn. The following agent-start reset consumes this one-shot
+ * preservation, so later messages in that turn do not repeat the reply header. */
+export function preserveTransportReplyDedupOnNextReset(chatId, messageId, target) {
+    const key = getReplyDedupTargetKey(chatId, target);
+    if (lastRepliedToMessageIdByTarget.get(key) !== messageId)
+        return;
+    replyDedupPreservedOnNextReset.set(key, messageId);
 }
 export function buildTelegramReplyParameters(chatId, messageId, target) {
     if (messageId === undefined || messageId <= 0)

package/dist/lib/routing.d.ts

@@ -122,6 +122,7 @@ export interface TelegramInboundRouteRuntimeDeps<TMessage extends TelegramRouted
     isContextActive?: (ctx: TContext) => boolean;
     dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
     requestNextDispatchAnnouncement?: () => void;
+    cancelNextDispatchAnnouncement?: () => void;
     requestDeferredDispatchNextQueuedTelegramTurn?: (dispatch: (ctx: TContext) => void) => void;
     hasDeferredDispatchContext?: () => boolean;
     startTypingLoop?: (ctx: TContext, chatId?: number, options?: {

package/dist/lib/routing.js

@@ -1418,6 +1418,10 @@ export function createTelegramInboundRouteRuntime(deps) {
         isContextActive: deps.isContextActive,
         dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
         requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+        cancelNextTransitionAnnouncements: () => {
+            deps.activeTurnRuntime.clearNextAbortAnnouncement();
+            deps.cancelNextDispatchAnnouncement?.();
+        },
         requestDeferredDispatchNextQueuedTelegramTurn: deps.requestDeferredDispatchNextQueuedTelegramTurn,
         startTypingLoop: deps.startTypingLoop,
         stopTypingLoop: deps.stopTypingLoop,
@@ -1476,6 +1480,7 @@ export function createTelegramInboundRouteRuntime(deps) {
         },
         getPromptTemplateCommands,
         sendTextReply: deps.sendTextReply,
+        markActiveTurnNextAbortAnnouncement: deps.activeTurnRuntime.markNextAbortAnnouncement,
         getActiveTurnReply: () => {
             const activeTurn = deps.activeTurnRuntime.get();
             if (!activeTurn)

package/dist/lib/sync.d.ts

@@ -97,6 +97,15 @@ export interface TelegramManualThreadDisconnectDeps<TSyncState> {
 export declare function markTelegramConfigSyncChange<TSyncState extends TelegramSyncState>(state: TSyncState, action: string, options?: {
     nowMs?: number;
 }): TSyncState;
+export declare function createTelegramPreservedLeaderQuitHandler(deps: {
+    instanceId: string;
+    topicTargetStore: Pick<TelegramTopicTargetStore, "load" | "list" | "listPendingCleanups" | "detachTargetOwner">;
+    getCurrentLeaderEpoch: () => number | string | undefined;
+    getProfileName: () => string | undefined;
+    isPollingSuspended: () => boolean;
+    resolveAutomaticThreadCleanupEnabled: () => boolean | Promise<boolean>;
+    runWorkspaceOperation: TelegramSyncWorkspaceOperationRunner;
+}): (isSessionCurrent: () => boolean) => (() => Promise<void>) | undefined;
 export interface TelegramSessionRestartThreadCleanupDeps<TSyncState extends TelegramSyncState> extends Omit<TelegramManualThreadDisconnectDeps<TSyncState>, "stopPolling"> {
     suspendPolling: () => Promise<void>;
 }

package/dist/lib/sync.js

@@ -6,6 +6,7 @@
 import { getTelegramApiErrorRequestTarget, isTelegramStaleTargetHttpError } from "./telegram-api.js";
 import { getTelegramTargetKey } from "./target.js";
 import * as ThreadReconciler from "./thread-reconciler.js";
+import { TelegramWorkspaceSlotUnavailableError } from "./workspace-slots.js";
 import { createTelegramWorkspaceAdmissionOperationId, runWithTelegramWorkspaceAdmissionsAsync, } from "./workspace-admission.js";
 import { createTelegramCleanupTargetProtection, commitTelegramWorkspaceProvisionBinding, getTelegramTargetFromApiBody, getTelegramThreadOwnerKey, isSameTelegramProcessInstance, isTelegramTopicTargetStaleError, normalizeTelegramWorkspacePath, provisionOwnBusTopic, } from "./threads.js";
 export function markTelegramConfigSyncChange(state, action, options) {
@@ -24,6 +25,42 @@ export function markTelegramConfigSyncChange(state, action, options) {
     });
     return nextState;
 }
+export function createTelegramPreservedLeaderQuitHandler(deps) {
+    return (isSessionCurrent) => {
+        const epoch = deps.getCurrentLeaderEpoch();
+        const profile = deps.getProfileName();
+        if (epoch === undefined || !isSessionCurrent())
+            return undefined;
+        const isCurrent = () => isSessionCurrent() && deps.getCurrentLeaderEpoch() === epoch &&
+            deps.getProfileName() === profile && deps.isPollingSuspended();
+        return async () => {
+            if (!isCurrent() || await deps.resolveAutomaticThreadCleanupEnabled() !== false)
+                return;
+            if (!isCurrent())
+                return;
+            await deps.runWorkspaceOperation({
+                operationId: createTelegramWorkspaceAdmissionOperationId(),
+                operationKind: "workspace.preserve-leader-quit",
+                scopes: [{ kind: "profile" }],
+            }, async () => {
+                if (!isCurrent())
+                    return;
+                await deps.topicTargetStore.load();
+                if (!isCurrent())
+                    return;
+                const records = deps.topicTargetStore.list().filter((record) => record.instanceId === deps.instanceId && (record.status === "active" || record.status === "starting"));
+                if (records.length !== 1)
+                    return;
+                const record = records[0];
+                if (deps.topicTargetStore.listPendingCleanups().some((intent) => intent.target.chatId === record.target.chatId && intent.target.threadId === record.target.threadId))
+                    return;
+                if (!await deps.topicTargetStore.detachTargetOwner(record, isCurrent) && isCurrent()) {
+                    throw new Error("Telegram preserved leader detachment was not committed.");
+                }
+            });
+        };
+    };
+}
 export function createTelegramSessionRestartThreadCleanupHandler(deps) {
     return createTelegramManualThreadDisconnectHandler({
         ...deps,
@@ -353,10 +390,13 @@ export async function ensureTelegramLeaderThreadBinding(deps) {
     };
     const leaderProfileKey = getTelegramThreadOwnerKey(leaderOwner);
     const legacyLeaderRecord = deps.topicTargetStore.getByProfileKey(leaderProfileKey);
+    let capacityUnavailable = false;
     const workspaceIdentity = normalizedLeaderCwd
-        ? deps.topicTargetStore.claimWorkspaceIdentity(normalizedLeaderCwd, deps.instanceId, legacyLeaderRecord?.instanceId, { sessionId: deps.sessionId })
+        ? deps.topicTargetStore.claimWorkspaceIdentity(normalizedLeaderCwd, deps.instanceId, legacyLeaderRecord?.instanceId, { sessionId: deps.sessionId, onCapacityUnavailable() { capacityUnavailable = true; } })
         : undefined;
     if (deps.cwd && !workspaceIdentity) {
+        if (capacityUnavailable)
+            throw new TelegramWorkspaceSlotUnavailableError();
         throw new Error("Telegram Workspace identity is already claimed.");
     }
     const commitWorkspaceBinding = async (result) => {

package/dist/lib/telegram-api.d.ts

@@ -484,6 +484,8 @@ export declare function getTelegramApiErrorRequestTarget(error: unknown): {
     threadId: number;
 } | undefined;
 export declare function isTelegramStaleTargetHttpError(error: unknown): boolean;
+/** Only a parsed Telegram rejection of this method proves a request had no effect. */
+export declare function isTelegramApiRequestRejected(error: unknown, method: string): boolean;
 export declare function isTelegramMessageNotModifiedError(error: unknown): boolean;
 export declare function isTelegramApiMethodRetrySafe(method: string): boolean;
 export declare function isRetryableTelegramApiError(error: unknown): boolean;
@@ -522,13 +524,19 @@ export declare function createTelegramAssistantDraftSender(deps: {
     sendRichMessageDraft: TelegramBridgeApiRuntime["sendRichMessageDraft"];
 }): TelegramBridgeApiRuntime["sendMessageDraft"];
 export declare function buildTelegramAnswerGuestQueryBody(guestQueryId: string, text?: string, options?: TelegramAnswerGuestQueryOptions): Record<string, unknown>;
+export type TelegramWorkspaceThreadDeletionTransport = (authorize: () => {
+    chatId: number;
+    threadId: number;
+}) => Promise<void>;
 export declare function createDefaultTelegramBridgeApiRuntime(deps: {
     getBotToken: () => string | undefined;
     recordRuntimeEvent: TelegramBridgeApiRuntimeDeps["recordRuntimeEvent"];
     captureRequestErrorHandler?: TelegramBridgeApiRuntimeDeps["captureRequestErrorHandler"];
     targetActivity?: TelegramApiTargetActivityRuntime;
     workspaceAdmission?: TelegramApiWorkspaceAdmissionPort | (() => TelegramApiWorkspaceAdmissionPort | undefined);
-}): TelegramBridgeApiRuntime;
+}): TelegramBridgeApiRuntime & {
+    deleteWorkspaceThread: TelegramWorkspaceThreadDeletionTransport;
+};
 export declare function createTelegramBridgeApiRuntime(deps: TelegramBridgeApiRuntimeDeps): TelegramBridgeApiRuntime;
 /**
  * Creates a low-level Telegram Bot API client.

package/dist/lib/telegram-api.js

@@ -231,11 +231,13 @@ export function isTelegramApiCommitUnknownError(error) {
 class TelegramApiHttpError extends Error {
     status;
     retryAfterSeconds;
+    rejectedRequestMethod;
     requestTarget;
-    constructor(message, status, retryAfterSeconds) {
+    constructor(message, status, retryAfterSeconds, rejectedRequestMethod) {
         super(message);
         this.status = status;
         this.retryAfterSeconds = retryAfterSeconds;
+        this.rejectedRequestMethod = rejectedRequestMethod;
     }
 }
 function attachTelegramApiRequestTarget(error, body) {
@@ -267,6 +269,11 @@ export function isTelegramStaleTargetHttpError(error) {
         return false;
     return /^Telegram API \w+ failed: HTTP 400: Bad Request: (message thread not found|thread not found|topic not found|topic deleted|topic closed|thread closed|forum topic closed|message thread closed|topic_id_invalid|topic_closed)$/i.test(error.message);
 }
+/** Only a parsed Telegram rejection of this method proves a request had no effect. */
+export function isTelegramApiRequestRejected(error, method) {
+    return error instanceof TelegramApiHttpError && error.rejectedRequestMethod !== undefined &&
+        error.rejectedRequestMethod === method;
+}
 export function isTelegramMessageNotModifiedError(error) {
     return (error instanceof Error && error.message.includes("message is not modified"));
 }
@@ -398,7 +405,8 @@ async function parseTelegramApiResponse(response, method) {
         const retryAfterHeader = response.headers?.get("retry-after");
         const retryAfterSeconds = data?.parameters?.retry_after ??
             (retryAfterHeader ? Number.parseInt(retryAfterHeader, 10) : undefined);
-        throw new TelegramApiHttpError(`Telegram API ${method} failed: ${status}${description}`, response.status, Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : undefined);
+        throw new TelegramApiHttpError(`Telegram API ${method} failed: ${status}${description}`, response.status, Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : undefined, data?.ok === false && data.error_code === response.status &&
+            [400, 401, 403, 404, 429].includes(response.status) ? method : undefined);
     }
     if (!data) {
         throw new TelegramApiMalformedSuccessError(method, "returned invalid JSON");
@@ -856,7 +864,7 @@ export function createDefaultTelegramBridgeApiRuntime(deps) {
             },
         })
         : client;
-    return createTelegramBridgeApiRuntime({
+    const runtime = createTelegramBridgeApiRuntime({
         client: deps.targetActivity
             ? createTelegramApiTargetTrackingClient(admittedClient, deps.targetActivity)
             : admittedClient,
@@ -866,6 +874,18 @@ export function createDefaultTelegramBridgeApiRuntime(deps) {
         recordRuntimeEvent: deps.recordRuntimeEvent,
         captureRequestErrorHandler: deps.captureRequestErrorHandler,
     });
+    return {
+        ...runtime,
+        async deleteWorkspaceThread(authorize) {
+            // The exclusive deletion permit replaces ordinary target admission.
+            const target = authorize();
+            const deleted = await client.call("deleteForumTopic", {
+                chat_id: target.chatId, message_thread_id: target.threadId,
+            }, { maxAttempts: 1, retrySafety: "non-idempotent" });
+            if (deleted !== true)
+                throw new Error("Telegram Workspace Thread deletion was not confirmed.");
+        },
+    };
 }
 export function createTelegramBridgeApiRuntime(deps) {
     const recoverRequestError = async (handler, error) => {

package/dist/lib/thread-cleanup-manager.js

@@ -342,7 +342,9 @@ export function createTelegramThreadCleanupWorkStore(options) {
                 return { confirmed: true, entry: structuredClone(entry) };
             });
         },
-        list() { return structuredClone(read().workSets); },
+        list() {
+            return structuredClone(withTelegramFileTransaction(`${options.path}.transaction`, () => read().workSets));
+        },
     };
 }
 export async function commitTelegramInactiveThreadCleanup(input) {
@@ -401,7 +403,10 @@ export function createTelegramThreadCleanupPermitRuntime(deps) {
             if (!deps.canAdoptFence(fence))
                 return undefined;
             try {
-                fence = deps.ledger.adoptThreadCleanupFence(fence, { owner, leaderEpoch });
+                const adopted = deps.ledger.adoptThreadCleanupFence(fence, { owner, leaderEpoch });
+                if (adopted.destructiveKind !== "manual-thread-cleanup")
+                    return undefined;
+                fence = adopted;
             }
             catch {
                 return undefined;

package/dist/lib/threads.d.ts

@@ -212,6 +212,8 @@ export interface TelegramTopicTargetStore {
     refresh?: () => Promise<void>;
     persist: () => Promise<void>;
     invalidateTarget: (target: TelegramTarget, isCurrent: () => boolean, lastSyncError: string) => Promise<boolean>;
+    /** Caller proves owner detachment; this does not assert Telegram Thread absence. */
+    detachTargetOwner: (expected: TelegramTopicTargetRecord, isCurrent: () => boolean) => Promise<boolean>;
     list: () => TelegramTopicTargetRecord[];
     getFollowerRecoveryHintByTarget?: (target: TelegramTarget) => {
         slot?: string;