@llblab/pi-telegram 0.52.2 → 0.53.0

package/lib/workspace-retirement.ts

@@ -14,25 +14,24 @@ import type {
   TelegramUpdateJournalEntry,
   TelegramUpdateJournalQueueOwnerIdentity,
 } from "./journal.ts";
-import { areTelegramTargetsEqual as sameTarget, type TelegramTarget } from "./target.ts";
+import {
+  areTelegramTargetsEqual as sameTarget,
+  type TelegramTarget,
+} from "./target.ts";
 import {
   getTelegramApiErrorRequestTarget,
   isTelegramApiRequestRejected,
   type TelegramWorkspaceThreadDeletionTransport,
 } from "./telegram-api.ts";
+import { isTelegramTopicDeletedErrorMessage } from "./thread-reconciler.ts";
 import type {
   TelegramTopicTargetStore,
-  TelegramWorkspaceJournalSource,
   TelegramWorkspaceExternalProtectionEvidence,
-  TelegramWorkspaceRetirementIntent,
+  TelegramWorkspaceJournalSource,
   TelegramWorkspaceProtectionState,
+  TelegramWorkspaceRetirementIntent,
   TelegramWorkspaceThreadBinding,
 } from "./threads.ts";
-import {
-  planTelegramWorkspaceSlotAllocation,
-  TelegramWorkspaceSlotUnavailableError,
-  type TelegramWorkspaceSlotOccupancy,
-} from "./workspace-slots.ts";
 import {
   createTelegramWorkspaceAdmissionOperationId,
   isTelegramWorkspaceRetirementFence,
@@ -42,6 +41,11 @@ import {
   type TelegramWorkspaceDeletionPermit,
   type TelegramWorkspaceRetirementFence,
 } from "./workspace-admission.ts";
+import {
+  planTelegramWorkspaceSlotAllocation,
+  TelegramWorkspaceSlotUnavailableError,
+  type TelegramWorkspaceSlotOccupancy,
+} from "./workspace-slots.ts";
 
 export interface TelegramWorkspaceOperationGate {
   runExclusive: <T>(operation: () => Promise<T>) => Promise<T>;
@@ -52,7 +56,10 @@ export function createTelegramWorkspaceOperationGate(): TelegramWorkspaceOperati
   return {
     runExclusive<T>(operation: () => Promise<T>): Promise<T> {
       const run = tail.then(operation);
-      tail = run.then(() => undefined, () => undefined);
+      tail = run.then(
+        () => undefined,
+        () => undefined,
+      );
       return run;
     },
   };
@@ -67,18 +74,21 @@ export type TelegramWorkspaceOperationRunner = <T>(
   operation: () => Promise<T>,
 ) => Promise<T>;
 
-export interface TelegramWorkspaceOperationRuntime
-  extends TelegramWorkspaceOperationGate {
+export interface TelegramWorkspaceOperationRuntime extends TelegramWorkspaceOperationGate {
   run: TelegramWorkspaceOperationRunner;
 }
 
-export function createTelegramWorkspaceOperationRuntime(input: {
-  getWorkspaceAdmission?: () => Pick<
-    TelegramWorkspaceAdmissionLedger,
-    "acquireAdmission" | "releaseAdmission"
-  > | undefined;
-  onReleaseError?: (error: unknown, operationKind: string) => void;
-} = {}): TelegramWorkspaceOperationRuntime {
+export function createTelegramWorkspaceOperationRuntime(
+  input: {
+    getWorkspaceAdmission?: () =>
+      | Pick<
+          TelegramWorkspaceAdmissionLedger,
+          "acquireAdmission" | "releaseAdmission"
+        >
+      | undefined;
+    onReleaseError?: (error: unknown, operationKind: string) => void;
+  } = {},
+): TelegramWorkspaceOperationRuntime {
   const gate = createTelegramWorkspaceOperationGate();
   const run: TelegramWorkspaceOperationRunner = (metadata, operation) => {
     const gated = () => gate.runExclusive(operation);
@@ -106,8 +116,13 @@ export interface TelegramWorkspaceJournalProtectionCapture {
 
 interface TelegramWorkspaceJournalReader {
   recoveryKey?: string;
-  journal: { read: () => { entries: readonly { update: unknown }[]; exists?: boolean } };
-  readForProtection?: () => { entries: readonly { update: unknown }[]; exists?: boolean };
+  journal: {
+    read: () => { entries: readonly { update: unknown }[]; exists?: boolean };
+  };
+  readForProtection?: () => {
+    entries: readonly { update: unknown }[];
+    exists?: boolean;
+  };
 }
 
 export function captureTelegramWorkspaceJournalProtectionSources(input: {
@@ -120,16 +135,21 @@ export function captureTelegramWorkspaceJournalProtectionSources(input: {
     recipientBindingKey: string,
     sessionId: string,
   ) => () => TelegramWorkspaceJournalReader | undefined;
-  withJournalReference?: <T>(binding: TelegramWorkspaceJournalReader,
-    operation: () => T) => T;
+  withJournalReference?: <T>(
+    binding: TelegramWorkspaceJournalReader,
+    operation: () => T,
+  ) => T;
   discovery?: {
     paths: readonly string[];
     complete: boolean;
-    createResolver: (path: string) => () => TelegramWorkspaceJournalReader | undefined;
+    createResolver: (
+      path: string,
+    ) => () => TelegramWorkspaceJournalReader | undefined;
   };
 }): TelegramWorkspaceJournalProtectionCapture {
   const sources: TelegramWorkspaceJournalProtectionSource[] = [];
-  let complete = input.binding.journalBindingsComplete === true ||
+  let complete =
+    input.binding.journalBindingsComplete === true ||
     input.discovery?.complete === true;
   const capture = (
     scope: TelegramWorkspaceJournalProtectionSource["scope"],
@@ -146,8 +166,12 @@ export function captureTelegramWorkspaceJournalProtectionSources(input: {
       const snapshot = input.withJournalReference
         ? input.withJournalReference(binding, read)
         : read();
-      sources.push({ kind: "available", scope, entries: snapshot.entries,
-        ...(snapshot.exists === undefined ? {} : { exists: snapshot.exists }) });
+      sources.push({
+        kind: "available",
+        scope,
+        entries: snapshot.entries,
+        ...(snapshot.exists === undefined ? {} : { exists: snapshot.exists }),
+      });
     } catch {
       complete = false;
       sources.push({ kind: "unknown", scope });
@@ -165,12 +189,24 @@ export function captureTelegramWorkspaceJournalProtectionSources(input: {
     );
   }
   for (const source of input.binding.journalSources ?? []) {
-    capture({ kind: "binding", bindingKey: input.binding.bindingKey,
-      journalBindingKey: source.recipientBindingKey, sessionId: source.sessionId },
-      input.createSessionResolver?.(source.recipientBindingKey, source.sessionId) ?? (() => undefined));
+    capture(
+      {
+        kind: "binding",
+        bindingKey: input.binding.bindingKey,
+        journalBindingKey: source.recipientBindingKey,
+        sessionId: source.sessionId,
+      },
+      input.createSessionResolver?.(
+        source.recipientBindingKey,
+        source.sessionId,
+      ) ?? (() => undefined),
+    );
   }
   for (const path of input.discovery?.paths ?? []) {
-    capture({ kind: "discovered", path }, input.discovery!.createResolver(path));
+    capture(
+      { kind: "discovered", path },
+      input.discovery!.createResolver(path),
+    );
   }
   return { sources, complete };
 }
@@ -180,7 +216,12 @@ export type TelegramWorkspaceJournalProtectionSource =
       kind: "available";
       scope:
         | { kind: "shared" }
-        | { kind: "binding"; bindingKey: string; journalBindingKey: string; sessionId?: string }
+        | {
+            kind: "binding";
+            bindingKey: string;
+            journalBindingKey: string;
+            sessionId?: string;
+          }
         | { kind: "discovered"; path: string };
       entries: readonly { update: unknown }[];
       /** Positive filesystem presence is distinct from a complete namespace with a missing historical family. */
@@ -190,27 +231,36 @@ export type TelegramWorkspaceJournalProtectionSource =
       kind: "unknown";
       scope:
         | { kind: "shared" }
-        | { kind: "binding"; bindingKey: string; journalBindingKey: string; sessionId?: string }
+        | {
+            kind: "binding";
+            bindingKey: string;
+            journalBindingKey: string;
+            sessionId?: string;
+          }
         | { kind: "discovered"; path: string };
     };
 
-function getJournalUpdateTarget(update: unknown):
-  | { chatId: number; threadId?: number }
-  | undefined {
-  if (!update || typeof update !== "object" || Array.isArray(update)) return undefined;
+function getJournalUpdateTarget(
+  update: unknown,
+): { chatId: number; threadId?: number } | undefined {
+  if (!update || typeof update !== "object" || Array.isArray(update))
+    return undefined;
   const record = update as Record<string, unknown>;
   if (record.message_reaction !== undefined) return undefined;
-  const direct = record.message ?? record.edited_message ?? record.guest_message;
+  const direct =
+    record.message ?? record.edited_message ?? record.guest_message;
   const callback = record.callback_query;
-  const message = direct ?? (
-    callback && typeof callback === "object" && !Array.isArray(callback)
+  const message =
+    direct ??
+    (callback && typeof callback === "object" && !Array.isArray(callback)
       ? (callback as Record<string, unknown>).message
-      : undefined
-  );
-  if (!message || typeof message !== "object" || Array.isArray(message)) return undefined;
+      : undefined);
+  if (!message || typeof message !== "object" || Array.isArray(message))
+    return undefined;
   const messageRecord = message as Record<string, unknown>;
   const chat = messageRecord.chat;
-  if (!chat || typeof chat !== "object" || Array.isArray(chat)) return undefined;
+  if (!chat || typeof chat !== "object" || Array.isArray(chat))
+    return undefined;
   const chatId = (chat as Record<string, unknown>).id;
   if (typeof chatId !== "number") return undefined;
   const threadId = messageRecord.message_thread_id;
@@ -228,19 +278,28 @@ export function resolveTelegramWorkspaceAcceptedWorkProtection(input: {
   /** Relocation cannot infer execution ownership from the original Telegram message target. */
   requireBindingProvenance?: boolean;
 }): TelegramWorkspaceProtectionState {
-  if (input.localAcceptedTargets.some((target) => sameTarget(target, input.binding.target))) {
+  if (
+    input.localAcceptedTargets.some((target) =>
+      sameTarget(target, input.binding.target),
+    )
+  ) {
     return "protected";
   }
   let unknown = !input.sourcesComplete;
   for (const source of input.journalSources) {
-    const relevant = source.scope.kind !== "binding" ||
+    const relevant =
+      source.scope.kind !== "binding" ||
       source.scope.bindingKey === input.binding.bindingKey;
     if (!relevant) continue;
     if (source.kind === "unknown") {
       unknown = true;
       continue;
     }
-    if (input.requireBindingProvenance && source.scope.kind === "binding" && source.exists === false) {
+    if (
+      input.requireBindingProvenance &&
+      source.scope.kind === "binding" &&
+      source.exists === false
+    ) {
       unknown = true;
       continue;
     }
@@ -272,7 +331,11 @@ export type TelegramWorkspaceJournalPruneResult =
     }
   | {
       kind: "blocked";
-      reason: "incomplete-evidence" | "writer-not-quiescent" | "state-changed" | "publication-refused";
+      reason:
+        | "incomplete-evidence"
+        | "writer-not-quiescent"
+        | "state-changed"
+        | "publication-refused";
     };
 
 export async function pruneTelegramWorkspaceJournalEvidence(input: {
@@ -310,60 +373,125 @@ export async function pruneTelegramWorkspaceJournalEvidence(input: {
       );
     }
     let capture: TelegramWorkspaceJournalProtectionCapture;
-    try { capture = input.capture(); }
-    catch { return { kind: "blocked", reason: "incomplete-evidence" }; }
-    const address = (key: string, sessionId?: string) => JSON.stringify([sessionId ?? null, key]);
+    try {
+      capture = input.capture();
+    } catch {
+      return { kind: "blocked", reason: "incomplete-evidence" };
+    }
+    const address = (key: string, sessionId?: string) =>
+      JSON.stringify([sessionId ?? null, key]);
     const keys = input.binding.journalBindingKeys ?? [];
     const sessions = input.binding.journalSources ?? [];
     const expected = [
-      ...keys.map(key => address(key)),
-      ...sessions.map(source => address(source.recipientBindingKey, source.sessionId)),
+      ...keys.map((key) => address(key)),
+      ...sessions.map((source) =>
+        address(source.recipientBindingKey, source.sessionId),
+      ),
     ];
-    const shared = capture.sources.filter(source => source.scope.kind === "shared");
-    const bindingSources = capture.sources.filter(source => source.scope.kind === "binding" &&
-      source.scope.bindingKey === input.binding.bindingKey);
-    const sourceByAddress = new Map(bindingSources.flatMap(source => source.scope.kind === "binding"
-      ? [[address(source.scope.journalBindingKey, source.scope.sessionId), source] as const] : []));
-    if (!capture.complete || shared.length !== 1 || shared[0]?.kind !== "available" ||
-        bindingSources.length !== expected.length || sourceByAddress.size !== expected.length ||
-        expected.some(key => sourceByAddress.get(key)?.kind !== "available")) {
+    const shared = capture.sources.filter(
+      (source) => source.scope.kind === "shared",
+    );
+    const bindingSources = capture.sources.filter(
+      (source) =>
+        source.scope.kind === "binding" &&
+        source.scope.bindingKey === input.binding.bindingKey,
+    );
+    const sourceByAddress = new Map(
+      bindingSources.flatMap((source) =>
+        source.scope.kind === "binding"
+          ? [
+              [
+                address(source.scope.journalBindingKey, source.scope.sessionId),
+                source,
+              ] as const,
+            ]
+          : [],
+      ),
+    );
+    if (
+      !capture.complete ||
+      shared.length !== 1 ||
+      shared[0]?.kind !== "available" ||
+      bindingSources.length !== expected.length ||
+      sourceByAddress.size !== expected.length ||
+      expected.some((key) => sourceByAddress.get(key)?.kind !== "available")
+    ) {
       return { kind: "blocked", reason: "incomplete-evidence" };
     }
-    const empty = new Set(expected.filter(key => {
-      const source = sourceByAddress.get(key);
-      return source?.kind === "available" && source.entries.length === 0;
-    }));
+    const empty = new Set(
+      expected.filter((key) => {
+        const source = sourceByAddress.get(key);
+        return source?.kind === "available" && source.entries.length === 0;
+      }),
+    );
     const emptyWriterKeys = new Set([
-      ...keys.filter(key => empty.has(address(key))),
-      ...sessions.filter(source => empty.has(address(source.recipientBindingKey, source.sessionId)))
-        .map(source => source.recipientBindingKey),
+      ...keys.filter((key) => empty.has(address(key))),
+      ...sessions
+        .filter((source) =>
+          empty.has(address(source.recipientBindingKey, source.sessionId)),
+        )
+        .map((source) => source.recipientBindingKey),
     ]);
-    const quiescent = new Set([...emptyWriterKeys].filter(key => input.getJournalWriterProtection(key) === "clear"));
-    const removedKeys = keys.filter(key => empty.has(address(key)) && quiescent.has(key));
-    const removedSources = sessions.filter(source => empty.has(address(source.recipientBindingKey, source.sessionId)) &&
-      quiescent.has(source.recipientBindingKey));
-    if (empty.size > 0 && removedKeys.length === 0 && removedSources.length === 0) {
+    const quiescent = new Set(
+      [...emptyWriterKeys].filter(
+        (key) => input.getJournalWriterProtection(key) === "clear",
+      ),
+    );
+    const removedKeys = keys.filter(
+      (key) => empty.has(address(key)) && quiescent.has(key),
+    );
+    const removedSources = sessions.filter(
+      (source) =>
+        empty.has(address(source.recipientBindingKey, source.sessionId)) &&
+        quiescent.has(source.recipientBindingKey),
+    );
+    if (
+      empty.size > 0 &&
+      removedKeys.length === 0 &&
+      removedSources.length === 0
+    ) {
       return { kind: "blocked", reason: "writer-not-quiescent" };
     }
-    const retainedKeys = keys.filter(key => !removedKeys.includes(key));
-    const retainedSources = sessions.filter(source => !removedSources.includes(source));
+    const retainedKeys = keys.filter((key) => !removedKeys.includes(key));
+    const retainedSources = sessions.filter(
+      (source) => !removedSources.includes(source),
+    );
     if (!isCurrent()) {
-      throw new Error("Telegram Workspace journal pruning lost leader authority.");
+      throw new Error(
+        "Telegram Workspace journal pruning lost leader authority.",
+      );
     }
     const binding = input.store.commitWorkspaceJournalEvidence(
-      input.binding, retainedKeys, input.binding.journalBindingsComplete === true, retainedSources,
+      input.binding,
+      retainedKeys,
+      input.binding.journalBindingsComplete === true,
+      retainedSources,
     );
     if (!binding) return { kind: "blocked", reason: "state-changed" };
     if (removedKeys.length > 0 || removedSources.length > 0) {
-      const published = await input.store.persistWorkspaceJournalEvidence(binding, isCurrent);
-      if (!isCurrent()) throw new Error("Telegram Workspace journal pruning lost leader authority.");
+      const published = await input.store.persistWorkspaceJournalEvidence(
+        binding,
+        isCurrent,
+      );
+      if (!isCurrent())
+        throw new Error(
+          "Telegram Workspace journal pruning lost leader authority.",
+        );
       if (!published) return { kind: "blocked", reason: "publication-refused" };
     }
     if (!isCurrent()) {
-      throw new Error("Telegram Workspace journal pruning lost leader authority.");
+      throw new Error(
+        "Telegram Workspace journal pruning lost leader authority.",
+      );
     }
-    return { kind: "committed", binding, removedKeys,
-      ...(removedSources.length ? { removedSources: removedSources.map(source => ({ ...source })) } : {}) };
+    return {
+      kind: "committed",
+      binding,
+      removedKeys,
+      ...(removedSources.length
+        ? { removedSources: removedSources.map((source) => ({ ...source })) }
+        : {}),
+    };
   };
   return runWithTelegramWorkspaceAdmissionsAsync({
     ledger: input.admission,
@@ -383,9 +511,10 @@ export function captureTelegramWorkspaceExternalProtection(input: {
   getLiveOwnerProtection: (
     binding: TelegramWorkspaceThreadBinding,
   ) => TelegramWorkspaceProtectionState;
-  getLocalAcceptedTargets: (
-    binding: TelegramWorkspaceThreadBinding,
-  ) => { targets: readonly TelegramTarget[]; complete: boolean };
+  getLocalAcceptedTargets: (binding: TelegramWorkspaceThreadBinding) => {
+    targets: readonly TelegramTarget[];
+    complete: boolean;
+  };
   captureJournalSources: (
     binding: TelegramWorkspaceThreadBinding,
   ) => TelegramWorkspaceJournalProtectionCapture;
@@ -415,7 +544,8 @@ export function captureTelegramWorkspaceExternalProtection(input: {
     // Unavailable queue or journal evidence must not clear accepted work.
   }
   try {
-    deliveryAuthority = input.getDeliveryAuthorityProtection?.(input.binding) ?? "unknown";
+    deliveryAuthority =
+      input.getDeliveryAuthorityProtection?.(input.binding) ?? "unknown";
   } catch {
     // Unavailable delivery evidence must not clear a binding.
   }
@@ -434,14 +564,19 @@ interface TelegramWorkspaceProtectionObserverDeps {
     recipientBindingKey: string,
     sessionId: string,
   ) => () => TelegramWorkspaceJournalReader | undefined;
-  discoverFollowerJournals?: () => { paths: readonly string[]; complete: boolean };
+  discoverFollowerJournals?: () => {
+    paths: readonly string[];
+    complete: boolean;
+  };
   /** Strict read-only namespace evidence; it never substitutes for writer closure. */
   inspectJournalNamespace?: () => TelegramJournalNamespaceInspection;
   createJournalPathResolver?: (
     path: string,
   ) => () => TelegramWorkspaceJournalReader | undefined;
-  withJournalReference?: <T>(binding: TelegramWorkspaceJournalReader,
-    operation: () => T) => T;
+  withJournalReference?: <T>(
+    binding: TelegramWorkspaceJournalReader,
+    operation: () => T,
+  ) => T;
   getJournalWriterProtection?: (
     journalBindingKey: string,
   ) => TelegramWorkspaceProtectionState;
@@ -451,51 +586,105 @@ interface TelegramWorkspaceProtectionObserverDeps {
 }
 
 export interface TelegramWorkspaceProtectionObserver {
-  capture: (binding: TelegramWorkspaceThreadBinding,
-    options?: { requireBindingProvenance?: boolean }) => TelegramWorkspaceExternalProtectionEvidence;
-  captureJournalSources: (binding: TelegramWorkspaceThreadBinding) => TelegramWorkspaceJournalProtectionCapture;
-  getJournalWriterProtection: (journalBindingKey: string) => TelegramWorkspaceProtectionState;
+  capture: (
+    binding: TelegramWorkspaceThreadBinding,
+    options?: { requireBindingProvenance?: boolean },
+  ) => TelegramWorkspaceExternalProtectionEvidence;
+  captureJournalSources: (
+    binding: TelegramWorkspaceThreadBinding,
+  ) => TelegramWorkspaceJournalProtectionCapture;
+  getJournalWriterProtection: (
+    journalBindingKey: string,
+  ) => TelegramWorkspaceProtectionState;
 }
 
 /** Shared read-only observer: protection and metadata pruning use the same scoped evidence path. */
-export function createTelegramWorkspaceProtectionObserver(deps: TelegramWorkspaceProtectionObserverDeps): TelegramWorkspaceProtectionObserver {
-  const captureJournalSources: TelegramWorkspaceProtectionObserver["captureJournalSources"] = (candidate) => {
-    const namespace = deps.inspectJournalNamespace?.();
-    if (deps.inspectJournalNamespace && (!namespace || namespace.sources.filter(source => source.role === "polling").length !== 1))
-      throw new Error("Telegram strict namespace evidence is unavailable or incomplete.");
-    if (namespace?.retainedInputs?.some(original => original.state !== "committed")) throw new Error(
-      "Telegram namespace contains uncommitted private retention evidence.",
-    );
-    const discovery = namespace
-      ? { paths: namespace.sources.filter(source => source.role !== "polling" && source.evidence.kind === "present")
-          .map(source => source.path), complete: true }
-      : candidate.journalBindingsComplete === true ? undefined : deps.discoverFollowerJournals?.();
-    if (namespace && !deps.createJournalPathResolver) throw new Error(
-      "Telegram strict namespace protection requires discovered source resolution.",
-    );
-    return captureTelegramWorkspaceJournalProtectionSources({
-      binding: candidate,
-      resolveLeader: deps.resolveLeaderJournal,
-      createFollowerResolver: deps.createFollowerJournalResolver,
-      ...(deps.createSessionJournalResolver ? { createSessionResolver: deps.createSessionJournalResolver } : {}),
-      ...(deps.withJournalReference ? { withJournalReference: deps.withJournalReference } : {}),
-      ...(discovery && deps.createJournalPathResolver
-        ? { discovery: { ...discovery, createResolver: deps.createJournalPathResolver } } : {}),
-    });
-  };
-  const capture: TelegramWorkspaceProtectionObserver["capture"] = function (binding, options) {
+export function createTelegramWorkspaceProtectionObserver(
+  deps: TelegramWorkspaceProtectionObserverDeps,
+): TelegramWorkspaceProtectionObserver {
+  const captureJournalSources: TelegramWorkspaceProtectionObserver["captureJournalSources"] =
+    (candidate) => {
+      const namespace = deps.inspectJournalNamespace?.();
+      if (
+        deps.inspectJournalNamespace &&
+        (!namespace ||
+          namespace.sources.filter((source) => source.role === "polling")
+            .length !== 1)
+      )
+        throw new Error(
+          "Telegram strict namespace evidence is unavailable or incomplete.",
+        );
+      if (
+        namespace?.retainedInputs?.some(
+          (original) => original.state !== "committed",
+        )
+      )
+        throw new Error(
+          "Telegram namespace contains uncommitted private retention evidence.",
+        );
+      const discovery = namespace
+        ? {
+            paths: namespace.sources
+              .filter(
+                (source) =>
+                  source.role !== "polling" &&
+                  source.evidence.kind === "present",
+              )
+              .map((source) => source.path),
+            complete: true,
+          }
+        : candidate.journalBindingsComplete === true
+          ? undefined
+          : deps.discoverFollowerJournals?.();
+      if (namespace && !deps.createJournalPathResolver)
+        throw new Error(
+          "Telegram strict namespace protection requires discovered source resolution.",
+        );
+      return captureTelegramWorkspaceJournalProtectionSources({
+        binding: candidate,
+        resolveLeader: deps.resolveLeaderJournal,
+        createFollowerResolver: deps.createFollowerJournalResolver,
+        ...(deps.createSessionJournalResolver
+          ? { createSessionResolver: deps.createSessionJournalResolver }
+          : {}),
+        ...(deps.withJournalReference
+          ? { withJournalReference: deps.withJournalReference }
+          : {}),
+        ...(discovery && deps.createJournalPathResolver
+          ? {
+              discovery: {
+                ...discovery,
+                createResolver: deps.createJournalPathResolver,
+              },
+            }
+          : {}),
+      });
+    };
+  const capture: TelegramWorkspaceProtectionObserver["capture"] = function (
+    binding,
+    options,
+  ) {
     return captureTelegramWorkspaceExternalProtection({
       binding,
       requireBindingProvenance: options?.requireBindingProvenance,
       getLiveOwnerProtection(candidate) {
-        if (deps.listFollowers().some((follower) =>
-          !!follower.target && sameTarget(follower.target, candidate.target),
-        )) return "protected";
+        if (
+          deps
+            .listFollowers()
+            .some(
+              (follower) =>
+                !!follower.target &&
+                sameTarget(follower.target, candidate.target),
+            )
+        )
+          return "protected";
         if (!deps.getJournalWriterProtection) return "unknown";
         let unknown = candidate.journalBindingsComplete !== true;
         const writerKeys = new Set([
           ...(candidate.journalBindingKeys ?? []),
-          ...(candidate.journalSources ?? []).map(source => source.recipientBindingKey),
+          ...(candidate.journalSources ?? []).map(
+            (source) => source.recipientBindingKey,
+          ),
         ]);
         for (const journalBindingKey of writerKeys) {
           const protection = deps.getJournalWriterProtection(journalBindingKey);
@@ -518,36 +707,56 @@ export function createTelegramWorkspaceProtectionObserver(deps: TelegramWorkspac
       },
       captureJournalSources,
       ...(deps.getDeliveryAuthorityProtection
-        ? { getDeliveryAuthorityProtection: deps.getDeliveryAuthorityProtection }
+        ? {
+            getDeliveryAuthorityProtection: deps.getDeliveryAuthorityProtection,
+          }
         : {}),
     });
   };
-  return { capture, captureJournalSources,
-    getJournalWriterProtection: deps.getJournalWriterProtection ?? (() => "unknown") };
+  return {
+    capture,
+    captureJournalSources,
+    getJournalWriterProtection:
+      deps.getJournalWriterProtection ?? (() => "unknown"),
+  };
 }
 
 /** Callable protection view retained for callers that need no metadata observation ports. */
-export function createTelegramWorkspaceExternalProtectionCapture(deps: TelegramWorkspaceProtectionObserverDeps): TelegramWorkspaceProtectionObserver["capture"] {
+export function createTelegramWorkspaceExternalProtectionCapture(
+  deps: TelegramWorkspaceProtectionObserverDeps,
+): TelegramWorkspaceProtectionObserver["capture"] {
   return createTelegramWorkspaceProtectionObserver(deps).capture;
 }
 
-export function createTelegramWorkspaceJournalEvidencePruner(deps: TelegramWorkspaceOperationGate & {
-  store: TelegramTopicTargetStore;
-  getAdmission: () => TelegramWorkspaceAdmissionLedger | undefined;
-  getLeaderEpoch: () => number | string | undefined;
-  protection: Pick<TelegramWorkspaceProtectionObserver, "captureJournalSources" | "getJournalWriterProtection">;
-}): (binding: TelegramWorkspaceThreadBinding, isCurrent: () => boolean) => Promise<TelegramWorkspaceJournalPruneResult> {
+export function createTelegramWorkspaceJournalEvidencePruner(
+  deps: TelegramWorkspaceOperationGate & {
+    store: TelegramTopicTargetStore;
+    getAdmission: () => TelegramWorkspaceAdmissionLedger | undefined;
+    getLeaderEpoch: () => number | string | undefined;
+    protection: Pick<
+      TelegramWorkspaceProtectionObserver,
+      "captureJournalSources" | "getJournalWriterProtection"
+    >;
+  },
+): (
+  binding: TelegramWorkspaceThreadBinding,
+  isCurrent: () => boolean,
+) => Promise<TelegramWorkspaceJournalPruneResult> {
   return async (binding, isCurrent) => {
     const admission = deps.getAdmission();
     if (!admission) return { kind: "blocked", reason: "state-changed" };
     const profileKey = admission.getProfileKey();
     return pruneTelegramWorkspaceJournalEvidence({
-      store: deps.store, binding, admission, runExclusive: deps.runExclusive,
+      store: deps.store,
+      binding,
+      admission,
+      runExclusive: deps.runExclusive,
       capture: () => deps.protection.captureJournalSources(binding),
       getJournalWriterProtection: deps.protection.getJournalWriterProtection,
       getLeaderEpoch: deps.getLeaderEpoch,
       getProfileKey: () => deps.getAdmission()?.getProfileKey() ?? "",
-      isCurrent: () => isCurrent() && deps.getAdmission()?.getProfileKey() === profileKey,
+      isCurrent: () =>
+        isCurrent() && deps.getAdmission()?.getProfileKey() === profileKey,
     });
   };
 }
@@ -556,8 +765,9 @@ export function isCurrentTelegramWorkspaceBinding(
   store: Pick<TelegramTopicTargetStore, "listWorkspaceBindings">,
   expected: TelegramWorkspaceThreadBinding,
 ): boolean {
-  return store.listWorkspaceBindings().some((binding) =>
-    isDeepStrictEqual(binding, expected));
+  return store
+    .listWorkspaceBindings()
+    .some((binding) => isDeepStrictEqual(binding, expected));
 }
 
 export interface TelegramWorkspaceDeadQueueJournalBinding {
@@ -598,7 +808,8 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
   ) => TelegramWorkspaceExternalProtectionEvidence;
   getActiveTurnTarget: () => TelegramTarget | undefined;
   getQueuedItems: () => readonly { chatId: number; target?: TelegramTarget }[];
-  resolveLeaderJournal: () => TelegramWorkspaceDeadQueueJournalBinding | undefined;
+  resolveLeaderJournal: () =>
+    TelegramWorkspaceDeadQueueJournalBinding | undefined;
   createFollowerJournalResolver: (
     journalBindingKey: string,
   ) => () => TelegramWorkspaceDeadQueueJournalBinding | undefined;
@@ -606,7 +817,10 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
     recipientBindingKey: string,
     sessionId: string,
   ) => () => TelegramWorkspaceDeadQueueJournalBinding | undefined;
-  discoverFollowerJournals?: () => { paths: readonly string[]; complete: boolean };
+  discoverFollowerJournals?: () => {
+    paths: readonly string[];
+    complete: boolean;
+  };
   createJournalPathResolver?: (
     path: string,
   ) => () => TelegramWorkspaceDeadQueueJournalBinding | undefined;
@@ -615,9 +829,10 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
     operation: () => T,
   ) => T;
   getRecoveryOwner: () => TelegramUpdateJournalQueueOwnerIdentity;
-  getQueueOwnerLiveness: (
-    owner: { processId: number; processBirthId: string },
-  ) => "alive" | "dead" | "unverifiable";
+  getQueueOwnerLiveness: (owner: {
+    processId: number;
+    processBirthId: string;
+  }) => "alive" | "dead" | "unverifiable";
   isBindingCurrent: (binding: TelegramWorkspaceThreadBinding) => boolean;
   onMutationError?: (error: unknown) => void;
 }): (
@@ -631,7 +846,8 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
     if (active && sameTarget(active, binding.target)) return "protected";
     let unknown = false;
     for (const item of deps.getQueuedItems()) {
-      if (item.target && sameTarget(item.target, binding.target)) return "protected";
+      if (item.target && sameTarget(item.target, binding.target))
+        return "protected";
       if (!item.target && item.chatId === binding.target.chatId) unknown = true;
     }
     return unknown ? "unknown" : "clear";
@@ -644,7 +860,10 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
     if (binding.journalSources?.length && !deps.createSessionJournalResolver)
       return { kind: "blocked", reason: "incomplete-source" };
     const initial = deps.getExternalProtection(binding);
-    if (initial.liveOwner !== "clear" || initial.deliveryAuthority !== "clear") {
+    if (
+      initial.liveOwner !== "clear" ||
+      initial.deliveryAuthority !== "clear"
+    ) {
       return { kind: "blocked", reason: "live-owner" };
     }
     if (localProtection(binding) !== "clear") {
@@ -652,10 +871,12 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
     }
     if (initial.acceptedWork === "clear") return { kind: "not-needed" };
 
-    const discovery = binding.journalBindingsComplete === true
-      ? undefined
-      : deps.discoverFollowerJournals?.();
-    let complete = binding.journalBindingsComplete === true || discovery?.complete === true;
+    const discovery =
+      binding.journalBindingsComplete === true
+        ? undefined
+        : deps.discoverFollowerJournals?.();
+    let complete =
+      binding.journalBindingsComplete === true || discovery?.complete === true;
     const sources: Array<{
       scope: "shared" | "binding" | "discovered";
       binding: TelegramWorkspaceDeadQueueJournalBinding;
@@ -687,7 +908,13 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
       capture("binding", deps.createFollowerJournalResolver(key));
     }
     for (const source of binding.journalSources ?? []) {
-      capture("binding", deps.createSessionJournalResolver!(source.recipientBindingKey, source.sessionId));
+      capture(
+        "binding",
+        deps.createSessionJournalResolver!(
+          source.recipientBindingKey,
+          source.sessionId,
+        ),
+      );
     }
     for (const path of discovery?.paths ?? []) {
       if (!deps.createJournalPathResolver) {
@@ -703,55 +930,80 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
       recovery: TelegramUpdateJournalDeadQueueOwnerRecoveryInput;
     }> = [];
     for (const source of sources) {
-      const relevant = source.scope === "binding"
-        ? [...source.entries]
-        : source.entries.filter((entry) => {
-            const target = getJournalUpdateTarget(entry.update);
-            return !!target && sameTarget(target, binding.target);
-          });
-      if (source.scope === "binding" && relevant.some((entry) => {
-        const target = getJournalUpdateTarget(entry.update);
-        return !target || !sameTarget(target, binding.target);
-      })) return { kind: "blocked", reason: "unsupported-custody" };
+      const relevant =
+        source.scope === "binding"
+          ? [...source.entries]
+          : source.entries.filter((entry) => {
+              const target = getJournalUpdateTarget(entry.update);
+              return !!target && sameTarget(target, binding.target);
+            });
+      if (
+        source.scope === "binding" &&
+        relevant.some((entry) => {
+          const target = getJournalUpdateTarget(entry.update);
+          return !target || !sameTarget(target, binding.target);
+        })
+      )
+        return { kind: "blocked", reason: "unsupported-custody" };
       const seen = new Set<string>();
       for (const entry of relevant) {
-        if (entry.state !== "queued" ||
-            (entry.queueKind !== "prompt" && entry.queueKind !== "control") ||
-            !entry.queueReceiptId || !entry.queueOwner || entry.queueHandoff) {
+        if (
+          entry.state !== "queued" ||
+          (entry.queueKind !== "prompt" && entry.queueKind !== "control") ||
+          !entry.queueReceiptId ||
+          !entry.queueOwner ||
+          entry.queueHandoff
+        ) {
           return { kind: "blocked", reason: "unsupported-custody" };
         }
         if (seen.has(entry.queueReceiptId)) continue;
         const receiptEntries = source.entries.filter(
           (candidate) => candidate.queueReceiptId === entry.queueReceiptId,
         );
-        if (!receiptEntries.length || receiptEntries.some((candidate) => {
-          const target = getJournalUpdateTarget(candidate.update);
-          return candidate.state !== "queued" ||
-            candidate.queueKind !== entry.queueKind ||
-            !candidate.queueOwner || candidate.queueHandoff !== undefined ||
-            !isDeepStrictEqual(candidate.queueOwner, entry.queueOwner) ||
-            !target || !sameTarget(target, binding.target);
-        })) return { kind: "blocked", reason: "unsupported-custody" };
+        if (
+          !receiptEntries.length ||
+          receiptEntries.some((candidate) => {
+            const target = getJournalUpdateTarget(candidate.update);
+            return (
+              candidate.state !== "queued" ||
+              candidate.queueKind !== entry.queueKind ||
+              !candidate.queueOwner ||
+              candidate.queueHandoff !== undefined ||
+              !isDeepStrictEqual(candidate.queueOwner, entry.queueOwner) ||
+              !target ||
+              !sameTarget(target, binding.target)
+            );
+          })
+        )
+          return { kind: "blocked", reason: "unsupported-custody" };
         seen.add(entry.queueReceiptId);
         plans.push({
           source: source.binding,
           recovery: {
             queueKind: entry.queueKind,
             receiptId: entry.queueReceiptId,
-            sourceUpdateIds: receiptEntries.map((candidate) => candidate.updateId).sort((a, b) => a - b),
+            sourceUpdateIds: receiptEntries
+              .map((candidate) => candidate.updateId)
+              .sort((a, b) => a - b),
             deadOwner: entry.queueOwner,
             recoveryOwner: deps.getRecoveryOwner(),
           },
         });
       }
     }
-    if (!plans.length) return { kind: "blocked", reason: "protection-retained" };
+    if (!plans.length)
+      return { kind: "blocked", reason: "protection-retained" };
     for (const plan of plans) {
       let liveness: "alive" | "dead" | "unverifiable" = "unverifiable";
-      try { liveness = deps.getQueueOwnerLiveness(plan.recovery.deadOwner); }
-      catch { /* Unknown process evidence is never destructive authority. */ }
-      if (liveness === "alive") return { kind: "blocked", reason: "owner-alive" };
-      if (liveness !== "dead") return { kind: "blocked", reason: "owner-unverifiable" };
+      try {
+        liveness = deps.getQueueOwnerLiveness(plan.recovery.deadOwner);
+      } catch {
+        /* Unknown process evidence is never destructive authority. */
+      }
+      if (liveness === "alive")
+        return { kind: "blocked", reason: "owner-alive" };
+      if (liveness !== "dead")
+        return { kind: "blocked", reason: "owner-unverifiable" };
     }
 
     const recoveredIds: number[] = [];
@@ -760,7 +1012,10 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
         return { kind: "blocked", reason: "authority-changed" };
       }
       const current = deps.getExternalProtection(binding);
-      if (current.liveOwner !== "clear" || current.deliveryAuthority !== "clear") {
+      if (
+        current.liveOwner !== "clear" ||
+        current.deliveryAuthority !== "clear"
+      ) {
         return { kind: "blocked", reason: "live-owner" };
       }
       if (localProtection(binding) !== "clear") {
@@ -770,10 +1025,15 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
       try {
         result = deps.withJournalReference
           ? deps.withJournalReference(plan.source, () =>
-              plan.source.journal.recoverDeadQueueOwner(plan.recovery))
+              plan.source.journal.recoverDeadQueueOwner(plan.recovery),
+            )
           : plan.source.journal.recoverDeadQueueOwner(plan.recovery);
       } catch (error) {
-        try { deps.onMutationError?.(error); } catch { /* Diagnostics are fail-open. */ }
+        try {
+          deps.onMutationError?.(error);
+        } catch {
+          /* Diagnostics are fail-open. */
+        }
         return { kind: "blocked", reason: "mutation-refused" };
       }
       if (result.status === "owner-alive") {
@@ -788,8 +1048,11 @@ export function createTelegramWorkspaceDeadOwnerQueueReclaimer(deps: {
       return { kind: "blocked", reason: "authority-changed" };
     }
     const after = deps.getExternalProtection(binding);
-    if (after.liveOwner !== "clear" || after.acceptedWork !== "clear" ||
-        after.deliveryAuthority !== "clear") {
+    if (
+      after.liveOwner !== "clear" ||
+      after.acceptedWork !== "clear" ||
+      after.deliveryAuthority !== "clear"
+    ) {
       return { kind: "blocked", reason: "protection-retained" };
     }
     return {
@@ -833,9 +1096,14 @@ export async function adoptTelegramWorkspaceRetirementIntent(input: {
     const leaderEpoch = input.getLeaderEpoch();
     const profileKey = input.getProfileKey();
     const isCurrent = () =>
-      leaderEpoch !== undefined && input.getLeaderEpoch() === leaderEpoch &&
-      input.getProfileKey() === profileKey && input.isCurrent?.() !== false;
-    if (!isCurrent()) throw new Error("Telegram Workspace retirement adoption requires current leader authority.");
+      leaderEpoch !== undefined &&
+      input.getLeaderEpoch() === leaderEpoch &&
+      input.getProfileKey() === profileKey &&
+      input.isCurrent?.() !== false;
+    if (!isCurrent())
+      throw new Error(
+        "Telegram Workspace retirement adoption requires current leader authority.",
+      );
     const intents = input.store.listWorkspaceRetirementIntents();
     if (intents.length !== 1 || !isDeepStrictEqual(intents[0], input.intent)) {
       return { kind: "blocked", reason: "intent-conflict" };
@@ -843,41 +1111,47 @@ export async function adoptTelegramWorkspaceRetirementIntent(input: {
     if (input.intent.profileKey !== profileKey) {
       return { kind: "blocked", reason: "profile-changed" };
     }
-    const binding = input.store.listWorkspaceBindings().find((candidate) =>
-      candidate.bindingKey === input.intent.binding.bindingKey,
-    );
+    const binding = input.store
+      .listWorkspaceBindings()
+      .find(
+        (candidate) => candidate.bindingKey === input.intent.binding.bindingKey,
+      );
     if (!binding || !isDeepStrictEqual(binding, input.intent.binding)) {
       return { kind: "blocked", reason: "binding-changed" };
     }
-    const eligible = input.store.captureWorkspaceSlotOccupancy(
-      input.getExternalProtection,
-      { expectedRetirement: input.intent },
-    ).bindings.find((candidate) =>
-      candidate.bindingKey === binding.bindingKey,
-    )?.protection === "eligible";
+    const eligible =
+      input.store
+        .captureWorkspaceSlotOccupancy(input.getExternalProtection, {
+          expectedRetirement: input.intent,
+        })
+        .bindings.find(
+          (candidate) => candidate.bindingKey === binding.bindingKey,
+        )?.protection === "eligible";
     if (!eligible) return { kind: "blocked", reason: "protection-changed" };
     const replacement = { ...input.intent, leaderEpoch: leaderEpoch! };
-    if (!isCurrent()) throw new Error("Telegram Workspace retirement adoption lost leader authority.");
-    if (!await input.store.replaceWorkspaceRetirementIntent(
-      input.intent,
-      replacement,
-      isCurrent,
-    )) return { kind: "blocked", reason: "commit-rejected" };
+    if (!isCurrent())
+      throw new Error(
+        "Telegram Workspace retirement adoption lost leader authority.",
+      );
+    if (
+      !(await input.store.replaceWorkspaceRetirementIntent(
+        input.intent,
+        replacement,
+        isCurrent,
+      ))
+    )
+      return { kind: "blocked", reason: "commit-rejected" };
     return { kind: "adopted", intent: replacement };
   });
 }
 
 function isTelegramWorkspaceDeletionConfirmedAbsent(error: unknown): boolean {
   if (!(error instanceof Error)) return false;
-  const status = "status" in error && typeof error.status === "number"
-    ? error.status : undefined;
-  if (status !== 400) return false;
-  const message = error.message.toLowerCase();
-  return message.includes("topic_id_invalid") ||
-    message.includes("message thread not found") ||
-    message.includes("thread not found") ||
-    message.includes("topic not found") ||
-    message.includes("topic deleted");
+  const status =
+    "status" in error && typeof error.status === "number"
+      ? error.status
+      : undefined;
+  return status === 400 && isTelegramTopicDeletedErrorMessage(error.message);
 }
 
 export type TelegramWorkspaceRetirementExecution =
@@ -898,9 +1172,7 @@ export type TelegramWorkspaceRetirementExecution =
     };
 
 export type TelegramWorkspaceRetirementAbsence =
-  | "absent"
-  | "present"
-  | "unknown";
+  "absent" | "present" | "unknown";
 
 function matchesTelegramWorkspaceRetirementFence(
   fence: TelegramWorkspaceRetirementFence,
@@ -918,27 +1190,51 @@ function matchesTelegramWorkspaceRetirementFence(
 }
 
 async function cancelRejectedTelegramWorkspaceRetirement(
-  input: Pick<Parameters<typeof executeTelegramWorkspaceRetirement>[0],
-    "store" | "admission" | "getLeaderEpoch" | "getProfileKey" | "isCurrent">,
+  input: Pick<
+    Parameters<typeof executeTelegramWorkspaceRetirement>[0],
+    "store" | "admission" | "getLeaderEpoch" | "getProfileKey" | "isCurrent"
+  >,
   retained: TelegramWorkspaceRetirementFence,
 ): Promise<Exclude<TelegramWorkspaceRetirementExecution, { kind: "retired" }>> {
   const epoch = input.getLeaderEpoch();
-  const isCurrent = () => epoch !== undefined && input.getLeaderEpoch() === epoch &&
-    input.getProfileKey() === retained.profileKey && input.isCurrent?.() !== false;
+  const isCurrent = () =>
+    epoch !== undefined &&
+    input.getLeaderEpoch() === epoch &&
+    input.getProfileKey() === retained.profileKey &&
+    input.isCurrent?.() !== false;
   if (!isCurrent()) return { kind: "retained", reason: "authority-changed" };
-  if (retained.phase !== "deletion-rejected" ||
-      (retained.destructiveKind ?? "pressure-retirement") !== "pressure-retirement") {
+  if (
+    retained.phase !== "deletion-rejected" ||
+    (retained.destructiveKind ?? "pressure-retirement") !==
+      "pressure-retirement"
+  ) {
     return { kind: "retained", reason: "fence-conflict" };
   }
   const owner = input.admission.getOwner();
-  const fence = retained.leaderEpoch === epoch && isDeepStrictEqual(retained.owner, owner)
-    ? retained : input.admission.adoptRetirementFence(retained, { owner, leaderEpoch: epoch! });
-  if (fence.phase !== "deletion-rejected") return { kind: "retained", reason: "fence-conflict" };
-  const bindingRetained = () => input.store.listWorkspaceBindings().some(binding =>
-    binding.bindingKey === fence.bindingKey && binding.slot === fence.slot && sameTarget(binding.target, fence.target));
+  const fence =
+    retained.leaderEpoch === epoch && isDeepStrictEqual(retained.owner, owner)
+      ? retained
+      : input.admission.adoptRetirementFence(retained, {
+          owner,
+          leaderEpoch: epoch!,
+        });
+  if (fence.phase !== "deletion-rejected")
+    return { kind: "retained", reason: "fence-conflict" };
+  const bindingRetained = () =>
+    input.store
+      .listWorkspaceBindings()
+      .some(
+        (binding) =>
+          binding.bindingKey === fence.bindingKey &&
+          binding.slot === fence.slot &&
+          sameTarget(binding.target, fence.target),
+      );
   const intents = input.store.listWorkspaceRetirementIntents();
-  if (!bindingRetained() || intents.length > 1 ||
-      (intents[0] && !matchesTelegramWorkspaceRetirementFence(fence, intents[0]))) {
+  if (
+    !bindingRetained() ||
+    intents.length > 1 ||
+    (intents[0] && !matchesTelegramWorkspaceRetirementFence(fence, intents[0]))
+  ) {
     return { kind: "retained", reason: "stale-intent" };
   }
   if (intents[0] && !input.store.removeWorkspaceRetirementIntent(intents[0])) {
@@ -948,12 +1244,17 @@ async function cancelRejectedTelegramWorkspaceRetirement(
   // in-memory withdrawal. The rejection fence protects both commit prefixes.
   await input.store.persist();
   if (!isCurrent()) return { kind: "retained", reason: "authority-changed" };
-  if (input.store.listWorkspaceRetirementIntents().length || !bindingRetained()) {
+  if (
+    input.store.listWorkspaceRetirementIntents().length ||
+    !bindingRetained()
+  ) {
     return { kind: "retained", reason: "commit-rejected" };
   }
-  try { input.admission.completeRejectedRetirementFence(fence); }
-  catch {
-    if (input.admission.read().fence) return { kind: "retained", reason: "fence-release-unconfirmed" };
+  try {
+    input.admission.completeRejectedRetirementFence(fence);
+  } catch {
+    if (input.admission.read().fence)
+      return { kind: "retained", reason: "fence-release-unconfirmed" };
   }
   return { kind: "cancelled", reason: "delete-rejected" };
 }
@@ -1005,7 +1306,10 @@ export async function executeTelegramWorkspaceRetirement(input: {
       input.getProfileKey() === input.intent.profileKey &&
       input.isCurrent?.() !== false;
     if (!isCurrent()) return { kind: "retained", reason: "authority-changed" };
-    if (!input.intent.binding.slot || !/^[A-Z]$/u.test(input.intent.binding.slot)) {
+    if (
+      !input.intent.binding.slot ||
+      !/^[A-Z]$/u.test(input.intent.binding.slot)
+    ) {
       return { kind: "retained", reason: "stale-intent" };
     }
     const owner = input.admission.getOwner();
@@ -1014,7 +1318,10 @@ export async function executeTelegramWorkspaceRetirement(input: {
       return { kind: "retained", reason: "fence-conflict" };
     }
     let fence: TelegramWorkspaceRetirementFence | undefined = storedFence;
-    if (fence && !matchesTelegramWorkspaceRetirementFence(fence, input.intent)) {
+    if (
+      fence &&
+      !matchesTelegramWorkspaceRetirementFence(fence, input.intent)
+    ) {
       return { kind: "retained", reason: "fence-conflict" };
     }
     if (
@@ -1029,15 +1336,24 @@ export async function executeTelegramWorkspaceRetirement(input: {
       });
     }
     if (fence?.phase === "deletion-rejected") {
-      return cancelRejectedTelegramWorkspaceRetirement({ ...input, isCurrent }, fence);
+      return cancelRejectedTelegramWorkspaceRetirement(
+        { ...input, isCurrent },
+        fence,
+      );
     }
-    const intent = input.store.listWorkspaceRetirementIntents().find((candidate) =>
-      isDeepStrictEqual(candidate, input.intent),
-    );
-    const binding = input.store.listWorkspaceBindings().find((candidate) =>
-      candidate.bindingKey === input.intent.binding.bindingKey,
-    );
-    if (!intent || !binding || !isDeepStrictEqual(binding, input.intent.binding)) {
+    const intent = input.store
+      .listWorkspaceRetirementIntents()
+      .find((candidate) => isDeepStrictEqual(candidate, input.intent));
+    const binding = input.store
+      .listWorkspaceBindings()
+      .find(
+        (candidate) => candidate.bindingKey === input.intent.binding.bindingKey,
+      );
+    if (
+      !intent ||
+      !binding ||
+      !isDeepStrictEqual(binding, input.intent.binding)
+    ) {
       if (!intent && !binding && fence?.phase === "commit-ready") {
         try {
           input.admission.completeRetirementFence(fence);
@@ -1060,12 +1376,15 @@ export async function executeTelegramWorkspaceRetirement(input: {
       // publication while this stale local projection is removed.
       input.store.markStaleByTarget(binding.target, "deleted");
     }
-    const eligible = () => input.store.captureWorkspaceSlotOccupancy(
-      input.getExternalProtection,
-      { expectedRetirement: input.intent },
-    ).bindings.find((candidate) =>
-      candidate.bindingKey === input.intent.binding.bindingKey,
-    )?.protection === "eligible";
+    const eligible = () =>
+      input.store
+        .captureWorkspaceSlotOccupancy(input.getExternalProtection, {
+          expectedRetirement: input.intent,
+        })
+        .bindings.find(
+          (candidate) =>
+            candidate.bindingKey === input.intent.binding.bindingKey,
+        )?.protection === "eligible";
     if (!eligible()) return { kind: "retained", reason: "protection-changed" };
     if (!fence) {
       const acquired = input.admission.acquireRetirementFence({
@@ -1112,10 +1431,20 @@ export async function executeTelegramWorkspaceRetirement(input: {
       } catch (error) {
         if (!isTelegramWorkspaceDeletionConfirmedAbsent(error)) {
           const target = getTelegramApiErrorRequestTarget(error);
-          if (target && sameTarget(target, binding.target) && isTelegramApiRequestRejected(error, "deleteForumTopic")) {
+          if (
+            target &&
+            sameTarget(target, binding.target) &&
+            isTelegramApiRequestRejected(error, "deleteForumTopic")
+          ) {
             fence = input.admission.confirmRetirementRejection(fence);
-            const cancellation = await cancelRejectedTelegramWorkspaceRetirement({ ...input, isCurrent }, fence);
-            return cancellation.kind === "cancelled" ? { kind: "retained", reason: "delete-rejected" } : cancellation;
+            const cancellation =
+              await cancelRejectedTelegramWorkspaceRetirement(
+                { ...input, isCurrent },
+                fence,
+              );
+            return cancellation.kind === "cancelled"
+              ? { kind: "retained", reason: "delete-rejected" }
+              : cancellation;
           }
           return { kind: "retained", reason: "delete-unconfirmed" };
         }
@@ -1133,7 +1462,9 @@ export async function executeTelegramWorkspaceRetirement(input: {
       input.store.markStaleByTarget(binding.target, "deleted");
     }
     if (!eligible()) return { kind: "retained", reason: "protection-changed" };
-    if (!await input.store.commitWorkspaceRetirement(input.intent, isCurrent)) {
+    if (
+      !(await input.store.commitWorkspaceRetirement(input.intent, isCurrent))
+    ) {
       return { kind: "retained", reason: "commit-rejected" };
     }
     try {
@@ -1213,7 +1544,10 @@ export async function prepareTelegramWorkspaceRetirement(
     deps.getLeaderEpoch() === leaderEpoch &&
     deps.getProfileKey() === profileKey &&
     deps.isCurrent?.() !== false;
-  if (!isCurrent()) throw new Error("Telegram Workspace retirement requires current leader authority.");
+  if (!isCurrent())
+    throw new Error(
+      "Telegram Workspace retirement requires current leader authority.",
+    );
 
   const existing = deps.store.listWorkspaceRetirementIntents();
   if (existing.length > 1) {
@@ -1221,27 +1555,30 @@ export async function prepareTelegramWorkspaceRetirement(
   }
   if (existing.length === 1) {
     const intent = existing[0]!;
-    const binding = deps.store.listWorkspaceBindings().find((candidate) =>
-      candidate.bindingKey === intent.binding.bindingKey,
-    );
+    const binding = deps.store
+      .listWorkspaceBindings()
+      .find((candidate) => candidate.bindingKey === intent.binding.bindingKey);
     const snapshot = deps.store.captureWorkspaceSlotOccupancy(
       deps.getExternalProtection,
       { expectedRetirement: intent },
     );
-    const candidate = snapshot.bindings.find((entry) =>
-      entry.bindingKey === intent.binding.bindingKey,
+    const candidate = snapshot.bindings.find(
+      (entry) => entry.bindingKey === intent.binding.bindingKey,
     );
     if (
       intent.profileKey !== profileKey ||
       intent.leaderEpoch !== leaderEpoch ||
-      !binding || !isDeepStrictEqual(binding, intent.binding) ||
+      !binding ||
+      !isDeepStrictEqual(binding, intent.binding) ||
       candidate?.protection !== "eligible"
     ) {
       return { kind: "blocked", reason: "stale-intent" };
     }
-    if (!isCurrent()) throw new Error("Telegram Workspace retirement lost leader authority.");
+    if (!isCurrent())
+      throw new Error("Telegram Workspace retirement lost leader authority.");
     await deps.store.persist();
-    if (!isCurrent()) throw new Error("Telegram Workspace retirement lost leader authority.");
+    if (!isCurrent())
+      throw new Error("Telegram Workspace retirement lost leader authority.");
     return { kind: "ready", intent };
   }
 
@@ -1256,9 +1593,9 @@ export async function prepareTelegramWorkspaceRetirement(
   );
   if (selection.kind !== "candidate") return selection;
   const selected = selection.candidate;
-  const binding = deps.store.listWorkspaceBindings().find((candidate) =>
-    candidate.bindingKey === selected.bindingKey,
-  );
+  const binding = deps.store
+    .listWorkspaceBindings()
+    .find((candidate) => candidate.bindingKey === selected.bindingKey);
   if (
     !binding?.slot ||
     binding.slot.toLowerCase() !== selected.slot ||
@@ -1274,21 +1611,25 @@ export async function prepareTelegramWorkspaceRetirement(
     leaderEpoch: leaderEpoch!,
     requestedAtMs: nowMs,
   };
-  if (!isCurrent()) throw new Error("Telegram Workspace retirement lost leader authority.");
+  if (!isCurrent())
+    throw new Error("Telegram Workspace retirement lost leader authority.");
   if (!deps.store.upsertWorkspaceRetirementIntent(intent)) {
     return { kind: "blocked", reason: "state-changed" };
   }
-  const rechecked = deps.store.captureWorkspaceSlotOccupancy(
-    deps.getExternalProtection,
-    { expectedRetirement: intent },
-  ).bindings.find((candidate) => candidate.bindingKey === binding.bindingKey);
+  const rechecked = deps.store
+    .captureWorkspaceSlotOccupancy(deps.getExternalProtection, {
+      expectedRetirement: intent,
+    })
+    .bindings.find((candidate) => candidate.bindingKey === binding.bindingKey);
   if (rechecked?.protection !== "eligible" || !isCurrent()) {
     deps.store.removeWorkspaceRetirementIntent(intent);
-    if (!isCurrent()) throw new Error("Telegram Workspace retirement lost leader authority.");
+    if (!isCurrent())
+      throw new Error("Telegram Workspace retirement lost leader authority.");
     return { kind: "blocked", reason: "state-changed" };
   }
   await deps.store.persist();
-  if (!isCurrent()) throw new Error("Telegram Workspace retirement lost leader authority.");
+  if (!isCurrent())
+    throw new Error("Telegram Workspace retirement lost leader authority.");
   return { kind: "ready", intent };
 }
 
@@ -1302,10 +1643,13 @@ export type TelegramWorkspaceRetirementLifecycleResult =
     };
 
 export async function runTelegramWorkspaceRetirementLifecycle(input: {
-  store: TelegramWorkspaceRetirementPreparationDeps["store"] & Pick<
-    TelegramTopicTargetStore,
-    "replaceWorkspaceRetirementIntent" | "commitWorkspaceRetirement" | "markStaleByTarget"
-  >;
+  store: TelegramWorkspaceRetirementPreparationDeps["store"] &
+    Pick<
+      TelegramTopicTargetStore,
+      | "replaceWorkspaceRetirementIntent"
+      | "commitWorkspaceRetirement"
+      | "markStaleByTarget"
+    >;
   getExternalProtection: (
     binding: TelegramWorkspaceThreadBinding,
   ) => TelegramWorkspaceExternalProtectionEvidence;
@@ -1314,7 +1658,9 @@ export async function runTelegramWorkspaceRetirementLifecycle(input: {
   isCurrent?: () => boolean;
   getNowMs?: () => number;
   runExclusive: <T>(operation: () => Promise<T>) => Promise<T>;
-  admission: Parameters<typeof executeTelegramWorkspaceRetirement>[0]["admission"];
+  admission: Parameters<
+    typeof executeTelegramWorkspaceRetirement
+  >[0]["admission"];
   deleteForumTopic: Parameters<
     typeof executeTelegramWorkspaceRetirement
   >[0]["deleteForumTopic"];
@@ -1324,51 +1670,101 @@ export async function runTelegramWorkspaceRetirementLifecycle(input: {
 }): Promise<TelegramWorkspaceRetirementLifecycleResult> {
   let intent = input.store.listWorkspaceRetirementIntents()[0];
   const retainedFence = input.admission.read().fence;
-  if (retainedFence && isTelegramWorkspaceRetirementFence(retainedFence) &&
-      retainedFence.phase === "deletion-rejected") {
-    return input.runExclusive(() => cancelRejectedTelegramWorkspaceRetirement(input, retainedFence));
+  if (
+    retainedFence &&
+    isTelegramWorkspaceRetirementFence(retainedFence) &&
+    retainedFence.phase === "deletion-rejected"
+  ) {
+    return input.runExclusive(() =>
+      cancelRejectedTelegramWorkspaceRetirement(input, retainedFence),
+    );
   }
-  if (!intent && retainedFence && isTelegramWorkspaceRetirementFence(retainedFence) &&
-      (retainedFence.destructiveKind ?? "pressure-retirement") === "pressure-retirement" &&
-      retainedFence.phase === "commit-ready") {
+  if (
+    !intent &&
+    retainedFence &&
+    isTelegramWorkspaceRetirementFence(retainedFence) &&
+    (retainedFence.destructiveKind ?? "pressure-retirement") ===
+      "pressure-retirement" &&
+    retainedFence.phase === "commit-ready"
+  ) {
     return input.runExclusive(async () => {
       const epoch = input.getLeaderEpoch();
-      if (epoch === undefined || input.getProfileKey() !== retainedFence.profileKey ||
-          input.isCurrent?.() === false) return { kind: "retained", reason: "authority-changed" };
-      if (input.store.listWorkspaceRetirementIntents().length ||
-          input.store.listWorkspaceBindings().some((binding) =>
-            binding.bindingKey === retainedFence.bindingKey)) {
+      if (
+        epoch === undefined ||
+        input.getProfileKey() !== retainedFence.profileKey ||
+        input.isCurrent?.() === false
+      )
+        return { kind: "retained", reason: "authority-changed" };
+      if (
+        input.store.listWorkspaceRetirementIntents().length ||
+        input.store
+          .listWorkspaceBindings()
+          .some((binding) => binding.bindingKey === retainedFence.bindingKey)
+      ) {
         return { kind: "retained", reason: "stale-intent" };
       }
       const owner = input.admission.getOwner();
-      const fence = retainedFence.leaderEpoch === epoch &&
-        isDeepStrictEqual(retainedFence.owner, owner) ? retainedFence :
-        input.admission.adoptRetirementFence(retainedFence, { owner, leaderEpoch: epoch });
+      const fence =
+        retainedFence.leaderEpoch === epoch &&
+        isDeepStrictEqual(retainedFence.owner, owner)
+          ? retainedFence
+          : input.admission.adoptRetirementFence(retainedFence, {
+              owner,
+              leaderEpoch: epoch,
+            });
       input.admission.completeRetirementFence(fence);
-      return { kind: "retired", bindingKey: fence.bindingKey, slot: fence.slot };
+      return {
+        kind: "retired",
+        bindingKey: fence.bindingKey,
+        slot: fence.slot,
+      };
     });
   }
   if (intent) {
-    if (retainedFence && isTelegramWorkspaceRetirementFence(retainedFence) &&
-        retainedFence.phase === "commit-ready" &&
-        matchesTelegramWorkspaceRetirementFence(retainedFence, intent)) {
+    if (
+      retainedFence &&
+      isTelegramWorkspaceRetirementFence(retainedFence) &&
+      retainedFence.phase === "commit-ready" &&
+      matchesTelegramWorkspaceRetirementFence(retainedFence, intent)
+    ) {
       const resumed = await input.runExclusive(async () => {
         const epoch = input.getLeaderEpoch();
         const profileKey = input.getProfileKey();
-        const isCurrent = () => epoch !== undefined && input.getLeaderEpoch() === epoch &&
-          input.getProfileKey() === profileKey && input.isCurrent?.() !== false;
+        const isCurrent = () =>
+          epoch !== undefined &&
+          input.getLeaderEpoch() === epoch &&
+          input.getProfileKey() === profileKey &&
+          input.isCurrent?.() !== false;
         if (!isCurrent() || intent!.profileKey !== profileKey) return undefined;
         const intents = input.store.listWorkspaceRetirementIntents();
-        const binding = input.store.listWorkspaceBindings().find(candidate =>
-          candidate.bindingKey === intent!.binding.bindingKey);
-        if (intents.length !== 1 || !isDeepStrictEqual(intents[0], intent) ||
-            !binding || !isDeepStrictEqual(binding, intent.binding)) return undefined;
+        const binding = input.store
+          .listWorkspaceBindings()
+          .find(
+            (candidate) => candidate.bindingKey === intent!.binding.bindingKey,
+          );
+        if (
+          intents.length !== 1 ||
+          !isDeepStrictEqual(intents[0], intent) ||
+          !binding ||
+          !isDeepStrictEqual(binding, intent.binding)
+        )
+          return undefined;
         if (intent!.leaderEpoch === epoch) return intent;
         const replacement = { ...intent!, leaderEpoch: epoch! };
-        return await input.store.replaceWorkspaceRetirementIntent(intent!, replacement, isCurrent)
-          ? replacement : undefined;
+        return (await input.store.replaceWorkspaceRetirementIntent(
+          intent!,
+          replacement,
+          isCurrent,
+        ))
+          ? replacement
+          : undefined;
       });
-      if (!resumed) return { kind: "blocked", stage: "adoption", reason: "commit-rejected" };
+      if (!resumed)
+        return {
+          kind: "blocked",
+          stage: "adoption",
+          reason: "commit-rejected",
+        };
       intent = resumed;
     } else {
       const adoption = await adoptTelegramWorkspaceRetirementIntent({
@@ -1386,19 +1782,21 @@ export async function runTelegramWorkspaceRetirementLifecycle(input: {
       intent = adoption.intent;
     }
   } else {
-    const preparation = await prepareTelegramWorkspaceRetirement(
-      {
-        store: input.store,
-        getExternalProtection: input.getExternalProtection,
-        getLeaderEpoch: input.getLeaderEpoch,
-        getProfileKey: input.getProfileKey,
-        isCurrent: input.isCurrent,
-        getNowMs: input.getNowMs,
-      },
-    );
+    const preparation = await prepareTelegramWorkspaceRetirement({
+      store: input.store,
+      getExternalProtection: input.getExternalProtection,
+      getLeaderEpoch: input.getLeaderEpoch,
+      getProfileKey: input.getProfileKey,
+      isCurrent: input.isCurrent,
+      getNowMs: input.getNowMs,
+    });
     if (preparation.kind === "not-needed") return preparation;
     if (preparation.kind === "blocked") {
-      return { kind: "blocked", stage: "preparation", reason: preparation.reason };
+      return {
+        kind: "blocked",
+        stage: "preparation",
+        reason: preparation.reason,
+      };
     }
     intent = preparation.intent;
   }
@@ -1416,13 +1814,17 @@ export async function runTelegramWorkspaceRetirementLifecycle(input: {
   });
 }
 
-export type TelegramWorkspaceCapacityRunner = <T>(operation: () => Promise<T>) => Promise<T>;
+export type TelegramWorkspaceCapacityRunner = <T>(
+  operation: () => Promise<T>,
+) => Promise<T>;
 
 export interface TelegramWorkspaceSlotRotationPorts extends TelegramWorkspaceOperationGate {
   getAdmission: () => TelegramWorkspaceAdmissionLedger | undefined;
   deleteThread: TelegramWorkspaceThreadDeletionTransport;
-  pruneJournalEvidence?: (binding: TelegramWorkspaceThreadBinding,
-    isCurrent: () => boolean) => Promise<TelegramWorkspaceJournalPruneResult>;
+  pruneJournalEvidence?: (
+    binding: TelegramWorkspaceThreadBinding,
+    isCurrent: () => boolean,
+  ) => Promise<TelegramWorkspaceJournalPruneResult>;
   reclaimDeadOwnerQueuedWork?: (
     binding: TelegramWorkspaceThreadBinding,
     isCurrent: () => boolean,
@@ -1430,122 +1832,222 @@ export interface TelegramWorkspaceSlotRotationPorts extends TelegramWorkspaceOpe
 }
 
 /** Retry allocation once, only after the failed operation released all ordinary leases. */
-export function createTelegramWorkspaceSlotRotation(input: TelegramWorkspaceSlotRotationPorts & {
-  store: TelegramTopicTargetStore;
-  getLeaderEpoch: () => number | string | undefined;
-  getExternalProtection: (binding: TelegramWorkspaceThreadBinding) => TelegramWorkspaceExternalProtectionEvidence;
-  recordEvent: (message: string, details: Record<string, unknown>) => void;
-}): TelegramWorkspaceCapacityRunner {
+export function createTelegramWorkspaceSlotRotation(
+  input: TelegramWorkspaceSlotRotationPorts & {
+    store: TelegramTopicTargetStore;
+    getLeaderEpoch: () => number | string | undefined;
+    getExternalProtection: (
+      binding: TelegramWorkspaceThreadBinding,
+    ) => TelegramWorkspaceExternalProtectionEvidence;
+    recordEvent: (message: string, details: Record<string, unknown>) => void;
+  },
+): TelegramWorkspaceCapacityRunner {
   const requests = createTelegramWorkspaceOperationGate();
   return async (operation) => {
     const admission = input.getAdmission();
     const epoch = input.getLeaderEpoch();
     if (!admission || epoch === undefined) return operation();
     const profileKey = admission.getProfileKey();
-    const isCurrent = () => input.getLeaderEpoch() === epoch &&
+    const isCurrent = () =>
+      input.getLeaderEpoch() === epoch &&
       input.getAdmission()?.getProfileKey() === profileKey;
     return requests.runExclusive(async () => {
-      if (!isCurrent()) throw new Error("Telegram Workspace allocation lost leader authority.");
+      if (!isCurrent())
+        throw new Error("Telegram Workspace allocation lost leader authority.");
       const rotate = async () => {
         const result = await input.runExclusive(async () => {
-          if (!isCurrent()) throw new Error("Telegram Workspace rotation lost leader authority.");
+          if (!isCurrent())
+            throw new Error(
+              "Telegram Workspace rotation lost leader authority.",
+            );
           await input.store.load();
-          if (!isCurrent()) throw new Error("Telegram Workspace rotation lost leader authority.");
+          if (!isCurrent())
+            throw new Error(
+              "Telegram Workspace rotation lost leader authority.",
+            );
           return runTelegramWorkspaceRetirementLifecycle({
-            store: input.store, admission, getExternalProtection: input.getExternalProtection,
-            getLeaderEpoch: input.getLeaderEpoch, getProfileKey: () => profileKey, isCurrent,
+            store: input.store,
+            admission,
+            getExternalProtection: input.getExternalProtection,
+            getLeaderEpoch: input.getLeaderEpoch,
+            getProfileKey: () => profileKey,
+            isCurrent,
             // This entire lifecycle already owns the shared gate, without an admission lease.
             runExclusive: async (action) => action(),
             deleteForumTopic(permit, body) {
               return input.deleteThread(() => {
                 const fence = admission.read().fence;
-                if (!isCurrent() || !fence || !isTelegramWorkspaceRetirementFence(fence) ||
-                    (fence.destructiveKind ?? "pressure-retirement") !== "pressure-retirement" ||
-                    (permit.destructiveKind ?? "pressure-retirement") !== "pressure-retirement" ||
-                    fence.phase !== "deletion-issued" ||
-                    !isDeepStrictEqual(fence.owner, admission.getOwner()) ||
-                    fence.profileKey !== permit.profileKey || fence.leaderEpoch !== permit.leaderEpoch ||
-                    fence.operationId !== permit.operationId || fence.retirementIntentId !== permit.retirementIntentId ||
-                    fence.bindingKey !== permit.bindingKey || fence.slot !== permit.slot ||
-                    fence.deletionIssuedAtMs !== permit.issuedAtMs ||
-                    !sameTarget(fence.target, permit.target) ||
-                    body.chat_id !== permit.target.chatId || body.message_thread_id !== permit.target.threadId) {
-                  throw new Error("Telegram Workspace deletion permit is stale.");
+                if (
+                  !isCurrent() ||
+                  !fence ||
+                  !isTelegramWorkspaceRetirementFence(fence) ||
+                  (fence.destructiveKind ?? "pressure-retirement") !==
+                    "pressure-retirement" ||
+                  (permit.destructiveKind ?? "pressure-retirement") !==
+                    "pressure-retirement" ||
+                  fence.phase !== "deletion-issued" ||
+                  !isDeepStrictEqual(fence.owner, admission.getOwner()) ||
+                  fence.profileKey !== permit.profileKey ||
+                  fence.leaderEpoch !== permit.leaderEpoch ||
+                  fence.operationId !== permit.operationId ||
+                  fence.retirementIntentId !== permit.retirementIntentId ||
+                  fence.bindingKey !== permit.bindingKey ||
+                  fence.slot !== permit.slot ||
+                  fence.deletionIssuedAtMs !== permit.issuedAtMs ||
+                  !sameTarget(fence.target, permit.target) ||
+                  body.chat_id !== permit.target.chatId ||
+                  body.message_thread_id !== permit.target.threadId
+                ) {
+                  throw new Error(
+                    "Telegram Workspace deletion permit is stale.",
+                  );
                 }
                 return { ...permit.target };
               });
             },
           });
         });
-        if (result.kind !== "retired" && result.kind !== "not-needed" && result.kind !== "cancelled") {
-          throw new Error(`Telegram Workspace slots A-Z are unavailable; rotation blocked (${result.reason}).`);
+        if (
+          result.kind !== "retired" &&
+          result.kind !== "not-needed" &&
+          result.kind !== "cancelled"
+        ) {
+          throw new Error(
+            `Telegram Workspace slots A-Z are unavailable; rotation blocked (${result.reason}).`,
+          );
         }
         if (result.kind === "retired") {
-          try { input.recordEvent("Telegram Workspace slot rotated.", { slot: result.slot }); }
-          catch { /* Diagnostics cannot turn completed retirement into another attempt. */ }
+          try {
+            input.recordEvent("Telegram Workspace slot rotated.", {
+              slot: result.slot,
+            });
+          } catch {
+            /* Diagnostics cannot turn completed retirement into another attempt. */
+          }
         }
-        if (!isCurrent()) throw new Error("Telegram Workspace rotation lost leader authority.");
+        if (!isCurrent())
+          throw new Error("Telegram Workspace rotation lost leader authority.");
         return result;
       };
       const pending = await input.runExclusive(async () => {
         await input.store.load();
-        if (!isCurrent()) throw new Error("Telegram Workspace allocation lost leader authority.");
+        if (!isCurrent())
+          throw new Error(
+            "Telegram Workspace allocation lost leader authority.",
+          );
         return input.store.listWorkspaceRetirementIntents().length > 0;
       });
       const fence = admission.read().fence;
-      if (pending || (fence && isTelegramWorkspaceRetirementFence(fence) &&
-          (fence.destructiveKind ?? "pressure-retirement") === "pressure-retirement")) {
+      if (
+        pending ||
+        (fence &&
+          isTelegramWorkspaceRetirementFence(fence) &&
+          (fence.destructiveKind ?? "pressure-retirement") ===
+            "pressure-retirement")
+      ) {
         const recovered = await rotate();
         if (recovered.kind !== "cancelled") return operation();
       }
-      try { return await operation(); }
-      catch (error) {
-        if (!(error instanceof TelegramWorkspaceSlotUnavailableError)) throw error;
+      try {
+        return await operation();
+      } catch (error) {
+        if (!(error instanceof TelegramWorkspaceSlotUnavailableError))
+          throw error;
         if (input.pruneJournalEvidence || input.reclaimDeadOwnerQueuedWork) {
           const candidates = await input.runExclusive(async () => {
             await input.store.load();
-            if (!isCurrent()) throw new Error("Telegram Workspace reclamation lost leader authority.");
-            const snapshot = input.store.captureWorkspaceSlotOccupancy(input.getExternalProtection);
-            const allocation = planTelegramWorkspaceSlotAllocation({ ...snapshot, nowMs: Date.now() });
-            if (allocation.kind === "free" || (allocation.kind === "blocked" && allocation.reason !== "protected-capacity")) return [];
-            if (allocation.kind === "reclaim" && !input.pruneJournalEvidence) return [];
-            return input.store.listWorkspaceBindings().filter((binding) =>
-              (allocation.kind !== "reclaim" || binding.bindingKey === allocation.candidate.bindingKey) &&
-              typeof binding.inactiveSinceMs === "number" &&
-              Number.isFinite(binding.inactiveSinceMs) &&
-              binding.inactiveSinceMs >= 0,
-            ).sort((left, right) =>
-              left.inactiveSinceMs! - right.inactiveSinceMs! ||
-              (left.slot ?? "").localeCompare(right.slot ?? ""),
+            if (!isCurrent())
+              throw new Error(
+                "Telegram Workspace reclamation lost leader authority.",
+              );
+            const snapshot = input.store.captureWorkspaceSlotOccupancy(
+              input.getExternalProtection,
             );
+            const allocation = planTelegramWorkspaceSlotAllocation({
+              ...snapshot,
+              nowMs: Date.now(),
+            });
+            if (
+              allocation.kind === "free" ||
+              (allocation.kind === "blocked" &&
+                allocation.reason !== "protected-capacity")
+            )
+              return [];
+            if (allocation.kind === "reclaim" && !input.pruneJournalEvidence)
+              return [];
+            return input.store
+              .listWorkspaceBindings()
+              .filter(
+                (binding) =>
+                  (allocation.kind !== "reclaim" ||
+                    binding.bindingKey === allocation.candidate.bindingKey) &&
+                  typeof binding.inactiveSinceMs === "number" &&
+                  Number.isFinite(binding.inactiveSinceMs) &&
+                  binding.inactiveSinceMs >= 0,
+              )
+              .sort(
+                (left, right) =>
+                  left.inactiveSinceMs! - right.inactiveSinceMs! ||
+                  (left.slot ?? "").localeCompare(right.slot ?? ""),
+              );
           });
           for (const original of candidates) {
             let binding = original;
-            if (input.pruneJournalEvidence && ((binding.journalBindingKeys?.length ?? 0) + (binding.journalSources?.length ?? 0) > 0)) {
-              const pruned = await input.pruneJournalEvidence(binding, isCurrent);
-              if (!isCurrent()) throw new Error("Telegram Workspace pruning lost leader authority.");
+            if (
+              input.pruneJournalEvidence &&
+              (binding.journalBindingKeys?.length ?? 0) +
+                (binding.journalSources?.length ?? 0) >
+                0
+            ) {
+              const pruned = await input.pruneJournalEvidence(
+                binding,
+                isCurrent,
+              );
+              if (!isCurrent())
+                throw new Error(
+                  "Telegram Workspace pruning lost leader authority.",
+                );
               if (pruned.kind !== "committed") continue;
               binding = pruned.binding;
-              const removed = pruned.removedKeys.length + (pruned.removedSources?.length ?? 0);
+              const removed =
+                pruned.removedKeys.length +
+                (pruned.removedSources?.length ?? 0);
               if (removed > 0) {
-                try { input.recordEvent("Telegram Workspace journal evidence pruned.", { slot: binding.slot, removed }); }
-                catch { /* Diagnostics cannot revoke a published metadata subset. */ }
+                try {
+                  input.recordEvent(
+                    "Telegram Workspace journal evidence pruned.",
+                    { slot: binding.slot, removed },
+                  );
+                } catch {
+                  /* Diagnostics cannot revoke a published metadata subset. */
+                }
               }
             }
             if (!input.reclaimDeadOwnerQueuedWork) continue;
             const evidence = input.getExternalProtection(binding);
-            if (evidence.liveOwner !== "clear" ||
-                evidence.acceptedWork !== "protected" ||
-                evidence.deliveryAuthority !== "clear") continue;
-            const reclaimed = await input.reclaimDeadOwnerQueuedWork(binding, isCurrent);
+            if (
+              evidence.liveOwner !== "clear" ||
+              evidence.acceptedWork !== "protected" ||
+              evidence.deliveryAuthority !== "clear"
+            )
+              continue;
+            const reclaimed = await input.reclaimDeadOwnerQueuedWork(
+              binding,
+              isCurrent,
+            );
             if (reclaimed.kind === "recovered") {
               try {
-                input.recordEvent("Telegram Workspace dead-owner queue reclaimed.", {
-                  slot: binding.slot,
-                  receipts: reclaimed.receipts,
-                  updateCount: reclaimed.updateIds.length,
-                });
-              } catch { /* Diagnostics cannot revoke journal-owned recovery. */ }
+                input.recordEvent(
+                  "Telegram Workspace dead-owner queue reclaimed.",
+                  {
+                    slot: binding.slot,
+                    receipts: reclaimed.receipts,
+                    updateCount: reclaimed.updateIds.length,
+                  },
+                );
+              } catch {
+                /* Diagnostics cannot revoke journal-owned recovery. */
+              }
               break;
             }
           }