@llblab/pi-telegram 0.50.1 → 0.51.1

package/lib/queue.ts

@@ -126,6 +126,8 @@ export interface PendingTelegramTurn extends TelegramQueueItemBase {
   historyText: string;
   priorityEmoji?: string;
   reactionSuppressionEmoji?: string;
+  /** Emit the explicit aborted-turn notice when /next settles this active turn. */
+  announceNextAbortOnEnd?: boolean;
 
   /** Turn should preferably be delivered as voice (mirror mode + user sent voice) */
   voiceReplyPreferred?: boolean;
@@ -235,6 +237,8 @@ export interface TelegramActiveTurnStore<
   has: () => boolean;
   set: (turn: TTurn) => void;
   clear: () => void;
+  markNextAbortAnnouncement: () => boolean;
+  clearNextAbortAnnouncement: () => boolean;
   getChatId: () => number | undefined;
   getTarget: () => TelegramQueueTarget | undefined;
   getReplyToMessageId: () => number | undefined;
@@ -461,6 +465,16 @@ 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,
@@ -1488,6 +1502,7 @@ export interface TelegramAgentEndPlan {
   kind: "no-turn" | "aborted" | "error" | "text" | "attachments-only" | "empty";
   shouldClearPreview: boolean;
   shouldDispatchNext: boolean;
+  shouldSendAbortMessage: boolean;
   shouldSendErrorMessage: boolean;
   shouldSendAttachmentNotice: boolean;
 }
@@ -1615,7 +1630,7 @@ export interface TelegramAgentEndHookRuntimeDeps<
   extractAssistant: (
     messages: readonly TMessage[],
   ) => TelegramAgentEndAssistantResult;
-  isRecoveredAssistantAlreadyPublished?: (assistant: TelegramAgentEndAssistantResult) => boolean;
+  isAssistantAlreadyPublished?: (assistant: TelegramAgentEndAssistantResult) => boolean;
   getFoldQueuedPromptsIntoHistory: () => boolean;
   resetRuntimeState: () => void;
   isSessionActive?: (ctx: TContext) => boolean;
@@ -1680,6 +1695,7 @@ export function buildTelegramAgentEndPlan(options: {
   hasFinalText: boolean;
   hasQueuedAttachments: boolean;
   foldQueuedPromptsIntoHistory: boolean;
+  announceNextAbortOnEnd?: boolean;
 }): TelegramAgentEndPlan {
   const shouldDispatchNext = shouldDispatchAfterTelegramAgentEnd({
     hasTurn: options.hasTurn,
@@ -1691,6 +1707,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "no-turn",
       shouldClearPreview: false,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1700,6 +1717,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "aborted",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: options.announceNextAbortOnEnd === true,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1709,6 +1727,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "error",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: true,
       shouldSendAttachmentNotice: false,
     };
@@ -1718,6 +1737,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "text",
       shouldClearPreview: false,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: false,
     };
@@ -1727,6 +1747,7 @@ export function buildTelegramAgentEndPlan(options: {
       kind: "attachments-only",
       shouldClearPreview: true,
       shouldDispatchNext,
+      shouldSendAbortMessage: false,
       shouldSendErrorMessage: false,
       shouldSendAttachmentNotice: true,
     };
@@ -1735,6 +1756,7 @@ export function buildTelegramAgentEndPlan(options: {
     kind: "empty",
     shouldClearPreview: true,
     shouldDispatchNext,
+    shouldSendAbortMessage: false,
     shouldSendErrorMessage: false,
     shouldSendAttachmentNotice: false,
   };
@@ -1761,8 +1783,7 @@ export function createTelegramAgentEndHook<
     if (deps.isSessionActive?.(ctx) === false) 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;
@@ -1892,6 +1913,7 @@ export async function handleTelegramAgentEndRuntime<
     hasFinalText: !!finalText || hasOutboundArtifacts,
     hasQueuedAttachments: (turn?.queuedAttachments.length ?? 0) > 0,
     foldQueuedPromptsIntoHistory: deps.foldQueuedPromptsIntoHistory,
+    announceNextAbortOnEnd: turn?.announceNextAbortOnEnd === true,
   });
   if (!turn) {
     if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
@@ -2018,22 +2040,29 @@ export async function handleTelegramAgentEndRuntime<
       await clearTurnPreview();
       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" as const } : {}),
-        },
-      );
+      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" as const } : {}),
+          },
+        );
+      } catch (error) {
+        if (!isOperationAborted) throw error;
+        deps.recordRuntimeEvent?.("dispatch", error, {
+          phase: "next-abort-announcement",
+        });
+      }
       if (!isDeliveryActive()) return;
       if (endPlan.shouldDispatchNext) deps.dispatchNextQueuedTelegramTurn();
       return;
@@ -2181,7 +2210,7 @@ export async function handleTelegramAgentEndRuntime<
   };
   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;
@@ -3093,6 +3122,9 @@ export interface TelegramQueueDispatchControllerDeps<
   ) => boolean;
   sendUserMessage: TelegramDispatchRuntimeDeps<TContext>["sendUserMessage"];
   onPromptDispatchFailure: (ctx: TContext, message: string) => void;
+  reconcileNextDispatchAnnouncementReplyOwnership?: (
+    item: PendingTelegramTurn,
+  ) => void;
   isQueueItemTransportActive?: (item: TelegramQueueItem<TContext>) => boolean;
   hasPendingInboundQueueMutationForItem?: (
     item: TelegramQueueItem<TContext>,
@@ -3108,6 +3140,7 @@ export interface TelegramQueueDispatchControllerDeps<
 export interface TelegramQueueDispatchController<TContext = unknown> {
   dispatchNext: (ctx: TContext) => void;
   requestNextDispatchAnnouncement: () => void;
+  cancelNextDispatchAnnouncement: () => void;
 }
 
 export function executeTelegramQueueDispatchPlan<TContext = unknown>(
@@ -3162,6 +3195,8 @@ export function createTelegramQueueDispatchRuntime<TContext = unknown>(
     commitPromptDispatch: deps.commitPromptDispatch,
     sendUserMessage: deps.sendUserMessage,
     onPromptDispatchFailure: deps.onPromptDispatchFailure,
+    reconcileNextDispatchAnnouncementReplyOwnership:
+      deps.reconcileNextDispatchAnnouncementReplyOwnership,
     isQueueItemTransportActive: deps.isQueueItemTransportActive,
     hasPendingInboundQueueMutationForItem:
       deps.hasPendingInboundQueueMutationForItem,
@@ -3177,12 +3212,19 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
 ): TelegramQueueDispatchController<TContext> {
   let controlDispatchPending = false;
   let nextDispatchAnnouncementRequested = false;
+  let nextDispatchAnnouncementGeneration = 0;
   let nextDispatchAnnouncementAnchor: TelegramQueueItem<TContext> | undefined;
   const controller: TelegramQueueDispatchController<TContext> = {
     requestNextDispatchAnnouncement: () => {
+      nextDispatchAnnouncementGeneration += 1;
       nextDispatchAnnouncementRequested = true;
       nextDispatchAnnouncementAnchor = undefined;
     },
+    cancelNextDispatchAnnouncement: () => {
+      nextDispatchAnnouncementGeneration += 1;
+      nextDispatchAnnouncementRequested = false;
+      nextDispatchAnnouncementAnchor = undefined;
+    },
     dispatchNext: (ctx) => {
       if (deps.hasDispatchContext && !deps.hasDispatchContext()) return;
       if (controlDispatchPending) {
@@ -3394,6 +3436,7 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
       if (dispatchPlan.kind === "prompt" && nextDispatchAnnouncementRequested) {
         nextDispatchAnnouncementRequested = false;
         controlDispatchPending = true;
+        const announcementGeneration = nextDispatchAnnouncementGeneration;
         const dispatchGeneration = deps.getDispatchGeneration?.();
         deps.updateStatus(ctx);
         void deps.sendTextReply(
@@ -3402,8 +3445,19 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
           "<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;
           if (
@@ -3411,6 +3465,10 @@ export function createTelegramQueueDispatchController<TContext = unknown>(
             deps.isDispatchGenerationActive &&
             !deps.isDispatchGenerationActive(dispatchGeneration)
           ) return;
+          if (announcementGeneration !== nextDispatchAnnouncementGeneration) {
+            if (nextDispatchAnnouncementRequested) controller.dispatchNext(ctx);
+            return;
+          }
           executePlan();
         });
         return;

package/lib/replies.ts

@@ -68,6 +68,7 @@ export function createReplyDedupRuntime(): ReplyDedupRuntime {
 // --- Transport-level dedup ---
 
 const lastRepliedToMessageIdByTarget = new Map<string, number>();
+const replyDedupPreservedOnNextReset = new Map<string, number>();
 let replyDedupGeneration = 0;
 
 function getReplyDedupTargetKey(
@@ -83,6 +84,23 @@ function getReplyDedupTargetKey(
 export function resetTransportReplyDedup(): void {
   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: number,
+  messageId: number,
+  target?: TelegramTarget,
+): void {
+  const key = getReplyDedupTargetKey(chatId, target);
+  if (lastRepliedToMessageIdByTarget.get(key) !== messageId) return;
+  replyDedupPreservedOnNextReset.set(key, messageId);
 }
 
 export function buildTelegramReplyParameters(

package/lib/routing.ts

@@ -627,6 +627,7 @@ export interface TelegramInboundRouteRuntimeDeps<
   isContextActive?: (ctx: TContext) => boolean;
   dispatchNextQueuedTelegramTurn: (ctx: TContext) => void;
   requestNextDispatchAnnouncement?: () => void;
+  cancelNextDispatchAnnouncement?: () => void;
   requestDeferredDispatchNextQueuedTelegramTurn?: (
     dispatch: (ctx: TContext) => void,
   ) => void;
@@ -2222,6 +2223,10 @@ export function createTelegramInboundRouteRuntime<
     isContextActive: deps.isContextActive,
     dispatchNextQueuedTelegramTurn: deps.dispatchNextQueuedTelegramTurn,
     requestNextDispatchAnnouncement: deps.requestNextDispatchAnnouncement,
+    cancelNextTransitionAnnouncements: () => {
+      deps.activeTurnRuntime.clearNextAbortAnnouncement();
+      deps.cancelNextDispatchAnnouncement?.();
+    },
     requestDeferredDispatchNextQueuedTelegramTurn:
       deps.requestDeferredDispatchNextQueuedTelegramTurn,
     startTypingLoop: deps.startTypingLoop,
@@ -2297,6 +2302,8 @@ export function createTelegramInboundRouteRuntime<
     },
     getPromptTemplateCommands,
     sendTextReply: deps.sendTextReply,
+    markActiveTurnNextAbortAnnouncement:
+      deps.activeTurnRuntime.markNextAbortAnnouncement,
     getActiveTurnReply: () => {
       const activeTurn = deps.activeTurnRuntime.get();
       if (!activeTurn) return undefined;

package/lib/sync.ts

@@ -7,6 +7,7 @@
 import { getTelegramApiErrorRequestTarget, isTelegramStaleTargetHttpError } from "./telegram-api.ts";
 import { getTelegramTargetKey, type TelegramTarget } from "./target.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
+import { TelegramWorkspaceSlotUnavailableError } from "./workspace-slots.ts";
 import {
   createTelegramWorkspaceAdmissionOperationId,
   runWithTelegramWorkspaceAdmissionsAsync,
@@ -197,6 +198,47 @@ export function markTelegramConfigSyncChange<
   return nextState;
 }
 
+export 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 {
+  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 interface TelegramSessionRestartThreadCleanupDeps<
   TSyncState extends TelegramSyncState,
 > extends Omit<TelegramManualThreadDisconnectDeps<TSyncState>, "stopPolling"> {
@@ -650,15 +692,17 @@ export async function ensureTelegramLeaderThreadBinding(
   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 },
+        { 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 (

package/lib/telegram-api.ts

@@ -882,15 +882,18 @@ export function isTelegramApiCommitUnknownError(
 class TelegramApiHttpError extends Error {
   readonly status: number | undefined;
   readonly retryAfterSeconds: number | undefined;
+  readonly rejectedRequestMethod: string | undefined;
   requestTarget?: { chatId: number; threadId: number };
   constructor(
     message: string,
     status: number | undefined,
     retryAfterSeconds: number | undefined,
+    rejectedRequestMethod?: string,
   ) {
     super(message);
     this.status = status;
     this.retryAfterSeconds = retryAfterSeconds;
+    this.rejectedRequestMethod = rejectedRequestMethod;
   }
 }
 
@@ -934,6 +937,12 @@ export function isTelegramStaleTargetHttpError(error: unknown): boolean {
   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: unknown, method: string): boolean {
+  return error instanceof TelegramApiHttpError && error.rejectedRequestMethod !== undefined &&
+    error.rejectedRequestMethod === method;
+}
+
 export function isTelegramMessageNotModifiedError(error: unknown): boolean {
   return (
     error instanceof Error && error.message.includes("message is not modified")
@@ -1106,6 +1115,8 @@ async function parseTelegramApiResponse<TResponse>(
       `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) {
@@ -1785,6 +1796,10 @@ export function buildTelegramAnswerGuestQueryBody(
   return body;
 }
 
+export type TelegramWorkspaceThreadDeletionTransport = (
+  authorize: () => { chatId: number; threadId: number },
+) => Promise<void>;
+
 export function createDefaultTelegramBridgeApiRuntime(deps: {
   getBotToken: () => string | undefined;
   recordRuntimeEvent: TelegramBridgeApiRuntimeDeps["recordRuntimeEvent"];
@@ -1793,7 +1808,9 @@ export function createDefaultTelegramBridgeApiRuntime(deps: {
   workspaceAdmission?:
     | TelegramApiWorkspaceAdmissionPort
     | (() => TelegramApiWorkspaceAdmissionPort | undefined);
-}): TelegramBridgeApiRuntime {
+}): TelegramBridgeApiRuntime & {
+  deleteWorkspaceThread: TelegramWorkspaceThreadDeletionTransport;
+} {
   const client = createTelegramApiClient(deps.getBotToken, {
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
@@ -1807,7 +1824,7 @@ export function createDefaultTelegramBridgeApiRuntime(deps: {
         },
       })
     : client;
-  return createTelegramBridgeApiRuntime({
+  const runtime = createTelegramBridgeApiRuntime({
     client: deps.targetActivity
       ? createTelegramApiTargetTrackingClient(admittedClient, deps.targetActivity)
       : admittedClient,
@@ -1817,6 +1834,17 @@ 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<boolean>("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(

package/lib/thread-cleanup-manager.ts

@@ -433,7 +433,12 @@ export function createTelegramThreadCleanupWorkStore(options: {
         publish(file); return { confirmed: true, entry: structuredClone(entry) };
       });
     },
-    list() { return structuredClone(read().workSets); },
+    list() {
+      return structuredClone(withTelegramFileTransaction(
+        `${options.path}.transaction`,
+        () => read().workSets,
+      ));
+    },
   };
 }
 
@@ -542,8 +547,11 @@ export function createTelegramThreadCleanupPermitRuntime(deps: {
     if (fence.leaderEpoch !== leaderEpoch || fence.owner.processId !== owner.processId ||
         fence.owner.processBirthId !== owner.processBirthId) {
       if (!deps.canAdoptFence(fence)) return undefined;
-      try { fence = deps.ledger.adoptThreadCleanupFence(fence,
-        { owner, leaderEpoch }); } catch { return undefined; }
+      try {
+        const adopted = deps.ledger.adoptThreadCleanupFence(fence, { owner, leaderEpoch });
+        if (adopted.destructiveKind !== "manual-thread-cleanup") return undefined;
+        fence = adopted;
+      } catch { return undefined; }
     }
     return deps.getLeaderEpoch() === leaderEpoch ? fence : undefined;
   };