@llblab/pi-kit 0.35.0 → 0.35.2

package/node_modules/@llblab/pi-telegram/lib/routing.ts

@@ -1568,6 +1568,13 @@ export interface TelegramInboundRouteRuntimeDeps<
     requiredJournalBindingKeys: readonly string[],
     ownInputs?: readonly Threads.TelegramTemporaryThreadInput[],
   ) => readonly number[] | undefined;
+  /** Explicit cleanup-only recovery; never called by a read-only protection observer. */
+  recoverTemporaryThreadDeadQueueOwners?: (
+    target: Queue.TelegramQueueTarget,
+    requiredJournalBindingKeys: readonly string[],
+    ownInputs: readonly Threads.TelegramTemporaryThreadInput[],
+    isCurrent: () => boolean,
+  ) => number;
   /** Quiet period after the last cancelled input before one cleanup attempt; defaults to 0 ms. */
   temporaryThreadCleanupDelayMs?: number;
   /** Live-rebind cleanup attempt pacing; the bounded window ends in `not-issued`, never a time-based deletion. */
@@ -6837,6 +6844,93 @@ export function createTelegramInboundRouteRuntime<
     }
     await promptEnqueue(messages, ctx);
   };
+  /** Local menu acceptance owns a one-shot effect; source removal and cleanup precede its release, never its replay. */
+  const stageTemporaryRerouteMenu = async (
+    pending: PendingUnboundReroute,
+    command: Commands.ParsedTelegramCommand,
+    messages: TMessage[],
+    ctx: TContext,
+    assertRecipientCurrent: () => void,
+    completion: NonNullable<ReturnType<typeof Updates.prepareTelegramDeferredSourceCompletion>>,
+  ): Promise<(() => Promise<void>) | undefined> => {
+    const original = pending.messages[0];
+    const cap = captureTemporaryThreadAuthority(ctx);
+    const temporary = pending.temporaryThread ?? findCreatedTemporaryThread(pending.sourceTarget);
+    if (!cap?.isCurrent() || !temporary) return undefined;
+    let accept!: (value: boolean) => void, resume!: (value: boolean) => void;
+    const accepted = new Promise<boolean>(resolve => { accept = resolve; });
+    const released = new Promise<boolean>(resolve => { resume = resolve; });
+    const admission: Commands.TelegramSelectedCommandAdmission = {
+      assertSourceCurrent() {
+        if (!completion.isCurrent()) throw new Error("Rerouted menu source authority changed.");
+      },
+      assertRecipientCurrent,
+      reportCompleted() {
+        const result = completion.reportCompleted();
+        accept(result);
+        return result;
+      },
+      async beforeEffects() {
+        if (!(await released)) throw new Error("Rerouted menu execution was not released.");
+      },
+    };
+    const prepare = command.name === "start" ? commandHandler.prepareSelectedStartCommand
+      : command.name === "help" ? commandHandler.prepareSelectedHelpCommand : commandHandler.prepareSelectedMenuCommand;
+    const dispatch = prepare(command, messages, ctx, admission);
+    if (!dispatch) return undefined;
+    const execution = dispatch().catch(error => {
+      deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-menu-execution" });
+      return false;
+    });
+    if (!(await Promise.race([accepted, execution.then(() => false)]))) {
+      resume(false);
+      await execution;
+      return undefined;
+    }
+    return async () => {
+      let allowEffects = false;
+      try {
+        const confirmed = await new Promise<boolean>(resolve => {
+          let done = false, unsubscribe: (() => void) | undefined;
+          const signal = Updates.getTelegramUpdateExecutionFence(original)?.signal;
+          const finish = (result: boolean) => {
+            if (done) return;
+            done = true;
+            clearTimeout(timer);
+            unsubscribe?.();
+            signal?.removeEventListener("abort", abort);
+            resolve(result);
+          };
+          const abort = () => finish(false);
+          const observe = () => {
+            if (!cap.isCurrent() || !completion.isCurrent()) finish(false);
+            else if (completion.inspectCompletion()) finish(true);
+          };
+          const timer = setTimeout(abort, deps.liveRebindCommandCompletionTimeoutMs ?? 8_000);
+          timer.unref?.();
+          unsubscribe = Updates.subscribeTelegramDeferredSourceCompletion(original, observe);
+          signal?.addEventListener("abort", abort, { once: true });
+          if (signal?.aborted) abort(); else observe();
+        });
+        if (!confirmed) throw new Error("Rerouted menu source removal is unconfirmed; execution remains suppressed.");
+        assertRecipientCurrent();
+        cancelTemporaryThreadCleanup(temporary.token);
+        try {
+          await runTemporaryThreadCleanup(temporary.token, cap, false);
+        } catch (error) {
+          // Cleanup uncertainty retains its canonical grant, not command execution authority or a retry license.
+          deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-menu-cleanup" });
+        }
+        assertRecipientCurrent();
+        allowEffects = true;
+      } catch (error) {
+        deps.recordRuntimeEvent?.("routing", error, { phase: "reroute-menu-release" });
+      } finally {
+        resume(allowEffects);
+        await execution;
+      }
+    };
+  };
   const finalizePendingReroute = async (
     rerouteId: string,
     pending: PendingUnboundReroute,
@@ -7258,12 +7352,20 @@ export function createTelegramInboundRouteRuntime<
           });
         if (!cancelledCurrent()) return;
         entry = cap.adopt(entry);
-        if (
-          !entry ||
-          !cap.isCurrent() ||
-          isRerouteTargetProtected(target, undefined, entry)
-        )
-          return;
+        if (!entry || !cap.isCurrent()) return;
+        if (isRerouteTargetProtected(target, undefined, entry) && deps.recoverTemporaryThreadDeadQueueOwners &&
+            store.inspectTemporaryThreadTarget(entry, cap.authority)?.kind === "temporary") {
+          const inputs = Threads.getTelegramTemporaryThreadInputs(entry);
+          const removed = deps.recoverTemporaryThreadDeadQueueOwners(
+            target, [cap.journalBindingKey, ...inputs.map(input => input.journalBindingKey)],
+            inputs, cap.isCurrent,
+          );
+          if (removed > 0) deps.recordRuntimeEvent?.("routing",
+            "Discarded historical queue receipts from confirmed-dead owners before temporary Thread cleanup.",
+            { phase: "temporary-thread-dead-owner-recovery", removedUpdateCount: removed });
+        }
+        // Recovery is not deletion authority: recapture every ordinary protection after the journal CAS.
+        if (!cap.isCurrent() || isRerouteTargetProtected(target, undefined, entry)) return;
         const issued = store.issueTemporaryThreadCleanup(entry, cap.authority);
         if (!issued || !cap.isCurrent()) return;
         entry = issued.entry;
@@ -8658,6 +8760,7 @@ export function createTelegramInboundRouteRuntime<
   const executeUnboundRerouteCallbackOperation = async (
     query: TCallbackQuery,
     ctx: TContext,
+    afterAdmission: (release: () => Promise<void>) => void,
   ): Promise<boolean> => {
     const parsed = parseTelegramUnboundRerouteCallbackData(query.data);
     if (!parsed) return false;
@@ -9349,7 +9452,20 @@ export function createTelegramInboundRouteRuntime<
     const localMessages = pending.rerouteCopies
       ? cloneTelegramMessagesForThread(pending.messages, parsed.threadId, pending.rerouteCopies.bySourceUpdateId)
       : reroutedMessages;
-    await dispatchPendingRerouteMessages(pending, localMessages, ctx);
+    const command = pending.dispatchKind === "command"
+      ? getLiveRebindMenu(localMessages) ?? getLiveRebindHelp(localMessages) : undefined;
+    const completion = pending.rerouteCopies && command
+      ? Updates.prepareTelegramDeferredSourceCompletion(pending.messages[0]) : undefined;
+    if (command && completion) {
+      const release = await stageTemporaryRerouteMenu(pending, command, localMessages, ctx, assertRerouteCurrent, completion);
+      if (!release) {
+        await deps.answerCallbackQuery(query.id, "Command acceptance unconfirmed; not resending");
+        return true;
+      }
+      afterAdmission(release);
+    } else {
+      await dispatchPendingRerouteMessages(pending, localMessages, ctx);
+    }
     assertRerouteCurrent();
     pending.messages = [];
     return completeRoutedReroute();
@@ -9360,17 +9476,23 @@ export function createTelegramInboundRouteRuntime<
   ): Promise<boolean> => {
     const parsed = parseTelegramUnboundRerouteCallbackData(query.data);
     if (!parsed) return false;
-    return withPendingRerouteSelection(parsed.rerouteId, query, () => {
-      if (!deps.runWorkspaceOperation)
-        return executeUnboundRerouteCallbackOperation(query, ctx);
-      return deps.runWorkspaceOperation(
-        {
-          operationId: `workspace-reroute:${query.id}`,
-          operationKind: "workspace.route-unbound-thread",
-          scopes: [{ kind: "profile" }],
-        },
-        () => executeUnboundRerouteCallbackOperation(query, ctx),
-      );
+    return withPendingRerouteSelection(parsed.rerouteId, query, async () => {
+      let release: (() => Promise<void>) | undefined;
+      const operation = () => executeUnboundRerouteCallbackOperation(query, ctx, value => { release = value; });
+      try {
+        if (!deps.runWorkspaceOperation) return await operation();
+        return await deps.runWorkspaceOperation(
+          {
+            operationId: `workspace-reroute:${query.id}`,
+            operationKind: "workspace.route-unbound-thread",
+            scopes: [{ kind: "profile" }],
+          },
+          operation,
+        );
+      } finally {
+        // Keep the exact source references, but release the non-reentrant Workspace gate before cleanup.
+        await release?.();
+      }
     });
   };
   const handleUnboundRerouteCallback = async (

package/node_modules/@llblab/pi-telegram/lib/runtime.ts

@@ -6,6 +6,16 @@
 
 import * as Machine from "./machine.ts";
 
+/**
+ * Structural port for run-collapsing diagnostics: a repeated identical failure extends its run instead of logging
+ * again, and the closing success records one outcome. The composition root owns the collapsed implementation.
+ */
+export interface TelegramRepeatedFailureLogPort {
+  record: (error: unknown, details?: Record<string, unknown>) => void;
+  settled: () => void;
+  reset: () => void;
+}
+
 const TELEGRAM_TYPING_ACTION_INTERVAL_MS = 3_000;
 const TELEGRAM_TYPING_IDLE_DRAIN_MAX_MS = 250;
 
@@ -344,6 +354,8 @@ function updateTelegramRuntimeStatusSafely<TContext>(
 export interface TelegramTypingLoopStarterDeps<
   TContext,
 > extends TelegramRuntimeEventRecorderPort {
+  /** Collapses one sustained presence failure run; the caller supplies its owner. */
+  failureLog: TelegramRepeatedFailureLogPort;
   typing: TelegramRuntimeTypingPort;
   getDefaultChatId: () => number | undefined;
   sendTypingAction: (
@@ -374,6 +386,31 @@ export function createTelegramTypingLoopStarter<TContext>(
     threadId: number | undefined;
     canContinue: () => boolean;
   } | undefined;
+  // An unreachable transport repeats one identical presence failure every tick; the port collapses the run.
+  // Running it through one guard keeps a faulty diagnostics port from escaping the in-flight action owner.
+  const typingFailureLog: TelegramRepeatedFailureLogPort = {
+    record(error, details) {
+      try {
+        deps.failureLog.record(error, details);
+      } catch {
+        // Typing diagnostics cannot escape the in-flight action owner.
+      }
+    },
+    settled() {
+      try {
+        deps.failureLog.settled();
+      } catch {
+        // A successful presence outranks its own diagnostic.
+      }
+    },
+    reset() {
+      try {
+        deps.failureLog.reset();
+      } catch {
+        // Typing diagnostics cannot fail a loop stop.
+      }
+    },
+  };
   return (ctx, chatId, options) => {
     const sessionGeneration = deps.getSessionGeneration?.();
     const transportAuthority = deps.getTransportAuthority?.();
@@ -422,24 +459,20 @@ export function createTelegramTypingLoopStarter<TContext>(
               if (!active || !canContinue()) throw new Error("Typing context authority changed.");
             },
           });
+          typingFailureLog.settled();
         } catch (error) {
           if (!active) return;
           if (!canContinue()) {
             deps.typing.stop();
             return;
           }
-          try {
-            deps.recordRuntimeEvent?.("typing", error, {
-              chatId: targetChatId,
-            });
-          } catch {
-            // Typing diagnostics cannot escape the in-flight action owner.
-          }
+          typingFailureLog.record(error, { chatId: targetChatId });
         }
       },
       shouldContinue: canContinue,
       onStopped: () => {
         active = false;
+        typingFailureLog.reset();
         if (currentOwner === owner) currentOwner = undefined;
       },
     });

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

@@ -401,6 +401,8 @@ export interface TelegramApiCallOptions {
   sleep?: (ms: number) => Promise<void>;
   /** Observability hook fired before a 429 retry wait, never for 5xx waits. */
   onRetryWait?: (wait: TelegramApiRetryWait) => void;
+  /** Caller-owned expected failure: still thrown, but the caller records the outcome instead of the API log. */
+  isExpectedError?: (error: unknown) => boolean;
 }
 
 export class TelegramApiAuthorityError extends Error {
@@ -473,6 +475,8 @@ export interface TelegramAnswerGuestQueryOptions {
 }
 
 export interface TelegramEditGuestInlineMessageContent {
+  /** Cached media only: inline edits cannot upload a new local file. */
+  media?: { type: "photo" | "document" | "audio"; media: string; caption?: string };
   text?: string;
   richMessage?: TelegramInputRichMessage;
   parseMode?: "HTML";
@@ -917,10 +921,9 @@ export interface TelegramBridgeApiRuntime extends Pick<
     options?: TelegramAnswerGuestQueryOptions,
   ) => Promise<void>;
   /**
-   * Temporary Guest Mode ACK experiment: answers the guest query and returns
-   * the sent inline message id so the final answer can edit that early reply.
-   * Requires direct transport ownership; Telegram does not document editing
-   * guest answers, so this exists only to falsify that behavior live.
+   * Answers the guest query and retains the sent inline message id for final
+   * text or cached-media replacement. Requires direct transport ownership;
+   * actual guest-media rendering remains live-client gated.
    */
   answerGuestQueryForInlineMessage: (
     guestQueryId: string,
@@ -930,6 +933,7 @@ export interface TelegramBridgeApiRuntime extends Pick<
   editGuestInlineMessage: (
     inlineMessageId: string,
     content: TelegramEditGuestInlineMessageContent,
+    options?: Pick<TelegramApiCallOptions, "assertAuthority">,
   ) => Promise<void>;
   deleteMessage: (chatId: number, messageId: number) => Promise<void>;
   prepareTempDir: () => Promise<number>;
@@ -2195,11 +2199,12 @@ export function createTelegramBridgeApiRuntime(
       ) {
         return true as TResponse;
       }
-      deps.recordRuntimeEvent(
-        "api",
-        error,
-        withTelegramTransportDiagnostics(error, { method }),
-      );
+      if (!options?.isExpectedError?.(error))
+        deps.recordRuntimeEvent(
+          "api",
+          error,
+          withTelegramTransportDiagnostics(error, { method }),
+        );
       throw error;
     }
   };
@@ -2404,14 +2409,29 @@ export function createTelegramBridgeApiRuntime(
     editGuestInlineMessage: async (
       inlineMessageId: string,
       content: TelegramEditGuestInlineMessageContent,
+      options?: Pick<TelegramApiCallOptions, "assertAuthority">,
     ) => {
+      if (content.media) {
+        try {
+          const result = await callRecorded("editMessageMedia", {
+            inline_message_id: inlineMessageId,
+            media: content.media,
+          }, { ...options, maxAttempts: 1, retryRateLimit: false });
+          if (result !== true) throw new Error("Missing inline edit acknowledgement.");
+        } catch (error) {
+          // Only a parsed rejection permits replacing this attempt with a failure notice.
+          if (isTelegramApiRequestRejected(error, "editMessageMedia")) throw error;
+          throw new TelegramApiCommitUnknownError("editMessageMedia", error);
+        }
+        return;
+      }
       await callRecorded("editMessageText", {
         inline_message_id: inlineMessageId,
         ...(content.richMessage
           ? { rich_message: content.richMessage }
           : { text: content.text }),
         ...(content.parseMode ? { parse_mode: content.parseMode } : {}),
-      });
+      }, options);
     },
     prepareTempDir: () =>
       prepareTelegramTempDir(deps.tempDir, deps.tempFileMaxAgeMs),

package/node_modules/@llblab/pi-telegram/lib/thread-reconciler.ts

@@ -719,7 +719,12 @@ export async function applyThreadReconciliationPlan(
       }
       let deleteConfirmed = false;
       let superseded = false;
-      for (const method of ports.skipCloseBeforeDelete
+      // Private-chat topics (positive chat ids) cannot be closed; Telegram only supports closeForumTopic in forums.
+      const skipClose =
+        ports.skipCloseBeforeDelete ||
+        (action.kind === "close-delete-graceful-shutdown-topic" &&
+          action.target.chatId > 0);
+      for (const method of skipClose
         ? ["deleteForumTopic"]
         : ["closeForumTopic", "deleteForumTopic"]) {
         if (ports.isCleanupTargetProtected?.(action.target, action)) {

package/node_modules/@llblab/pi-telegram/lib/threads.ts

@@ -252,6 +252,13 @@ export interface TelegramWorkspaceExternalProtectionEvidence {
   deliveryAuthority: TelegramWorkspaceProtectionState;
 }
 
+/** Per-binding probe; `withSnapshot` lets one occupancy capture share binding-independent evidence reads. */
+export type TelegramWorkspaceExternalProtectionCapture = ((
+  binding: TelegramWorkspaceThreadBinding,
+) => TelegramWorkspaceExternalProtectionEvidence) & {
+  withSnapshot?: <T>(capture: () => T) => T;
+};
+
 export interface TelegramWorkspaceSlotOccupancySnapshot {
   bindings: TelegramWorkspaceSlotOccupancy[];
   reservedSlots: string[];
@@ -876,9 +883,7 @@ export interface TelegramTopicTargetStore {
   ) => Promise<boolean>;
   /** Caller must separately prove no external live owner, accepted work, or delivery authority. */
   captureWorkspaceSlotOccupancy: (
-    getExternalProtection: (
-      binding: TelegramWorkspaceThreadBinding,
-    ) => TelegramWorkspaceExternalProtectionEvidence,
+    getExternalProtection: TelegramWorkspaceExternalProtectionCapture,
     options?: { expectedRetirement?: TelegramWorkspaceRetirementIntent },
   ) => TelegramWorkspaceSlotOccupancySnapshot;
   hasWorkspaceBinding: (cwd: string, sessionId?: string) => boolean;
@@ -2723,10 +2728,16 @@ function liveRebindOldTargetUnknown(value: TelegramWorkspaceLiveRebindIntent): b
 function retainLiveRebind(value: TelegramWorkspaceLiveRebindIntent): boolean {
   return liveRebindActive(value) || liveRebindOldTargetUnknown(value) || value.oldTargetProtected === true;
 }
-function protectedLiveRebindOldTargets(snapshot: TelegramWorkspaceRestoreSnapshot | undefined): TelegramTarget[] {
+function provisioningProtectionIntents(snapshot: TelegramWorkspaceRestoreSnapshot): readonly Pick<TelegramWorkspaceRestoreIntent, "request">[] {
+  return [...snapshot.operations, ...(snapshot.liveRebindings ?? []).filter(retainLiveRebind)];
+}
+function protectedLiveRebindOldTargetIntents(snapshot: TelegramWorkspaceRestoreSnapshot | undefined): TelegramWorkspaceLiveRebindIntent[] {
   return (snapshot?.liveRebindings ?? []).filter(value =>
     value.oldTargetProtected === true || liveRebindOldTargetUnknown(value) || value.inputRelease !== undefined && value.cleanup === "issued",
-  ).map(value => ({ ...value.request.binding.target }));
+  );
+}
+function protectedLiveRebindOldTargets(snapshot: TelegramWorkspaceRestoreSnapshot | undefined): TelegramTarget[] {
+  return protectedLiveRebindOldTargetIntents(snapshot).map(value => ({ ...value.request.binding.target }));
 }
 function pendingWorkspaceRelocationRequests(
   snapshot: TelegramWorkspaceRestoreSnapshot | undefined,
@@ -2821,10 +2832,11 @@ function assertWorkspaceRestoreBindingProtection(
       throw new Error("Protected Workspace Restore owner target changed.");
     }
   }
-  for (const old of protectedLiveRebindOldTargets(file.workspaceRestore)) {
+  for (const { request } of protectedLiveRebindOldTargetIntents(file.workspaceRestore)) {
+    const old = request.binding.target;
     if (file.workspaceBindings?.some(value => targetMatches(value.target, old)) ||
       file.threads?.some(value => targetMatches(value.target, old) && ["active", "starting", "pending", "probe-required"].includes(value.status)) ||
-      file.pendingProvisions?.some(value => !value.target || targetMatches(value.target, old)) ||
+      file.pendingProvisions?.some(value => conflictsWithWorkspaceRestoreProvision(request, value)) ||
       file.reservations?.some(value => targetMatches(value.target, old)))
       throw new Error("Unknown live cleanup target remains protected.");
   }
@@ -3840,7 +3852,7 @@ export function createTelegramTopicTargetStore(
   };
   const assertRestoreRecoveryProtection = (
     path: string,
-    operations: readonly TelegramWorkspaceRestoreIntent[],
+    operations: readonly Pick<TelegramWorkspaceRestoreIntent, "request">[],
     provisions: readonly TelegramThreadPendingProvision[],
     requireKnownTargets = false,
     recoveryEvidence?: TelegramProvisionRecoveryFile,
@@ -5061,7 +5073,7 @@ export function createTelegramTopicTargetStore(
       assertWorkspaceRestoreBindingProtection(file);
       assertRestoreRecoveryProtection(
         path,
-        file.workspaceRestore!.operations,
+        provisioningProtectionIntents(file.workspaceRestore!),
         file.pendingProvisions ?? [],
       );
       observe({
@@ -5117,7 +5129,7 @@ export function createTelegramTopicTargetStore(
         assertWorkspaceRestoreBindingProtection(file);
         assertRestoreRecoveryProtection(
           path,
-          file.workspaceRestore!.operations,
+          provisioningProtectionIntents(file.workspaceRestore!),
           file.pendingProvisions ?? [],
         );
         const canonical = file.workspaceBindings ?? [],
@@ -5175,9 +5187,9 @@ export function createTelegramTopicTargetStore(
             (row) => currentRow(row) && targetMatches(row.target, old),
           ) ||
           reserved.some((value) => targetMatches(value.target, old)) ||
-          provisions.some(
-            (value) => !value.target || targetMatches(value.target, old),
-          ) ||
+          // Use the same binding/slot/owner/target conflicts as rebind admission. An unrelated unlocated
+          // create must not globally veto cleanup of this exact former binding (nor its issued marker).
+          provisions.some((value) => conflictsWithWorkspaceRestoreProvision(request, value)) ||
           cleanups.some((value) => targetMatches(value.target, old));
         if (
           protectedTarget(
@@ -5390,8 +5402,11 @@ export function createTelegramTopicTargetStore(
           file.reservations?.some((value) =>
             targetMatches(value.target, target),
           ) ||
+          // This exact created frame already proves a separately created routing tab (API ACK or authenticated
+          // implicit creation). An unlocated Workspace create is not its owner; keep that intent unresolved,
+          // but veto a concrete target collision. Generic unknown-target/Restore cleanup keeps its own guards.
           file.pendingProvisions?.some(
-            (value) => !value.target || targetMatches(value.target, target),
+            (value) => !!value.target && targetMatches(value.target, target),
           ) ||
           file.pendingCleanups?.some((value) =>
             targetMatches(value.target, target),
@@ -5557,7 +5572,7 @@ export function createTelegramTopicTargetStore(
                 parseTopicTargetFile(before.file).pendingProvisions ?? [];
               assertRestoreRecoveryProtection(
                 path,
-                before.state.operations,
+                provisioningProtectionIntents(before.state),
                 provisions,
               );
               const after = { ...before.file, workspaceRestore: next };
@@ -5573,7 +5588,7 @@ export function createTelegramTopicTargetStore(
                   return false;
                 assertRestoreRecoveryProtection(
                   path,
-                  [...before.state.operations, ...next.operations],
+                  [...provisioningProtectionIntents(before.state), ...provisioningProtectionIntents(next)],
                   provisions,
                 );
                 committedBefore = before;
@@ -5598,7 +5613,7 @@ export function createTelegramTopicTargetStore(
                     );
                   assertRestoreRecoveryProtection(
                     path,
-                    [...before.state.operations, ...next.operations],
+                    [...provisioningProtectionIntents(before.state), ...provisioningProtectionIntents(next)],
                     provisions,
                   );
                   if (!currentScope() || !isCurrent()) return;
@@ -6775,7 +6790,7 @@ export function createTelegramTopicTargetStore(
           conflictsWithWorkspaceRestoreProvision(request, provision),
         ) ||
         conflictsWithTemporaryThread(workspaceRestore, provision.target) ||
-        protectedLiveRebindOldTargets(workspaceRestore).some(old => !provision.target || targetMatches(old, provision.target))
+        protectedLiveRebindOldTargetIntents(workspaceRestore).some(({ request }) => conflictsWithWorkspaceRestoreProvision(request, provision))
       ) {
         throw new Error("Protected Workspace Restore provisioning conflict.");
       }
@@ -7349,7 +7364,9 @@ export function createTelegramTopicTargetStore(
     },
     captureWorkspaceSlotOccupancy(getExternalProtection, options) {
       const nowMs = getNowMs();
-      const bindings = Array.from(workspaceBindings.values()).map((binding) => {
+      const inSnapshot =
+        getExternalProtection.withSnapshot ?? ((capture) => capture());
+      const bindings = inSnapshot(() => Array.from(workspaceBindings.values()).map((binding) => {
         const slot = binding.slot?.toLowerCase() ?? "";
         const locallyProtected = isWorkspaceBindingLocallyProtected(
           binding,
@@ -7388,7 +7405,7 @@ export function createTelegramTopicTargetStore(
             : {}),
           protection,
         };
-      });
+      }));
       const localReservedSlots = [
         ...Array.from(workspaceClaims.values()).map(
           (claim) => claim.identity.slot,