@llblab/pi-telegram 0.50.0 → 0.51.0

package/lib/paths.ts

@@ -9,7 +9,7 @@
  */
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 
 export const TELEGRAM_DEFAULT_PROFILE_NAME = "default";
 
@@ -43,6 +43,20 @@ export function resolveAgentDir(
   return join(homedir(), ".pi", "agent");
 }
 
+/**
+ * Pure reference preflight against an independently approved resource path.
+ * Reject aliases; never repair relative historical references or redirect storage.
+ * Equality proves spelling only, not file identity, consumer closure or migration readiness.
+ */
+export function requireTelegramStoragePathReference(path: string, expectedPath: string): string {
+  if (typeof path !== "string" || typeof expectedPath !== "string" ||
+      !isAbsolute(path) || resolve(path) !== path ||
+      !isAbsolute(expectedPath) || resolve(expectedPath) !== expectedPath || path !== expectedPath) {
+    throw new Error("Telegram storage reference does not match its approved absolute path.");
+  }
+  return path;
+}
+
 /** Telegram bridge configuration file (<agentDir>/telegram.json). */
 export function resolveTelegramConfigPath(): string {
   return join(resolveAgentDir(), "telegram.json");
@@ -100,6 +114,13 @@ export function resolveTelegramWorkspaceAdmissionPath(
   );
 }
 
+/** Profile-only callback shape; binds storage to the configured agent directory. */
+export function resolveTelegramWorkspaceAdmissionPathForProfile(
+  profileName?: string,
+): string {
+  return resolveTelegramWorkspaceAdmissionPath(resolveAgentDir(), profileName);
+}
+
 /** Durable inactive Thread cleanup work-set journal. */
 export function resolveTelegramThreadCleanupWorkPath(
   agentDir = resolveAgentDir(),
@@ -129,6 +150,13 @@ export function resolveTelegramUpdateJournalPath(
   );
 }
 
+/** Profile-only callback shape; binds storage to the configured agent directory. */
+export function resolveTelegramUpdateJournalPathForProfile(
+  profileName?: string,
+): string {
+  return resolveTelegramUpdateJournalPath(resolveAgentDir(), profileName);
+}
+
 /** Durable follower delivery journal, isolated by stable recipient binding. */
 export function resolveTelegramFollowerJournalPath(
   recipientBindingKey: string,

package/lib/polling.ts

@@ -28,8 +28,8 @@ const TELEGRAM_GET_UPDATES_CONFLICT_SLOW_RETRY_MS = 3_000;
 const TELEGRAM_POLLING_RETRY_MS = 3_000;
 export const TELEGRAM_GET_UPDATES_GRACE_MS = 10_000;
 
-// Standard Telegram DM polling does not expose ordinary message-deletion events,
-// so queue removal stays reaction-driven while delete-like business updates remain defensive-only.
+// Standard Telegram DM polling does not expose ordinary message-deletion events.
+// Business deletions belong to a separate namespace and default routing ignores them.
 export const TELEGRAM_ALLOWED_UPDATES = [
   "message",
   "edited_message",

package/lib/queue.ts

@@ -922,6 +922,28 @@ export function removeTelegramQueueItemsByMessageIds<TContext = unknown>(
   };
 }
 
+export function removeTelegramQueuedGuestPromptByOrder<TContext = unknown>(
+  items: TelegramQueueItem<TContext>[],
+  queueOrder: number,
+): {
+  items: TelegramQueueItem<TContext>[];
+  removedItems: PendingTelegramTurn[];
+  removedCount: number;
+} {
+  const index = items.findIndex((item) => {
+    return isPendingTelegramTurn(item) &&
+      item.guestQueryId !== undefined &&
+      item.queueOrder === queueOrder;
+  });
+  if (index < 0) return { items, removedItems: [], removedCount: 0 };
+  const removedItem = items[index] as PendingTelegramTurn;
+  return {
+    items: [...items.slice(0, index), ...items.slice(index + 1)],
+    removedItems: [removedItem],
+    removedCount: 1,
+  };
+}
+
 export function applyTelegramQueuePromptReactionDisposition<
   TContext = unknown,
 >(
@@ -1593,7 +1615,7 @@ export interface TelegramAgentEndHookRuntimeDeps<
   extractAssistant: (
     messages: readonly TMessage[],
   ) => TelegramAgentEndAssistantResult;
-  isRecoveredAssistantAlreadyPublished?: (assistant: TelegramAgentEndAssistantResult) => boolean;
+  isAssistantAlreadyPublished?: (assistant: TelegramAgentEndAssistantResult) => boolean;
   getFoldQueuedPromptsIntoHistory: () => boolean;
   resetRuntimeState: () => void;
   isSessionActive?: (ctx: TContext) => boolean;
@@ -1739,8 +1761,7 @@ export function createTelegramAgentEndHook<
     if (deps.isSessionActive?.(ctx) === false) return;
     const turn = deps.getActiveTurn();
     const extractedAssistant = assistantOverride ?? (turn ? deps.extractAssistant(event.messages) : {});
-    const assistant = extractedAssistant.recoveredFromEarlier &&
-        deps.isRecoveredAssistantAlreadyPublished?.(extractedAssistant)
+    const assistant = deps.isAssistantAlreadyPublished?.(extractedAssistant)
       ? { stopReason: extractedAssistant.stopReason }
       : extractedAssistant;
     const hasPublication = !!assistant.text || assistant.stopReason === "error" || !!turn?.queuedAttachments.length;
@@ -2331,6 +2352,10 @@ export interface TelegramQueueMutationController<TContext> {
     ctx: TContext,
     scope?: TelegramQueueMessageScope,
   ) => number;
+  removeGuestPromptByQueueOrder?: (
+    queueOrder: number,
+    ctx: TContext,
+  ) => boolean;
   applyReactionByMessageId: (
     messageId: number,
     disposition: TelegramQueueReactionDisposition,
@@ -2604,6 +2629,11 @@ export function createTelegramQueueMutationController<TContext>(
         buildRuntimeDeps(ctx),
         scope,
       ),
+    removeGuestPromptByQueueOrder: (queueOrder, ctx) =>
+      removeTelegramQueuedGuestPromptByOrderRuntime(
+        queueOrder,
+        buildRuntimeDeps(ctx),
+      ),
     applyReactionByMessageId: (messageId, disposition, ctx, scope) =>
       applyTelegramQueuePromptReactionDispositionRuntime(
         messageId,
@@ -2684,6 +2714,21 @@ export function removeTelegramQueueItemsByMessageIdsRuntime<TContext>(
   return removedCount;
 }
 
+export function removeTelegramQueuedGuestPromptByOrderRuntime<TContext>(
+  queueOrder: number,
+  deps: TelegramQueueMutationRuntimeDeps<TContext>,
+): boolean {
+  const { items, removedItems, removedCount } =
+    removeTelegramQueuedGuestPromptByOrder(deps.getQueuedItems(), queueOrder);
+  if (removedCount === 0) return false;
+  // A menu Skip means permanent discard, so settle durable admission before
+  // removing the live item. A failed settlement keeps the prompt retryable.
+  deps.onItemsDiscarded?.(removedItems, deps.ctx);
+  deps.setQueuedItems(items);
+  updateTelegramQueueStatusRuntime(deps);
+  return true;
+}
+
 export function applyTelegramQueuePromptReactionDispositionRuntime<TContext>(
   messageId: number,
   disposition: TelegramQueueReactionDisposition,

package/lib/replies.ts

@@ -1018,6 +1018,10 @@ export const TELEGRAM_GUEST_PLACEHOLDER_FRAMES = [
   "<b>🌏 Working on it...</b>",
 ] as const;
 
+// Telegram does not expose deletion for inline messages. This non-printing,
+// non-empty edit visually clears a guest placeholder after its query is skipped.
+export const TELEGRAM_DISMISSED_GUEST_PLACEHOLDER_TEXT = "\u2063";
+
 export function buildTelegramGuestPlaceholderFrame(step: number): string {
   const frames: readonly string[] = TELEGRAM_GUEST_PLACEHOLDER_FRAMES;
   const index = ((step % frames.length) + frames.length) % frames.length;
@@ -1052,6 +1056,8 @@ export interface TelegramGuestPlaceholderRuntime {
   stop: (inlineMessageId: string) => Promise<void>;
   /** Cancels every loop without waiting for in-flight edits (session shutdown). */
   stopAll: () => void;
+  /** Stops rotation and visually clears the inline placeholder. */
+  dismiss: (inlineMessageId: string) => Promise<void>;
 }
 
 interface TelegramGuestPlaceholderSession {
@@ -1202,5 +1208,18 @@ export function createTelegramGuestPlaceholderRuntime(
       }
       sessions.clear();
     },
+    async dismiss(inlineMessageId) {
+      await stop(inlineMessageId);
+      try {
+        await deps.editGuestInlineMessage(inlineMessageId, {
+          text: TELEGRAM_DISMISSED_GUEST_PLACEHOLDER_TEXT,
+          parseMode: "HTML",
+        });
+      } catch (error) {
+        deps.recordRuntimeEvent?.("guest", error, {
+          phase: "guest-placeholder-dismiss",
+        });
+      }
+    },
   };
 }

package/lib/sync.ts

@@ -7,6 +7,7 @@
 import { getTelegramApiErrorRequestTarget, isTelegramStaleTargetHttpError } from "./telegram-api.ts";
 import { getTelegramTargetKey, type TelegramTarget } from "./target.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
+import { TelegramWorkspaceSlotUnavailableError } from "./workspace-slots.ts";
 import {
   createTelegramWorkspaceAdmissionOperationId,
   runWithTelegramWorkspaceAdmissionsAsync,
@@ -197,6 +198,47 @@ export function markTelegramConfigSyncChange<
   return nextState;
 }
 
+export function createTelegramPreservedLeaderQuitHandler(deps: {
+  instanceId: string;
+  topicTargetStore: Pick<TelegramTopicTargetStore,
+    "load" | "list" | "listPendingCleanups" | "detachTargetOwner">;
+  getCurrentLeaderEpoch: () => number | string | undefined;
+  getProfileName: () => string | undefined;
+  isPollingSuspended: () => boolean;
+  resolveAutomaticThreadCleanupEnabled: () => boolean | Promise<boolean>;
+  runWorkspaceOperation: TelegramSyncWorkspaceOperationRunner;
+}): (isSessionCurrent: () => boolean) => (() => Promise<void>) | undefined {
+  return (isSessionCurrent) => {
+    const epoch = deps.getCurrentLeaderEpoch();
+    const profile = deps.getProfileName();
+    if (epoch === undefined || !isSessionCurrent()) return undefined;
+    const isCurrent = () => isSessionCurrent() && deps.getCurrentLeaderEpoch() === epoch &&
+      deps.getProfileName() === profile && deps.isPollingSuspended();
+    return async () => {
+      if (!isCurrent() || await deps.resolveAutomaticThreadCleanupEnabled() !== false) return;
+      if (!isCurrent()) return;
+      await deps.runWorkspaceOperation({
+        operationId: createTelegramWorkspaceAdmissionOperationId(),
+        operationKind: "workspace.preserve-leader-quit",
+        scopes: [{ kind: "profile" }],
+      }, async () => {
+        if (!isCurrent()) return;
+        await deps.topicTargetStore.load();
+        if (!isCurrent()) return;
+        const records = deps.topicTargetStore.list().filter((record) =>
+          record.instanceId === deps.instanceId && (record.status === "active" || record.status === "starting"));
+        if (records.length !== 1) return;
+        const record = records[0]!;
+        if (deps.topicTargetStore.listPendingCleanups().some((intent) =>
+          intent.target.chatId === record.target.chatId && intent.target.threadId === record.target.threadId)) return;
+        if (!await deps.topicTargetStore.detachTargetOwner(record, isCurrent) && isCurrent()) {
+          throw new Error("Telegram preserved leader detachment was not committed.");
+        }
+      });
+    };
+  };
+}
+
 export interface TelegramSessionRestartThreadCleanupDeps<
   TSyncState extends TelegramSyncState,
 > extends Omit<TelegramManualThreadDisconnectDeps<TSyncState>, "stopPolling"> {
@@ -650,15 +692,17 @@ export async function ensureTelegramLeaderThreadBinding(
   const leaderProfileKey = getTelegramThreadOwnerKey(leaderOwner);
   const legacyLeaderRecord =
     deps.topicTargetStore.getByProfileKey(leaderProfileKey);
+  let capacityUnavailable = false;
   const workspaceIdentity = normalizedLeaderCwd
     ? deps.topicTargetStore.claimWorkspaceIdentity(
         normalizedLeaderCwd,
         deps.instanceId,
         legacyLeaderRecord?.instanceId,
-        { sessionId: deps.sessionId },
+        { sessionId: deps.sessionId, onCapacityUnavailable() { capacityUnavailable = true; } },
       )
     : undefined;
   if (deps.cwd && !workspaceIdentity) {
+    if (capacityUnavailable) throw new TelegramWorkspaceSlotUnavailableError();
     throw new Error("Telegram Workspace identity is already claimed.");
   }
   const commitWorkspaceBinding = async (
@@ -684,7 +728,14 @@ export async function ensureTelegramLeaderThreadBinding(
     assertLeaderEpoch("before-workspace-persist");
     await deps.topicTargetStore.persist();
     assertLeaderEpoch("after-workspace-persist");
-    return { ...result, ...(committed.displayTitle ? { displayTitle: committed.displayTitle } : {}) };
+    const { target: _target, slot: _slot, threadName: _threadName, displayTitle: _displayTitle, ...rest } = result;
+    return {
+      ...rest,
+      target: { ...committed.target },
+      slot: committed.slot ?? result.slot,
+      ...(committed.threadName ? { threadName: committed.threadName } : {}),
+      ...(committed.displayTitle ? { displayTitle: committed.displayTitle } : {}),
+    };
   };
   try {
   const unavailableTargetKeys = new Set([

package/lib/telegram-api.ts

@@ -882,15 +882,18 @@ export function isTelegramApiCommitUnknownError(
 class TelegramApiHttpError extends Error {
   readonly status: number | undefined;
   readonly retryAfterSeconds: number | undefined;
+  readonly rejectedRequestMethod: string | undefined;
   requestTarget?: { chatId: number; threadId: number };
   constructor(
     message: string,
     status: number | undefined,
     retryAfterSeconds: number | undefined,
+    rejectedRequestMethod?: string,
   ) {
     super(message);
     this.status = status;
     this.retryAfterSeconds = retryAfterSeconds;
+    this.rejectedRequestMethod = rejectedRequestMethod;
   }
 }
 
@@ -934,6 +937,12 @@ export function isTelegramStaleTargetHttpError(error: unknown): boolean {
   return /^Telegram API \w+ failed: HTTP 400: Bad Request: (message thread not found|thread not found|topic not found|topic deleted|topic closed|thread closed|forum topic closed|message thread closed|topic_id_invalid|topic_closed)$/i.test(error.message);
 }
 
+/** Only a parsed Telegram rejection of this method proves a request had no effect. */
+export function isTelegramApiRequestRejected(error: unknown, method: string): boolean {
+  return error instanceof TelegramApiHttpError && error.rejectedRequestMethod !== undefined &&
+    error.rejectedRequestMethod === method;
+}
+
 export function isTelegramMessageNotModifiedError(error: unknown): boolean {
   return (
     error instanceof Error && error.message.includes("message is not modified")
@@ -1106,6 +1115,8 @@ async function parseTelegramApiResponse<TResponse>(
       `Telegram API ${method} failed: ${status}${description}`,
       response.status,
       Number.isFinite(retryAfterSeconds) ? retryAfterSeconds : undefined,
+      data?.ok === false && data.error_code === response.status &&
+        [400, 401, 403, 404, 429].includes(response.status) ? method : undefined,
     );
   }
   if (!data) {
@@ -1785,6 +1796,10 @@ export function buildTelegramAnswerGuestQueryBody(
   return body;
 }
 
+export type TelegramWorkspaceThreadDeletionTransport = (
+  authorize: () => { chatId: number; threadId: number },
+) => Promise<void>;
+
 export function createDefaultTelegramBridgeApiRuntime(deps: {
   getBotToken: () => string | undefined;
   recordRuntimeEvent: TelegramBridgeApiRuntimeDeps["recordRuntimeEvent"];
@@ -1793,7 +1808,9 @@ export function createDefaultTelegramBridgeApiRuntime(deps: {
   workspaceAdmission?:
     | TelegramApiWorkspaceAdmissionPort
     | (() => TelegramApiWorkspaceAdmissionPort | undefined);
-}): TelegramBridgeApiRuntime {
+}): TelegramBridgeApiRuntime & {
+  deleteWorkspaceThread: TelegramWorkspaceThreadDeletionTransport;
+} {
   const client = createTelegramApiClient(deps.getBotToken, {
     recordRuntimeEvent: deps.recordRuntimeEvent,
   });
@@ -1807,7 +1824,7 @@ export function createDefaultTelegramBridgeApiRuntime(deps: {
         },
       })
     : client;
-  return createTelegramBridgeApiRuntime({
+  const runtime = createTelegramBridgeApiRuntime({
     client: deps.targetActivity
       ? createTelegramApiTargetTrackingClient(admittedClient, deps.targetActivity)
       : admittedClient,
@@ -1817,6 +1834,17 @@ export function createDefaultTelegramBridgeApiRuntime(deps: {
     recordRuntimeEvent: deps.recordRuntimeEvent,
     captureRequestErrorHandler: deps.captureRequestErrorHandler,
   });
+  return {
+    ...runtime,
+    async deleteWorkspaceThread(authorize) {
+      // The exclusive deletion permit replaces ordinary target admission.
+      const target = authorize();
+      const deleted = await client.call<boolean>("deleteForumTopic", {
+        chat_id: target.chatId, message_thread_id: target.threadId,
+      }, { maxAttempts: 1, retrySafety: "non-idempotent" });
+      if (deleted !== true) throw new Error("Telegram Workspace Thread deletion was not confirmed.");
+    },
+  };
 }
 
 export function createTelegramBridgeApiRuntime(

package/lib/thread-cleanup-manager.ts

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

package/lib/threads.ts

@@ -34,6 +34,7 @@ import * as ThreadReconciler from "./thread-reconciler.ts";
 import {
   planTelegramWorkspaceSlotAllocation,
   TELEGRAM_WORKSPACE_SLOTS,
+  TelegramWorkspaceSlotUnavailableError,
   type TelegramWorkspaceSlotOccupancy,
 } from "./workspace-slots.ts";
 import {
@@ -458,6 +459,11 @@ export interface TelegramTopicTargetStore {
     isCurrent: () => boolean,
     lastSyncError: string,
   ) => Promise<boolean>;
+  /** Caller proves owner detachment; this does not assert Telegram Thread absence. */
+  detachTargetOwner: (
+    expected: TelegramTopicTargetRecord,
+    isCurrent: () => boolean,
+  ) => Promise<boolean>;
   list: () => TelegramTopicTargetRecord[];
   getFollowerRecoveryHintByTarget?: (
     target: TelegramTarget,
@@ -2108,20 +2114,33 @@ export function createTelegramTopicTargetStore(
     mutationRevision += 1;
   };
 
-  const persistSnapshot = (invalidation?: {
+  const markWorkspaceBindingInactiveByTarget = (target: TelegramTarget, inactiveSinceMs = getNowMs()): boolean => {
+    if (!Number.isFinite(inactiveSinceMs) || inactiveSinceMs < 0) return false;
+    for (const [key, binding] of workspaceBindings) {
+      if (!targetMatches(binding.target, target) || binding.inactiveSinceMs !== undefined) continue;
+      workspaceBindings.set(key, { ...binding, inactiveSinceMs });
+      markDirty();
+      return true;
+    }
+    return false;
+  };
+
+  const persistSnapshot = (transition?: {
     target: TelegramTarget;
     isCurrent: () => boolean;
-    lastSyncError: string;
-  }): Promise<boolean> => {
+  } & (
+    | { kind: "invalidate"; lastSyncError: string }
+    | { kind: "detach"; owner: TelegramTopicTargetRecord }
+  )): Promise<boolean> => {
       const persist = persistQueue.then(async () => {
         const path = getPath();
         if (loadedPath !== path && !dirty) resetForPath(path);
         if (options.canPersist && !options.canPersist()) {
-          if (!invalidation) await loadFromDisk();
+          if (!transition) await loadFromDisk();
           return false;
         }
         if (!dirty || !loaded) await loadFromDisk();
-        if (invalidation && !invalidation.isCurrent()) return false;
+        if (transition && !transition.isCurrent()) return false;
         const nowMs = getNowMs();
         reservations = reservations.filter(
           (reservation) =>
@@ -2134,6 +2153,10 @@ export function createTelegramTopicTargetStore(
         const currentRecords = Array.from(records.values())
           .filter(isPersistedThreadRecord)
           .map(cloneRecord);
+        if (transition?.kind === "detach") {
+          const owners = currentRecords.filter((record) => targetMatches(record.target, transition.target));
+          if (owners.length !== 1 || !isDeepStrictEqual(normalizeRecord(owners[0]), transition.owner)) return false;
+        }
         records = new Map(
           currentRecords.map((record) => [
             getRecordOwnerKey(record),
@@ -2176,20 +2199,32 @@ export function createTelegramTopicTargetStore(
             return serialized;
           }),
         };
-        if (invalidation) {
-          const record = file.threads.find((record) => targetMatches(record.target, invalidation.target));
+        if (transition) {
+          const record = file.threads.find((record) => targetMatches(record.target, transition.target));
           if (!record) return false;
+          if (transition.kind === "detach") {
+            const bindings = file.workspaceBindings.filter((binding) => targetMatches(binding.target, record.target));
+            if (bindings.length !== 1 || !/^[A-Z]$/.test(record.slot ?? "") ||
+                bindings[0]!.slot !== record.slot) return false;
+          }
           file.threads = file.threads.filter((candidate) => candidate !== record);
-          file.syncObservations = file.syncObservations.filter((observation) => !targetMatches(observation.target, record.target));
-          file.syncObservations.push({
-            target: { ...record.target },
-            syncStatus: "deleted",
-            observedAtMs: nowMs,
-            ...(record.instanceId ? { instanceId: record.instanceId } : {}),
-            ...(record.slot ? { slot: record.slot } : {}),
-            lastSyncError: invalidation.lastSyncError,
-            lastReconcileAction: "mark-stale",
-          });
+          for (const binding of file.workspaceBindings) {
+            if (targetMatches(binding.target, transition.target) && binding.inactiveSinceMs === undefined) {
+              binding.inactiveSinceMs = nowMs;
+            }
+          }
+          if (transition.kind === "invalidate") {
+            file.syncObservations = file.syncObservations.filter((observation) => !targetMatches(observation.target, record.target));
+            file.syncObservations.push({
+              target: { ...record.target },
+              syncStatus: "deleted",
+              observedAtMs: nowMs,
+              ...(record.instanceId ? { instanceId: record.instanceId } : {}),
+              ...(record.slot ? { slot: record.slot } : {}),
+              lastSyncError: transition.lastSyncError,
+              lastReconcileAction: "mark-stale",
+            });
+          }
         }
         let persistedSemanticSnapshot: Record<string, unknown> | undefined;
         try {
@@ -2201,7 +2236,7 @@ export function createTelegramTopicTargetStore(
         }
         // Normalize optional fields to wire JSON; object key order is not a state change.
         if (
-          isDeepStrictEqual(
+          !transition && isDeepStrictEqual(
             persistedSemanticSnapshot,
             getTelegramStateSemanticSnapshot(JSON.parse(JSON.stringify(file))),
           ) &&
@@ -2221,17 +2256,20 @@ export function createTelegramTopicTargetStore(
         });
         await chmod(tempPath, 0o600);
         try {
-          if (invalidation) {
+          if (transition) {
             let applied = false;
             const commit = () => {
               if (getPath() !== path || mutationRevision !== persistedRevision ||
-                statusRevision !== persistedStatusRevision || !invalidation.isCurrent()) return;
+                statusRevision !== persistedStatusRevision || !transition.isCurrent()) return;
               // Fence and rename share one synchronous commit boundary. No stale
-              // invalidation enters the live projection before durable commit.
+              // transition enters the live projection before durable commit.
               renameSync(tempPath, path);
               loadedPath = path;
-              records = new Map(Array.from(records).filter(([, record]) => !targetMatches(record.target, invalidation.target)));
+              records = new Map(Array.from(records).filter(([, record]) => !targetMatches(record.target, transition.target)));
               syncObservations = file.syncObservations;
+              workspaceBindings = new Map(file.workspaceBindings.map((binding) => [
+                getWorkspaceBindingMapKey(binding), cloneWorkspaceBinding(binding),
+              ]));
               mutationRevision += 1;
               dirty = false;
               applied = true;
@@ -2283,7 +2321,12 @@ export function createTelegramTopicTargetStore(
       await persistSnapshot();
     },
     invalidateTarget(target, isCurrent, lastSyncError) {
-      return persistSnapshot({ target, isCurrent, lastSyncError });
+      return persistSnapshot({ kind: "invalidate", target, isCurrent, lastSyncError });
+    },
+    detachTargetOwner(expected, isCurrent) {
+      const owner = normalizeRecord(expected);
+      if (!owner) return Promise.resolve(false);
+      return persistSnapshot({ kind: "detach", owner, target: owner.target, isCurrent });
     },
     list() {
       return Array.from(records.values()).map(cloneRecord);
@@ -2838,16 +2881,7 @@ export function createTelegramTopicTargetStore(
       markDirty();
       return true;
     },
-    markWorkspaceBindingInactiveByTarget(target, inactiveSinceMs = getNowMs()) {
-      if (!Number.isFinite(inactiveSinceMs) || inactiveSinceMs < 0) return false;
-      for (const [key, binding] of workspaceBindings) {
-        if (!targetMatches(binding.target, target) || binding.inactiveSinceMs !== undefined) continue;
-        workspaceBindings.set(key, { ...binding, inactiveSinceMs });
-        markDirty();
-        return true;
-      }
-      return false;
-    },
+    markWorkspaceBindingInactiveByTarget,
     markWorkspaceBindingActiveByTarget(target) {
       if (hasWorkspaceRetirementConflict({ target })) return false;
       for (const [key, binding] of workspaceBindings) {
@@ -3274,7 +3308,10 @@ export function createTelegramTopicTargetStore(
         entry.target && targetMatches(entry.target, target),
       ) : undefined;
       const source = record ?? pending;
-      if (!source?.target) return false;
+      // Confirmed absence ends this binding's active target lifetime, even after
+      // an earlier stale observation already removed its live record.
+      const inactive = syncStatus === "deleted" && markWorkspaceBindingInactiveByTarget(target);
+      if (!source?.target) return inactive;
       syncObservations = syncObservations.filter((entry) => !targetMatches(entry.target, target));
       syncObservations.push({
         target: { ...source.target }, syncStatus, observedAtMs: getNowMs(),
@@ -4886,7 +4923,7 @@ export function createTelegramTopicTargetProvisioner(
     if (existing && isCurrentThreadRecord(existing)) {
       const slot = existing.slot ?? deps.store.allocateSlot(request.profileKey);
       if (!slot) {
-        throw new Error("Telegram Workspace slot reservation is unavailable.");
+        throw new TelegramWorkspaceSlotUnavailableError();
       }
       const occupied = listOccupiedTelegramThreadIdentities({
         records: deps.store.list(),
@@ -5015,7 +5052,7 @@ export function createTelegramTopicTargetProvisioner(
         request.workspaceBindingKey,
       );
     if (!slot) {
-      throw new Error("Telegram Workspace slot reservation is unavailable.");
+      throw new TelegramWorkspaceSlotUnavailableError();
     }
     const uniqueCandidate =
       candidateThreadName &&