@llblab/pi-kit 0.6.0 → 0.7.0

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

@@ -4,7 +4,7 @@
  * Owns current live instance-binding to Telegram UI thread mappings backed by Bot API ForumTopic/message_thread_id transport
  */
 
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import {
   chmodSync,
   existsSync,
@@ -20,7 +20,7 @@ import {
   unlink,
   writeFile,
 } from "node:fs/promises";
-import { dirname } from "node:path";
+import { dirname, posix, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 
 import {
@@ -31,6 +31,11 @@ import {
 import type { TelegramTarget } from "./target.ts";
 import { withTelegramFileTransaction } from "./locks.ts";
 import * as ThreadReconciler from "./thread-reconciler.ts";
+import {
+  planTelegramWorkspaceSlotAllocation,
+  TELEGRAM_WORKSPACE_SLOTS,
+  type TelegramWorkspaceSlotOccupancy,
+} from "./workspace-slots.ts";
 import {
   resolveAgentDir,
   resolveTelegramProfileTempFilePath,
@@ -44,6 +49,101 @@ export interface TelegramThreadNameInput {
   slot?: string;
 }
 
+export interface TelegramWorkspaceBindingIdentity {
+  cwd: string;
+  workspaceKey: string;
+  /** Immutable legacy binding-key component, not the displayed global letter. */
+  instanceSlot: string;
+  bindingKey: string;
+  /** Profile-wide letter reserved by the transient claim. */
+  slot?: string;
+}
+
+const TELEGRAM_WORKSPACE_KEY_MAX_LENGTH = 180;
+
+export function normalizeTelegramWorkspacePath(
+  cwd: string,
+): string | undefined {
+  const trimmed = cwd.trim();
+  if (!trimmed) return undefined;
+  const normalized = (trimmed.startsWith("/")
+    ? posix.normalize(trimmed)
+    : resolve(trimmed).replaceAll("\\", "/"));
+  const withoutTrailingSeparators =
+    normalized.length > 1 ? normalized.replace(/\/+$/u, "") : normalized;
+  return process.platform === "win32"
+    ? withoutTrailingSeparators.replace(/^([A-Z]):/u, (_, drive: string) =>
+        `${drive.toLowerCase()}:`,
+      )
+    : withoutTrailingSeparators;
+}
+
+export function createTelegramWorkspaceDirectoryKey(
+  cwd: string,
+): string | undefined {
+  const normalized = normalizeTelegramWorkspacePath(cwd);
+  if (!normalized) return undefined;
+  const readable =
+    normalized
+      .replace(/[^\p{L}\p{N}._-]+/gu, "-")
+      .replace(/^-+|-+$/gu, "") || "root";
+  const candidate = `--${readable}--`;
+  if (candidate.length <= TELEGRAM_WORKSPACE_KEY_MAX_LENGTH) return candidate;
+  const digest = createHash("sha256")
+    .update(normalized)
+    .digest("hex")
+    .slice(0, 12);
+  const prefixLength =
+    TELEGRAM_WORKSPACE_KEY_MAX_LENGTH - digest.length - 5;
+  return `--${readable.slice(0, prefixLength)}-${digest}--`;
+}
+
+function createTelegramWorkspaceInstanceSlot(
+  ordinal: number,
+): string | undefined {
+  if (!Number.isSafeInteger(ordinal) || ordinal < 0) return undefined;
+  let value = ordinal + 1;
+  let slot = "";
+  while (value > 0) {
+    value -= 1;
+    slot = String.fromCharCode(97 + (value % 26)) + slot;
+    value = Math.floor(value / 26);
+  }
+  return slot;
+}
+
+function createTelegramWorkspaceBindingIdentityWithKey(
+  cwd: string,
+  workspaceKey: string,
+  ordinal: number,
+): TelegramWorkspaceBindingIdentity | undefined {
+  const instanceSlot = createTelegramWorkspaceInstanceSlot(ordinal);
+  if (!instanceSlot) return undefined;
+  return {
+    cwd,
+    workspaceKey,
+    instanceSlot,
+    bindingKey:
+      instanceSlot === "a" ? workspaceKey : `${workspaceKey}${instanceSlot}`,
+  };
+}
+
+export function createTelegramWorkspaceBindingIdentity(
+  cwd: string,
+  ordinal = 0,
+): TelegramWorkspaceBindingIdentity | undefined {
+  const normalized = normalizeTelegramWorkspacePath(cwd);
+  const workspaceKey = normalized
+    ? createTelegramWorkspaceDirectoryKey(normalized)
+    : undefined;
+  if (!normalized || !workspaceKey) return undefined;
+  return createTelegramWorkspaceBindingIdentityWithKey(
+    normalized,
+    workspaceKey,
+    ordinal,
+  );
+}
+
 export type TelegramTopicTargetStatus =
   | "active"
   | "offline"
@@ -86,6 +186,7 @@ export interface TelegramThreadPendingProvision {
   profileKey?: string;
   status?: "in-flight" | "ambiguous";
   threadName?: string;
+  displayTitle?: string;
   slot?: string;
   target?: TelegramTarget & { threadId: number };
   startedAtMs: number;
@@ -125,6 +226,8 @@ export interface TelegramTopicTargetRecord {
   createdAtMs: number;
   updatedAtMs: number;
   threadName?: string;
+  /** Explicit per-Workspace display override set by the operator. */
+  manualThreadName?: string;
   instanceId?: string;
   slot?: string;
   lastError?: string;
@@ -143,6 +246,61 @@ export interface TelegramThreadIdentityRecord {
   updatedAtMs: number;
 }
 
+export interface TelegramWorkspaceThreadBinding {
+  cwd: string;
+  workspaceKey: string;
+  instanceSlot: string;
+  bindingKey: string;
+  target: TelegramTarget & { threadId: number };
+  /** Stable generated identity retained for compatibility and recovery. */
+  threadName?: string;
+  /** Explicit display override; absence selects the profile's automatic mode. */
+  manualThreadName?: string;
+  slot?: string;
+  /** Last title acknowledged by Telegram; never replaces the stable name. */
+  displayTitle?: string;
+  /** Historical follower-journal routing keys that may retain accepted work. */
+  journalBindingKeys?: string[];
+  /** True only when the historical journal-key set is proven complete. */
+  journalBindingsComplete?: true;
+  /** Sticky once this directory has multiple retained bindings. */
+  showSlotSuffix?: boolean;
+  /** First continuously proven no-owner transition; absent means active or unproven. */
+  inactiveSinceMs?: number;
+  updatedAtMs: number;
+}
+
+export type TelegramWorkspaceDisplayBinding = Pick<
+  TelegramWorkspaceThreadBinding,
+  "bindingKey" | "cwd" | "slot" | "threadName" | "manualThreadName" |
+    "showSlotSuffix"
+>;
+
+export interface TelegramWorkspaceRetirementIntent {
+  id: string;
+  reason: "pressure";
+  profileKey: string;
+  binding: TelegramWorkspaceThreadBinding;
+  leaderEpoch: number | string;
+  requestedAtMs: number;
+}
+
+export type TelegramWorkspaceProtectionState =
+  | "clear"
+  | "protected"
+  | "unknown";
+
+export interface TelegramWorkspaceExternalProtectionEvidence {
+  liveOwner: TelegramWorkspaceProtectionState;
+  acceptedWork: TelegramWorkspaceProtectionState;
+  deliveryAuthority: TelegramWorkspaceProtectionState;
+}
+
+export interface TelegramWorkspaceSlotOccupancySnapshot {
+  bindings: TelegramWorkspaceSlotOccupancy[];
+  reservedSlots: string[];
+}
+
 export type TelegramBotThreadMode = "unknown" | "enabled" | "disabled";
 
 export interface TelegramBotStateSnapshot {
@@ -162,6 +320,8 @@ export interface TelegramTopicTargetFile {
   diagnostics?: Record<string, unknown>;
   threads: TelegramTopicTargetRecord[];
   identities?: TelegramThreadIdentityRecord[];
+  workspaceBindings?: TelegramWorkspaceThreadBinding[];
+  workspaceRetirements?: TelegramWorkspaceRetirementIntent[];
   reservations?: TelegramThreadReservation[];
   pendingProvisions?: TelegramThreadPendingProvision[];
   pendingCleanups?: TelegramThreadCleanupIntent[];
@@ -269,6 +429,70 @@ export interface TelegramTopicTargetStore {
     profileKey: string,
   ) => TelegramThreadIdentityRecord | undefined;
   forgetIdentityByProfileKey: (profileKey: string) => boolean;
+  listWorkspaceBindings: () => TelegramWorkspaceThreadBinding[];
+  listWorkspaceRetirementIntents: () => TelegramWorkspaceRetirementIntent[];
+  commitWorkspaceJournalEvidence: (
+    expected: TelegramWorkspaceThreadBinding,
+    journalBindingKeys: readonly string[],
+    complete: boolean,
+  ) => TelegramWorkspaceThreadBinding | undefined;
+  upsertWorkspaceRetirementIntent: (
+    intent: TelegramWorkspaceRetirementIntent,
+  ) => boolean;
+  removeWorkspaceRetirementIntent: (
+    expected: TelegramWorkspaceRetirementIntent,
+  ) => boolean;
+  replaceWorkspaceRetirementIntent: (
+    expected: TelegramWorkspaceRetirementIntent,
+    replacement: TelegramWorkspaceRetirementIntent,
+    isCurrent: () => boolean,
+  ) => Promise<boolean>;
+  commitWorkspaceRetirement: (
+    expected: TelegramWorkspaceRetirementIntent,
+    isCurrent: () => boolean,
+  ) => Promise<boolean>;
+  commitInactiveWorkspaceCleanup: (
+    expected: TelegramWorkspaceThreadBinding | {
+      cwd: string; workspaceKey: string; instanceSlot: string; slot: string; bindingKey: string;
+      target: { chatId: number; threadId: number }; inactiveSinceMs: number; bindingUpdatedAtMs: number;
+    },
+    isCurrent: () => boolean,
+  ) => Promise<boolean>;
+  /** Caller must separately prove no external live owner, accepted work, or delivery authority. */
+  captureWorkspaceSlotOccupancy: (
+    getExternalProtection: (
+      binding: TelegramWorkspaceThreadBinding,
+    ) => TelegramWorkspaceExternalProtectionEvidence,
+    options?: { expectedRetirement?: TelegramWorkspaceRetirementIntent },
+  ) => TelegramWorkspaceSlotOccupancySnapshot;
+  hasWorkspaceBinding: (cwd: string) => boolean;
+  setWorkspaceDisplayTitle: (
+    expected: TelegramWorkspaceThreadBinding,
+    title: string,
+  ) => boolean;
+  markWorkspaceBindingInactiveByTarget: (
+    target: TelegramTarget,
+    inactiveSinceMs?: number,
+  ) => boolean;
+  markWorkspaceBindingActiveByTarget: (target: TelegramTarget) => boolean;
+  getWorkspaceBinding: (
+    cwd: string,
+    instanceSlot?: string,
+  ) => TelegramWorkspaceThreadBinding | undefined;
+  claimWorkspaceIdentity: (
+    cwd: string,
+    instanceId: string,
+    previousInstanceId?: string,
+    options?: {
+      existingBindingOnly?: boolean;
+      onCapacityUnavailable?: () => void;
+    },
+  ) => TelegramWorkspaceBindingIdentity | undefined;
+  releaseWorkspaceClaim: (instanceId: string) => boolean;
+  upsertWorkspaceBinding: (
+    binding: TelegramWorkspaceThreadBinding,
+    claimInstanceId?: string,
+  ) => TelegramWorkspaceThreadBinding | undefined;
   upsert: (record: TelegramTopicTargetRecord) => TelegramTopicTargetRecord;
   markOfflineByInstanceId: (instanceId: string) => number;
   markStaleByTarget: (
@@ -280,10 +504,17 @@ export interface TelegramTopicTargetStore {
   renameByTarget: (
     target: TelegramTarget,
     threadName: string,
+    options?: { updateDisplayTitle: boolean },
+  ) => TelegramTopicTargetRecord | undefined;
+  clearManualNameByTarget: (
+    target: TelegramTarget,
+    automaticTitle: string,
   ) => TelegramTopicTargetRecord | undefined;
   allocateSlot: (
     profileKey: string,
     preferredSlot?: string,
+    workspaceBindingKey?: string,
+    options?: { excludeCurrentRecord?: boolean },
   ) => string | undefined;
   /** Claim the first reusable inactive thread for an instance, linking it to instanceId. */
   claimReusableTarget: (
@@ -371,9 +602,11 @@ export function createTelegramCleanupTargetProtection(
 
 export interface TelegramTopicTargetStoreOptions {
   path: string | (() => string);
+  telegramProfile?: string | (() => string | undefined);
   getNowMs?: () => number;
   canPersist?: () => boolean;
   commitPersist?: (commit: () => void) => boolean;
+  getExternalReservedSlots?: () => readonly string[];
 }
 
 export interface TelegramTopicTargetProvisionerDeps {
@@ -389,10 +622,13 @@ export interface TelegramTopicTargetProvisionerDeps {
     | "markStaleByTarget"
     | "allocateSlot"
     | "claimReusableTarget"
+    | "listWorkspaceBindings"
     | "listPendingProvisions"
     | "upsertPendingProvision"
     | "recordPendingProvisionTargetRecovery"
     | "removePendingProvision"
+    | "listSyncObservations"
+    | "listPendingCleanups"
     | "persist"
   >;
   callApi: <TResponse>(
@@ -401,6 +637,9 @@ export interface TelegramTopicTargetProvisionerDeps {
     options?: TelegramApiCallOptions,
   ) => Promise<TResponse>;
   topicNameTemplate?: string;
+  resolveInitialWorkspaceDisplayTitle?: (
+    binding: TelegramWorkspaceDisplayBinding,
+  ) => string | undefined;
   getNowMs?: () => number;
   getRandom?: () => number;
   getCurrentLeaderEpoch?: () => number | string | undefined;
@@ -408,11 +647,19 @@ export interface TelegramTopicTargetProvisionerDeps {
 }
 
 export interface TelegramTopicTargetRenamerDeps {
-  store: Pick<TelegramTopicTargetStore, "renameByTarget">;
+  store: Pick<
+    TelegramTopicTargetStore,
+    | "renameByTarget"
+    | "list"
+    | "listWorkspaceBindings"
+    | "listPendingProvisions"
+  >;
   callApi: <TResponse>(
     method: string,
     body: Record<string, unknown>,
   ) => Promise<TResponse>;
+  assertAuthority?: () => void;
+  shouldRenameDisplayedTitle?: () => boolean;
   topicNameTemplate?: string;
 }
 
@@ -423,6 +670,57 @@ export interface TelegramTopicTargetProvisionRequest {
   profileKey: string;
   threadName?: string;
   preferredSlot?: string;
+  workspaceBindingKey?: string;
+  workspaceCwd?: string;
+}
+
+/** Pending creation evidence cannot bypass an exact target's unresolved cleanup or closure. */
+export function assertTelegramPendingTopicRecoveryAllowed(
+  store: Pick<TelegramTopicTargetStore,
+    "listPendingProvisions" | "listPendingCleanups" | "listSyncObservations">,
+  target: TelegramTarget,
+): void {
+  if (!store.listPendingProvisions().some((entry) =>
+    entry.target && targetMatches(entry.target, target),
+  )) return;
+  if (store.listPendingCleanups().some((entry) => targetMatches(entry.target, target)) ||
+      store.listSyncObservations().some((entry) =>
+        targetMatches(entry.target, target) && entry.syncStatus === "closed",
+      )) {
+    throw new Error("Telegram pending topic requires reconciliation before recovery.");
+  }
+}
+
+/** Settle creation-title evidence with the exact Workspace claim; caller fences and persists. */
+export function commitTelegramWorkspaceProvisionBinding(input: {
+  store: Pick<TelegramTopicTargetStore,
+    "upsertWorkspaceBinding" | "setWorkspaceDisplayTitle" |
+    "listPendingProvisions" | "removePendingProvision" |
+    "listPendingCleanups" | "listSyncObservations">;
+  binding: TelegramWorkspaceThreadBinding;
+  instanceId: string;
+  profileKey: string;
+  displayTitle?: string;
+}): TelegramWorkspaceThreadBinding {
+  assertTelegramPendingTopicRecoveryAllowed(input.store, input.binding.target);
+  const pending = input.store.listPendingProvisions().filter((provision) =>
+    provision.target && targetMatches(provision.target, input.binding.target) &&
+    provision.slot === input.binding.slot &&
+    (provision.instanceId === input.instanceId || provision.profileKey === input.profileKey),
+  );
+  const titles = new Set(pending.map((provision) => provision.displayTitle)
+    .filter((title) => title !== undefined));
+  if (input.displayTitle !== undefined) titles.add(input.displayTitle);
+  if (titles.size > 1) throw new Error("Telegram Workspace creation title evidence conflicts.");
+  const displayTitle = titles.values().next().value;
+  const committed = input.store.upsertWorkspaceBinding(input.binding, input.instanceId);
+  if (!committed) throw new Error("Telegram Workspace binding claim changed.");
+  if (displayTitle !== undefined &&
+      !input.store.setWorkspaceDisplayTitle(committed, displayTitle)) {
+    throw new Error("Telegram Workspace display title commit changed binding.");
+  }
+  for (const provision of pending) input.store.removePendingProvision(provision.id);
+  return displayTitle === undefined ? committed : { ...committed, displayTitle };
 }
 
 export interface TelegramTopicTargetRenameRequest {
@@ -435,6 +733,7 @@ export interface TelegramTopicTargetProvisionResult {
   target: TelegramTarget & { threadId: number };
   reused: boolean;
   record: TelegramTopicTargetRecord;
+  displayTitle?: string;
 }
 
 interface TelegramTopicResult {
@@ -620,13 +919,22 @@ function parseThreadOwner(value: unknown): TelegramThreadOwner | undefined {
       cwd: typeof record.cwd === "string" ? record.cwd : undefined,
       instanceId:
         typeof record.instanceId === "string" ? record.instanceId : undefined,
+      ...(typeof record.telegramProfile === "string"
+        ? { telegramProfile: record.telegramProfile }
+        : {}),
     };
   }
   if (
     record.kind === "manual-follower" &&
     typeof record.instanceId === "string"
   ) {
-    return { kind: "manual-follower", instanceId: record.instanceId };
+    return {
+      kind: "manual-follower",
+      instanceId: record.instanceId,
+      ...(typeof record.telegramProfile === "string"
+        ? { telegramProfile: record.telegramProfile }
+        : {}),
+    };
   }
   if (
     record.kind === "pending-topic" &&
@@ -729,6 +1037,11 @@ function normalizeRecord(
     createdAtMs: record.createdAtMs,
     updatedAtMs: record.updatedAtMs,
     threadName: getPersistedThreadName(record),
+    ...(typeof record.manualThreadName === "string" &&
+      normalizeTelegramTopicTargetThreadName(record.manualThreadName)
+      ? { manualThreadName:
+          normalizeTelegramTopicTargetThreadName(record.manualThreadName) }
+      : {}),
     instanceId:
       typeof record.instanceId === "string" ? record.instanceId : undefined,
     slot: typeof record.slot === "string" ? record.slot : undefined,
@@ -810,6 +1123,134 @@ function cloneIdentityRecord(
   return { ...identity };
 }
 
+function getWorkspaceBindingMapKey(
+  binding: Pick<TelegramWorkspaceThreadBinding, "cwd" | "instanceSlot">,
+): string {
+  return `${binding.cwd}\u0000${binding.instanceSlot}`;
+}
+
+function normalizeWorkspaceBindingRecord(
+  value: unknown,
+): TelegramWorkspaceThreadBinding | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return undefined;
+  const record = value as Record<string, unknown>;
+  if (
+    typeof record.cwd !== "string" ||
+    typeof record.workspaceKey !== "string" ||
+    typeof record.instanceSlot !== "string" ||
+    typeof record.bindingKey !== "string" ||
+    typeof record.updatedAtMs !== "number"
+  ) {
+    return undefined;
+  }
+  const cwd = normalizeTelegramWorkspacePath(record.cwd);
+  if (
+    !cwd ||
+    cwd !== record.cwd ||
+    !record.workspaceKey ||
+    !/^[a-z]+$/u.test(record.instanceSlot) ||
+    record.bindingKey !==
+      (record.instanceSlot === "a"
+        ? record.workspaceKey
+        : `${record.workspaceKey}${record.instanceSlot}`)
+  ) {
+    return undefined;
+  }
+  const targetValue = record.target;
+  if (
+    !targetValue ||
+    typeof targetValue !== "object" ||
+    Array.isArray(targetValue)
+  ) {
+    return undefined;
+  }
+  const target = targetValue as Record<string, unknown>;
+  if (
+    typeof target.chatId !== "number" ||
+    typeof target.threadId !== "number" ||
+    !Number.isInteger(target.threadId)
+  ) {
+    return undefined;
+  }
+  const threadName = getPersistedThreadName(record);
+  const manualThreadName =
+    typeof record.manualThreadName === "string"
+      ? normalizeTelegramTopicTargetThreadName(record.manualThreadName)
+      : undefined;
+  const slot =
+    typeof record.slot === "string" && /^[A-Z]$/u.test(record.slot)
+      ? record.slot
+      : undefined;
+  const journalBindingKeys = Array.isArray(record.journalBindingKeys) &&
+    record.journalBindingKeys.every((key) =>
+      typeof key === "string" && key.length > 0 && key.length <= 512,
+    )
+    ? Array.from(new Set(record.journalBindingKeys as string[]))
+    : undefined;
+  return {
+    cwd,
+    workspaceKey: record.workspaceKey,
+    instanceSlot: record.instanceSlot,
+    bindingKey: record.bindingKey,
+    ...(record.showSlotSuffix === true ? { showSlotSuffix: true } : {}),
+    ...(typeof record.displayTitle === "string" && record.displayTitle.trim()
+      ? { displayTitle: record.displayTitle }
+      : {}),
+    ...(typeof record.inactiveSinceMs === "number" &&
+      Number.isFinite(record.inactiveSinceMs) && record.inactiveSinceMs >= 0
+      ? { inactiveSinceMs: record.inactiveSinceMs }
+      : {}),
+    ...(journalBindingKeys ? { journalBindingKeys } : {}),
+    ...(record.journalBindingsComplete === true && journalBindingKeys
+      ? { journalBindingsComplete: true as const }
+      : {}),
+    target: { chatId: target.chatId, threadId: target.threadId },
+    ...(threadName ? { threadName } : {}),
+    ...(manualThreadName ? { manualThreadName } : {}),
+    ...(slot ? { slot } : {}),
+    updatedAtMs: record.updatedAtMs,
+  };
+}
+
+function cloneWorkspaceBinding(
+  binding: TelegramWorkspaceThreadBinding,
+): TelegramWorkspaceThreadBinding {
+  return { ...binding, target: { ...binding.target } };
+}
+
+function normalizeWorkspaceRetirementIntent(
+  value: unknown,
+): TelegramWorkspaceRetirementIntent | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const record = value as Record<string, unknown>;
+  const binding = normalizeWorkspaceBindingRecord(record.binding);
+  if (
+    typeof record.id !== "string" || !record.id ||
+    record.reason !== "pressure" ||
+    typeof record.profileKey !== "string" || !record.profileKey ||
+    !binding?.slot || binding.inactiveSinceMs === undefined ||
+    !((typeof record.leaderEpoch === "number" && Number.isFinite(record.leaderEpoch)) ||
+      (typeof record.leaderEpoch === "string" && record.leaderEpoch.length > 0)) ||
+    typeof record.requestedAtMs !== "number" || !Number.isFinite(record.requestedAtMs) ||
+    record.requestedAtMs < 0
+  ) return undefined;
+  return {
+    id: record.id,
+    reason: record.reason,
+    profileKey: record.profileKey,
+    binding,
+    leaderEpoch: record.leaderEpoch,
+    requestedAtMs: record.requestedAtMs,
+  };
+}
+
+function cloneWorkspaceRetirementIntent(
+  intent: TelegramWorkspaceRetirementIntent,
+): TelegramWorkspaceRetirementIntent {
+  return { ...intent, binding: cloneWorkspaceBinding(intent.binding) };
+}
+
 function normalizeBotStateSnapshot(value: unknown): TelegramBotStateSnapshot {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     return { threadMode: "unknown" };
@@ -925,6 +1366,9 @@ function normalizePendingProvision(
     ...(typeof record.threadName === "string"
       ? { threadName: record.threadName }
       : {}),
+    ...(typeof record.displayTitle === "string" && record.displayTitle.trim()
+      ? { displayTitle: record.displayTitle }
+      : {}),
     ...(typeof record.slot === "string" ? { slot: record.slot } : {}),
     ...(target ? { target } : {}),
     startedAtMs: record.startedAtMs,
@@ -1070,6 +1514,18 @@ function parseTopicTargetFile(value: unknown): TelegramTopicTargetFile {
           return normalized ? [normalized] : [];
         })
       : [],
+    workspaceBindings: Array.isArray(file.workspaceBindings)
+      ? file.workspaceBindings.flatMap((binding) => {
+          const normalized = normalizeWorkspaceBindingRecord(binding);
+          return normalized ? [normalized] : [];
+        })
+      : [],
+    workspaceRetirements: Array.isArray(file.workspaceRetirements)
+      ? file.workspaceRetirements.flatMap((intent) => {
+          const normalized = normalizeWorkspaceRetirementIntent(intent);
+          return normalized ? [normalized] : [];
+        })
+      : [],
     reservations: Array.isArray(file.reservations)
       ? file.reservations.flatMap((reservation) => {
           const normalized = normalizeReservation(reservation);
@@ -1097,16 +1553,16 @@ function parseTopicTargetFile(value: unknown): TelegramTopicTargetFile {
   };
 }
 
-function serializeTelegramStateSemanticSnapshot(
+function getTelegramStateSemanticSnapshot(
   value: unknown,
-): string | undefined {
+): Record<string, unknown> | undefined {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return undefined;
   const { writtenAtMs: _writtenAtMs, ...semantic } = value as Record<
     string,
     unknown
   >;
-  return JSON.stringify(semantic);
+  return semantic;
 }
 
 function targetMatches(left: TelegramTarget, right: TelegramTarget): boolean {
@@ -1174,7 +1630,7 @@ function getInstanceProcessKey(
   return pid && /^\d+$/.test(pid) ? pid : undefined;
 }
 
-function isSameProcessInstance(
+export function isSameTelegramProcessInstance(
   left: string | undefined,
   right: string | undefined,
 ): boolean {
@@ -1197,9 +1653,39 @@ export function createTelegramTopicTargetStore(
   options: TelegramTopicTargetStoreOptions,
 ): TelegramTopicTargetStore {
   const getNowMs = options.getNowMs ?? Date.now;
+  const captureExternalReservedSlots = (): string[] | undefined => {
+    try {
+      const slots = options.getExternalReservedSlots?.() ?? [];
+      if (!Array.isArray(slots) ||
+          slots.some((slot) => typeof slot !== "string" || !/^[A-Z]$/u.test(slot))) {
+        return undefined;
+      }
+      return Array.from(new Set(slots));
+    } catch {
+      return undefined;
+    }
+  };
   let botState: TelegramBotStateSnapshot = { threadMode: "unknown" };
   let records = new Map<string, TelegramTopicTargetRecord>();
   let identities = new Map<string, TelegramThreadIdentityRecord>();
+  let workspaceBindings = new Map<string, TelegramWorkspaceThreadBinding>();
+  let workspaceRetirements: TelegramWorkspaceRetirementIntent[] = [];
+  let workspaceRetirementCommitInFlight = false;
+  const hasWorkspaceRetirementConflict = (input: {
+    bindingKey?: string;
+    cwd?: string;
+    target?: TelegramTarget;
+    slot?: string;
+  }): boolean => workspaceRetirements.some((intent) =>
+    (input.bindingKey !== undefined && intent.binding.bindingKey === input.bindingKey) ||
+    (input.cwd !== undefined && intent.binding.cwd === input.cwd) ||
+    (input.target !== undefined && targetMatches(intent.binding.target, input.target)) ||
+    (input.slot !== undefined && intent.binding.slot === input.slot),
+  );
+  let workspaceClaims = new Map<
+    string,
+    { identity: TelegramWorkspaceBindingIdentity; instanceId: string }
+  >();
   let reservations: TelegramThreadReservation[] = [];
   let pendingProvisions: TelegramThreadPendingProvision[] = [];
   let pendingCleanups: TelegramThreadCleanupIntent[] = [];
@@ -1220,6 +1706,19 @@ export function createTelegramTopicTargetStore(
     diagnostics?: Record<string, unknown>;
   } = {};
 
+  const reconcileWorkspaceSuffixExposure = (): void => {
+    const directoryCounts = new Map<string, number>();
+    const exposed = new Set<string>();
+    for (const binding of workspaceBindings.values()) {
+      directoryCounts.set(binding.cwd, (directoryCounts.get(binding.cwd) ?? 0) + 1);
+      if (binding.showSlotSuffix) exposed.add(binding.cwd);
+    }
+    for (const binding of workspaceBindings.values()) {
+      if ((directoryCounts.get(binding.cwd) ?? 0) > 1 || exposed.has(binding.cwd)) {
+        binding.showSlotSuffix = true;
+      }
+    }
+  };
   const rememberSlot = (slot: string | undefined, nowMs = getNowMs()) => {
     if (!slot || !/^[A-Z]$/.test(slot)) return;
     botState = { ...botState, lastSlot: slot, updatedAtMs: nowMs };
@@ -1234,9 +1733,84 @@ export function createTelegramTopicTargetStore(
       updatedAtMs: record.updatedAtMs,
     });
   };
+  const resolveWorkspaceKey = (cwd: string): string | undefined => {
+    const known = [
+      ...Array.from(workspaceBindings.values()),
+      ...Array.from(workspaceClaims.values()).map((claim) => claim.identity),
+    ];
+    const existing = known.find((binding) => binding.cwd === cwd);
+    if (existing) return existing.workspaceKey;
+    const readable = createTelegramWorkspaceDirectoryKey(cwd);
+    if (!readable) return undefined;
+    const collision = known.some(
+      (binding) =>
+        binding.workspaceKey === readable && binding.cwd !== cwd,
+    );
+    if (!collision) return readable;
+    const digest = createHash("sha256").update(cwd).digest("hex").slice(0, 12);
+    const prefix = readable.endsWith("--") ? readable.slice(0, -2) : readable;
+    return `${prefix.slice(0, TELEGRAM_WORKSPACE_KEY_MAX_LENGTH - digest.length - 3)}-${digest}--`;
+  };
+  const isWorkspaceTargetLive = (
+    binding: TelegramWorkspaceThreadBinding,
+  ): TelegramTopicTargetRecord | undefined =>
+    Array.from(records.values()).find(
+      (record) =>
+        isCurrentThreadRecord(record) &&
+        targetMatches(record.target, binding.target),
+    );
+  const findLegacyWorkspaceMigrationRecord = (
+    cwd: string,
+    instanceId: string,
+    previousInstanceId?: string,
+  ): TelegramTopicTargetRecord | undefined => {
+    const processIds = new Set(
+      [instanceId, previousInstanceId].filter(
+        (value): value is string => !!value,
+      ),
+    );
+    return Array.from(records.values())
+      .filter((record) => {
+        const owner = getRecordOwner(record);
+        const belongsToWorkspace =
+          owner.kind === "leader"
+            ? owner.cwd
+              ? normalizeTelegramWorkspacePath(owner.cwd) === cwd
+              : !!record.instanceId && Array.from(processIds).some((processId) =>
+                  isSameTelegramProcessInstance(record.instanceId, processId),
+                )
+            : owner.kind === "manual-follower" &&
+              (processIds.has(owner.instanceId) ||
+                (!!record.instanceId && processIds.has(record.instanceId)));
+        if (!belongsToWorkspace) return false;
+        const targetBinding = Array.from(workspaceBindings.values()).find(
+          (binding) => targetMatches(binding.target, record.target),
+        );
+        return !targetBinding || targetBinding.cwd === cwd;
+      })
+      .sort((left, right) => right.updatedAtMs - left.updatedAtMs)[0];
+  };
 
   const getPath = () =>
     typeof options.path === "function" ? options.path() : options.path;
+  const getTelegramProfile = () =>
+    typeof options.telegramProfile === "function"
+      ? options.telegramProfile()
+      : options.telegramProfile;
+  const scopeOwnerToActiveProfile = (
+    owner: TelegramThreadOwner,
+  ): TelegramThreadOwner => {
+    const telegramProfile = getTelegramProfile();
+    if (
+      !telegramProfile ||
+      owner.kind === "pending-topic" ||
+      owner.kind === "legacy" ||
+      owner.telegramProfile
+    ) {
+      return owner;
+    }
+    return { ...owner, telegramProfile };
+  };
   const getRecoveryPath = (path: string) => `${path}.provision-recovery.json`;
   const readProvisionRecoveries = (
     path: string,
@@ -1257,6 +1831,10 @@ export function createTelegramTopicTargetStore(
     botState = { threadMode: "unknown" };
     records = new Map();
     identities = new Map();
+    workspaceBindings = new Map();
+    workspaceRetirements = [];
+    workspaceRetirementCommitInFlight = false;
+    workspaceClaims = new Map();
     reservations = [];
     pendingProvisions = [];
     pendingCleanups = [];
@@ -1275,6 +1853,9 @@ export function createTelegramTopicTargetStore(
       botState = { threadMode: "unknown" };
       records = new Map();
       identities = new Map();
+      workspaceBindings = new Map();
+      workspaceRetirements = [];
+      workspaceRetirementCommitInFlight = false;
       reservations = [];
       pendingProvisions = [];
       pendingCleanups = [];
@@ -1292,18 +1873,37 @@ export function createTelegramTopicTargetStore(
     const file = parseTopicTargetFile(rawFile);
     followerRecoveryHints = parseFollowerRecoveryHints(rawFile);
     botState = file.bot;
+    const scopedRecords = file.threads.map((record) =>
+      cloneRecord({
+        ...record,
+        owner: scopeOwnerToActiveProfile(getRecordOwner(record)),
+      }),
+    );
     records = new Map(
-      file.threads.map((record) => [
-        getRecordOwnerKey(record),
-        cloneRecord(record),
-      ]),
+      scopedRecords.map((record) => [getRecordOwnerKey(record), record]),
     );
     identities = new Map(
-      (file.identities ?? []).map((identity) => [
-        identity.profileKey,
-        cloneIdentityRecord(identity),
+      (file.identities ?? []).map((identity) => {
+        const owner = scopeOwnerToActiveProfile(
+          getTelegramThreadOwnerFromProfileKey(identity.profileKey),
+        );
+        const profileKey = getTelegramThreadOwnerKey(owner);
+        return [
+          profileKey,
+          cloneIdentityRecord({ ...identity, profileKey }),
+        ];
+      }),
+    );
+    workspaceBindings = new Map(
+      (file.workspaceBindings ?? []).map((binding) => [
+        getWorkspaceBindingMapKey(binding),
+        cloneWorkspaceBinding(binding),
       ]),
     );
+    workspaceRetirements = (file.workspaceRetirements ?? []).map(
+      cloneWorkspaceRetirementIntent,
+    );
+    reconcileWorkspaceSuffixExposure();
     for (const record of records.values()) rememberIdentity(record);
     const nowMs = getNowMs();
     reservations = (file.reservations ?? [])
@@ -1364,8 +1964,6 @@ export function createTelegramTopicTargetStore(
         }
         if (!dirty || !loaded) await loadFromDisk();
         if (invalidation && !invalidation.isCurrent()) return false;
-        await mkdir(dirname(path), { recursive: true });
-        const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
         const nowMs = getNowMs();
         reservations = reservations.filter(
           (reservation) =>
@@ -1393,6 +1991,12 @@ export function createTelegramTopicTargetStore(
           bot: botState,
           ...statusSnapshot,
           identities: Array.from(identities.values()).map(cloneIdentityRecord),
+          workspaceBindings: Array.from(workspaceBindings.values()).map(
+            cloneWorkspaceBinding,
+          ),
+          workspaceRetirements: workspaceRetirements.map(
+            cloneWorkspaceRetirementIntent,
+          ),
           reservations: reservations.map((reservation) => ({ ...reservation })),
           pendingProvisions: pendingProvisions.map((provision) => ({
             ...provision,
@@ -1426,24 +2030,30 @@ export function createTelegramTopicTargetStore(
             lastReconcileAction: "mark-stale",
           });
         }
-        let persistedSemanticSnapshot: string | undefined;
+        let persistedSemanticSnapshot: Record<string, unknown> | undefined;
         try {
-          persistedSemanticSnapshot = serializeTelegramStateSemanticSnapshot(
+          persistedSemanticSnapshot = getTelegramStateSemanticSnapshot(
             JSON.parse(await readFile(path, "utf8")),
           );
         } catch {
           /* missing or invalid snapshots must be replaced */
         }
+        // Normalize optional fields to wire JSON; object key order is not a state change.
         if (
-          persistedSemanticSnapshot ===
-            serializeTelegramStateSemanticSnapshot(file) &&
+          isDeepStrictEqual(
+            persistedSemanticSnapshot,
+            getTelegramStateSemanticSnapshot(JSON.parse(JSON.stringify(file))),
+          ) &&
           mutationRevision === persistedRevision &&
           statusRevision === persistedStatusRevision
         ) {
+          loadedPath = path;
           loaded = true;
           dirty = false;
           return true;
         }
+        await mkdir(dirname(path), { recursive: true });
+        const tempPath = `${path}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`;
         await writeFile(tempPath, `${JSON.stringify(file, null, 2)}\n`, {
           encoding: "utf8",
           mode: 0o600,
@@ -1458,6 +2068,7 @@ export function createTelegramTopicTargetStore(
               // Fence and rename share one synchronous commit boundary. No stale
               // invalidation 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)));
               syncObservations = file.syncObservations;
               mutationRevision += 1;
@@ -1488,6 +2099,7 @@ export function createTelegramTopicTargetStore(
           await unlink(tempPath).catch(() => undefined);
           throw error;
         }
+        loadedPath = path;
         loaded = true;
         if (mutationRevision === persistedRevision) dirty = false;
         return true;
@@ -1678,6 +2290,620 @@ export function createTelegramTopicTargetStore(
       markDirty();
       return true;
     },
+    listWorkspaceBindings() {
+      return Array.from(workspaceBindings.values()).map(cloneWorkspaceBinding);
+    },
+    listWorkspaceRetirementIntents() {
+      return workspaceRetirements.map(cloneWorkspaceRetirementIntent);
+    },
+    commitWorkspaceJournalEvidence(expected, journalBindingKeys, complete) {
+      if (workspaceRetirementCommitInFlight || hasWorkspaceRetirementConflict(expected)) {
+        return undefined;
+      }
+      const key = getWorkspaceBindingMapKey(expected);
+      const current = workspaceBindings.get(key);
+      if (!current || !isDeepStrictEqual(current, expected) ||
+          !journalBindingKeys.every((bindingKey) =>
+            typeof bindingKey === "string" && bindingKey.length > 0 && bindingKey.length <= 512,
+          )) return undefined;
+      const keys = Array.from(new Set(journalBindingKeys));
+      if ((current.journalBindingsComplete === true) === complete &&
+          isDeepStrictEqual(current.journalBindingKeys ?? [], keys)) {
+        return cloneWorkspaceBinding(current);
+      }
+      const next = { ...current, updatedAtMs: getNowMs() };
+      if (keys.length) next.journalBindingKeys = keys;
+      else delete next.journalBindingKeys;
+      if (complete) next.journalBindingsComplete = true;
+      else delete next.journalBindingsComplete;
+      workspaceBindings.set(key, next);
+      markDirty();
+      return cloneWorkspaceBinding(next);
+    },
+    upsertWorkspaceRetirementIntent(intent) {
+      const next = normalizeWorkspaceRetirementIntent(intent);
+      if (!next) return false;
+      const current = workspaceBindings.get(getWorkspaceBindingMapKey(next.binding));
+      if (!current || !isDeepStrictEqual(current, next.binding)) return false;
+      const sameId = workspaceRetirements.find((candidate) => candidate.id === next.id);
+      if (sameId) return isDeepStrictEqual(sameId, next);
+      if (workspaceRetirements.some((candidate) =>
+        candidate.binding.bindingKey === next.binding.bindingKey ||
+        candidate.binding.slot === next.binding.slot ||
+        targetMatches(candidate.binding.target, next.binding.target),
+      )) return false;
+      workspaceRetirements.push(cloneWorkspaceRetirementIntent(next));
+      markDirty();
+      return true;
+    },
+    removeWorkspaceRetirementIntent(expected) {
+      const index = workspaceRetirements.findIndex((candidate) =>
+        isDeepStrictEqual(candidate, expected),
+      );
+      if (index < 0) return false;
+      workspaceRetirements.splice(index, 1);
+      markDirty();
+      return true;
+    },
+    async replaceWorkspaceRetirementIntent(expected, replacement, isCurrent) {
+      if (workspaceRetirementCommitInFlight || !isCurrent()) return false;
+      const previous = normalizeWorkspaceRetirementIntent(expected);
+      const next = normalizeWorkspaceRetirementIntent(replacement);
+      if (!previous || !next || previous.id !== next.id ||
+          previous.reason !== next.reason || previous.profileKey !== next.profileKey ||
+          previous.requestedAtMs !== next.requestedAtMs ||
+          !isDeepStrictEqual(previous.binding, next.binding)) return false;
+      const binding = workspaceBindings.get(getWorkspaceBindingMapKey(previous.binding));
+      const intentIndex = workspaceRetirements.findIndex((candidate) =>
+        isDeepStrictEqual(candidate, previous),
+      );
+      if (!binding || !isDeepStrictEqual(binding, previous.binding) || intentIndex < 0) {
+        return false;
+      }
+      if (isDeepStrictEqual(previous, next)) return true;
+      workspaceRetirementCommitInFlight = true;
+      workspaceRetirements[intentIndex] = cloneWorkspaceRetirementIntent(next);
+      markDirty();
+      const restoreInMemory = () => {
+        workspaceRetirements = workspaceRetirements.filter(
+          (candidate) => candidate.id !== previous.id,
+        );
+        workspaceRetirements.push(cloneWorkspaceRetirementIntent(previous));
+        markDirty();
+      };
+      try {
+        if (!isCurrent()) {
+          restoreInMemory();
+          return false;
+        }
+        const persisted = await persistSnapshot();
+        if (!persisted) {
+          restoreInMemory();
+          return false;
+        }
+        return true;
+      } catch (error) {
+        try {
+          await loadFromDisk();
+        } catch {
+          restoreInMemory();
+          throw error;
+        }
+        if (workspaceRetirements.some((candidate) => isDeepStrictEqual(candidate, next))) {
+          return true;
+        }
+        if (!workspaceRetirements.some((candidate) => isDeepStrictEqual(candidate, previous))) {
+          restoreInMemory();
+        }
+        throw error;
+      } finally {
+        workspaceRetirementCommitInFlight = false;
+      }
+    },
+    async commitInactiveWorkspaceCleanup(expected, isCurrent) {
+      if (workspaceRetirementCommitInFlight || !isCurrent()) return false;
+      const cleanupSnapshot = "bindingUpdatedAtMs" in expected ? expected : undefined;
+      const normalized = cleanupSnapshot ? undefined : normalizeWorkspaceBindingRecord(expected);
+      if (cleanupSnapshot && (!cleanupSnapshot.cwd || !cleanupSnapshot.workspaceKey ||
+          !cleanupSnapshot.instanceSlot || !cleanupSnapshot.slot || !cleanupSnapshot.bindingKey ||
+          !Number.isSafeInteger(cleanupSnapshot.inactiveSinceMs) ||
+          !Number.isSafeInteger(cleanupSnapshot.bindingUpdatedAtMs) ||
+          !Number.isSafeInteger(cleanupSnapshot.target.chatId) ||
+          !Number.isSafeInteger(cleanupSnapshot.target.threadId) || cleanupSnapshot.target.threadId <= 0)) return false;
+      if (!cleanupSnapshot && (!normalized?.slot || normalized.inactiveSinceMs === undefined)) return false;
+      const mapKey = getWorkspaceBindingMapKey((cleanupSnapshot ?? normalized)!);
+      const binding = workspaceBindings.get(mapKey);
+      if (!binding) return isCurrent();
+      const exact = cleanupSnapshot ? binding.cwd === cleanupSnapshot.cwd &&
+        binding.workspaceKey === cleanupSnapshot.workspaceKey &&
+        binding.instanceSlot === cleanupSnapshot.instanceSlot && binding.slot === cleanupSnapshot.slot &&
+        binding.bindingKey === cleanupSnapshot.bindingKey && targetMatches(binding.target, cleanupSnapshot.target) &&
+        binding.inactiveSinceMs === cleanupSnapshot.inactiveSinceMs &&
+        binding.updatedAtMs === cleanupSnapshot.bindingUpdatedAtMs : isDeepStrictEqual(binding, normalized);
+      if (!exact) return false;
+      const nowMs = getNowMs();
+      const targetOrSlotMatches = (candidate: { target?: TelegramTarget; slot?: string }) =>
+        (candidate.target && targetMatches(candidate.target, binding.target)) || candidate.slot === binding.slot;
+      const protectedLocally = Array.from(records.values()).some((record) =>
+        isCurrentThreadRecord(record) && targetOrSlotMatches(record)) ||
+        Array.from(workspaceClaims.values()).some((claim) =>
+          claim.identity.bindingKey === binding.bindingKey || claim.identity.slot === binding.slot) ||
+        reservations.some((reservation) =>
+          (reservation.expiresAtMs === undefined || reservation.expiresAtMs > nowMs) && targetOrSlotMatches(reservation)) ||
+        pendingProvisions.some((provision) =>
+          isPendingProvisionLiveOrTargeted(provision, nowMs) && targetOrSlotMatches(provision)) ||
+        pendingCleanups.some(targetOrSlotMatches) || workspaceRetirements.some((intent) =>
+          intent.binding.bindingKey === binding.bindingKey || targetOrSlotMatches(intent.binding));
+      if (protectedLocally) return false;
+      workspaceRetirementCommitInFlight = true;
+      workspaceBindings.delete(mapKey);
+      markDirty();
+      const restore = () => { workspaceBindings.set(mapKey, cloneWorkspaceBinding(binding)); markDirty(); };
+      try {
+        if (!isCurrent()) { restore(); return false; }
+        if (!await persistSnapshot()) { restore(); return false; }
+        return true;
+      } catch (error) {
+        try { await loadFromDisk(); } catch { restore(); throw error; }
+        if (!workspaceBindings.has(mapKey)) return true;
+        if (!isDeepStrictEqual(workspaceBindings.get(mapKey), binding)) restore();
+        throw error;
+      } finally { workspaceRetirementCommitInFlight = false; }
+    },
+    async commitWorkspaceRetirement(expected, isCurrent) {
+      if (workspaceRetirementCommitInFlight || !isCurrent()) return false;
+      const normalized = normalizeWorkspaceRetirementIntent(expected);
+      if (!normalized) return false;
+      const mapKey = getWorkspaceBindingMapKey(normalized.binding);
+      const binding = workspaceBindings.get(mapKey);
+      const intentIndex = workspaceRetirements.findIndex((candidate) =>
+        isDeepStrictEqual(candidate, normalized),
+      );
+      if (!binding || !isDeepStrictEqual(binding, normalized.binding) || intentIndex < 0) {
+        return false;
+      }
+      const nowMs = getNowMs();
+      const targetOrSlotMatches = (candidate: {
+        target?: TelegramTarget;
+        slot?: string;
+      }) =>
+        (candidate.target && targetMatches(candidate.target, binding.target)) ||
+        candidate.slot === binding.slot;
+      const locallyProtected =
+        Array.from(records.values()).some((record) =>
+          isCurrentThreadRecord(record) && targetOrSlotMatches(record),
+        ) ||
+        Array.from(workspaceClaims.values()).some((claim) =>
+          claim.identity.bindingKey === binding.bindingKey ||
+          claim.identity.slot === binding.slot,
+        ) ||
+        reservations.some((reservation) =>
+          (reservation.expiresAtMs === undefined || reservation.expiresAtMs > nowMs) &&
+          targetOrSlotMatches(reservation),
+        ) ||
+        pendingProvisions.some((provision) =>
+          isPendingProvisionLiveOrTargeted(provision, nowMs) &&
+          targetOrSlotMatches(provision),
+        ) ||
+        pendingCleanups.some(targetOrSlotMatches) ||
+        workspaceRetirements.some((candidate, index) =>
+          index !== intentIndex &&
+          (candidate.binding.bindingKey === binding.bindingKey ||
+            targetOrSlotMatches(candidate.binding)),
+        );
+      if (locallyProtected) return false;
+      const previousRetirements = workspaceRetirements.map(
+        cloneWorkspaceRetirementIntent,
+      );
+      workspaceRetirementCommitInFlight = true;
+      workspaceBindings.delete(mapKey);
+      workspaceRetirements.splice(intentIndex, 1);
+      markDirty();
+      const restoreInMemory = () => {
+        workspaceBindings.set(mapKey, cloneWorkspaceBinding(binding));
+        workspaceRetirements = previousRetirements.map(
+          cloneWorkspaceRetirementIntent,
+        );
+        markDirty();
+      };
+      try {
+        if (!isCurrent()) {
+          restoreInMemory();
+          return false;
+        }
+        const persisted = await persistSnapshot();
+        if (!persisted) {
+          restoreInMemory();
+          return false;
+        }
+        return true;
+      } catch (error) {
+        try {
+          await loadFromDisk();
+        } catch {
+          restoreInMemory();
+          throw error;
+        }
+        const committed = !workspaceBindings.has(mapKey) &&
+          !workspaceRetirements.some((candidate) => candidate.id === normalized.id);
+        if (committed) return true;
+        if (!workspaceBindings.has(mapKey) ||
+            !workspaceRetirements.some((candidate) => candidate.id === normalized.id)) {
+          restoreInMemory();
+        }
+        throw error;
+      } finally {
+        workspaceRetirementCommitInFlight = false;
+      }
+    },
+    captureWorkspaceSlotOccupancy(getExternalProtection, options) {
+      const nowMs = getNowMs();
+      const bindings = Array.from(workspaceBindings.values()).map((binding) => {
+        const slot = binding.slot?.toLowerCase() ?? "";
+        const targetOrSlotMatches = (candidate: {
+          target?: TelegramTarget;
+          slot?: string;
+        }) =>
+          (candidate.target && targetMatches(candidate.target, binding.target)) ||
+          (!!binding.slot && candidate.slot === binding.slot);
+        const locallyProtected =
+          Array.from(records.values()).some((record) =>
+            isCurrentThreadRecord(record) && targetOrSlotMatches(record),
+          ) ||
+          Array.from(workspaceClaims.values()).some((claim) =>
+            claim.identity.bindingKey === binding.bindingKey ||
+            (!!binding.slot && claim.identity.slot === binding.slot),
+          ) ||
+          reservations.some((reservation) =>
+            (reservation.expiresAtMs === undefined || reservation.expiresAtMs > nowMs) &&
+            targetOrSlotMatches(reservation),
+          ) ||
+          pendingProvisions.some((provision) =>
+            isPendingProvisionLiveOrTargeted(provision, nowMs) &&
+            targetOrSlotMatches(provision),
+          ) ||
+          pendingCleanups.some((intent) => targetOrSlotMatches(intent)) ||
+          workspaceRetirements.some((intent) =>
+            !isDeepStrictEqual(intent, options?.expectedRetirement) &&
+            (intent.binding.bindingKey === binding.bindingKey ||
+              targetOrSlotMatches(intent.binding)),
+          );
+        const externalProtection = getExternalProtection(cloneWorkspaceBinding(binding));
+        const externalStates = [
+          externalProtection.liveOwner,
+          externalProtection.acceptedWork,
+          externalProtection.deliveryAuthority,
+        ];
+        const hasValidInactivity = binding.inactiveSinceMs !== undefined &&
+          Number.isFinite(binding.inactiveSinceMs) &&
+          binding.inactiveSinceMs >= 0 && binding.inactiveSinceMs <= nowMs;
+        const protection: TelegramWorkspaceSlotOccupancy["protection"] =
+          locallyProtected || externalStates.includes("protected")
+          ? "protected"
+          : externalStates.every((state) => state === "clear") && hasValidInactivity
+            ? "eligible"
+            : "unknown";
+        return {
+          bindingKey: binding.bindingKey,
+          slot,
+          ...(binding.inactiveSinceMs !== undefined
+            ? { inactiveSinceMs: binding.inactiveSinceMs }
+            : {}),
+          protection,
+        };
+      });
+      const localReservedSlots = [
+        ...Array.from(workspaceClaims.values()).map((claim) => claim.identity.slot),
+        ...Array.from(records.values()).filter(isCurrentThreadRecord).map((record) => record.slot),
+        ...reservations.filter((reservation) =>
+          reservation.expiresAtMs === undefined || reservation.expiresAtMs > nowMs,
+        ).map((reservation) => reservation.slot),
+        ...pendingProvisions.filter((provision) =>
+          isPendingProvisionLiveOrTargeted(provision, nowMs),
+        ).map((provision) => provision.slot),
+      ].filter((slot): slot is string => !!slot && /^[A-Z]$/u.test(slot))
+        .map((slot) => slot.toLowerCase());
+      const externalReservedSlots = captureExternalReservedSlots();
+      const reservedSlots = externalReservedSlots
+        ? [
+            ...localReservedSlots,
+            ...externalReservedSlots.map((slot) => slot.toLowerCase()),
+          ]
+        : [...localReservedSlots, "invalid"];
+      return { bindings, reservedSlots };
+    },
+    hasWorkspaceBinding(cwd) {
+      const normalizedCwd = normalizeTelegramWorkspacePath(cwd);
+      return !!normalizedCwd && Array.from(workspaceBindings.values()).some(
+        (binding) => binding.cwd === normalizedCwd,
+      );
+    },
+    setWorkspaceDisplayTitle(expected, title) {
+      if (hasWorkspaceRetirementConflict(expected)) return false;
+      const key = getWorkspaceBindingMapKey(expected);
+      const current = workspaceBindings.get(key);
+      if (!current || !isDeepStrictEqual(current, expected) || !title.trim() ||
+          title.length > 128) return false;
+      if (current.displayTitle === title) return true;
+      workspaceBindings.set(key, { ...current, displayTitle: title });
+      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;
+    },
+    markWorkspaceBindingActiveByTarget(target) {
+      if (hasWorkspaceRetirementConflict({ target })) return false;
+      for (const [key, binding] of workspaceBindings) {
+        if (!targetMatches(binding.target, target) || binding.inactiveSinceMs === undefined) continue;
+        const next = { ...binding };
+        delete next.inactiveSinceMs;
+        workspaceBindings.set(key, next);
+        markDirty();
+        return true;
+      }
+      return false;
+    },
+    getWorkspaceBinding(cwd, instanceSlot = "a") {
+      const normalizedCwd = normalizeTelegramWorkspacePath(cwd);
+      if (!normalizedCwd || !/^[a-z]+$/u.test(instanceSlot)) return undefined;
+      const binding = workspaceBindings.get(
+        getWorkspaceBindingMapKey({ cwd: normalizedCwd, instanceSlot }),
+      );
+      return binding ? cloneWorkspaceBinding(binding) : undefined;
+    },
+    claimWorkspaceIdentity(cwd, instanceId, previousInstanceId, options) {
+      if (workspaceRetirementCommitInFlight) return undefined;
+      const normalizedCwd = normalizeTelegramWorkspacePath(cwd);
+      if (!normalizedCwd || !instanceId ||
+          hasWorkspaceRetirementConflict({ cwd: normalizedCwd })) return undefined;
+      const externalReservedSlots = captureExternalReservedSlots();
+      if (!externalReservedSlots) {
+        options?.onCapacityUnavailable?.();
+        return undefined;
+      }
+      const externalReservedSlotKeys = externalReservedSlots.map((slot) =>
+        slot.toLowerCase(),
+      );
+      for (const claim of workspaceClaims.values()) {
+        if (claim.instanceId !== instanceId) continue;
+        if (claim.identity.cwd !== normalizedCwd || !claim.identity.slot ||
+            externalReservedSlotKeys.includes(claim.identity.slot.toLowerCase())) {
+          return undefined;
+        }
+        if (
+          options?.existingBindingOnly &&
+          !workspaceBindings.has(getWorkspaceBindingMapKey(claim.identity))
+        ) return undefined;
+        return { ...claim.identity };
+      }
+      const workspaceKey = resolveWorkspaceKey(normalizedCwd);
+      if (!workspaceKey) return undefined;
+      let legacyRecord = findLegacyWorkspaceMigrationRecord(
+        normalizedCwd,
+        instanceId,
+        previousInstanceId,
+      );
+      const legacyTarget = legacyRecord?.target;
+      const targetBinding = legacyTarget
+        ? Array.from(workspaceBindings.values()).find(
+            (binding) =>
+              binding.cwd === normalizedCwd &&
+              targetMatches(binding.target, legacyTarget),
+          )
+        : undefined;
+      let capacityUnavailable = false;
+      const claimIdentity = (
+        identity: TelegramWorkspaceBindingIdentity,
+      ): TelegramWorkspaceBindingIdentity | undefined => {
+        const mapKey = getWorkspaceBindingMapKey(identity);
+        const existingClaim = workspaceClaims.get(mapKey);
+        if (existingClaim) {
+          return existingClaim.instanceId === instanceId
+            ? { ...existingClaim.identity }
+            : undefined;
+        }
+        const binding = workspaceBindings.get(mapKey);
+        const liveRecord = binding
+          ? isWorkspaceTargetLive(binding)
+          : undefined;
+        if (
+          liveRecord &&
+          liveRecord.instanceId !== instanceId &&
+          liveRecord.instanceId !== previousInstanceId
+        ) {
+          return undefined;
+        }
+        const retainedTarget = binding?.target ?? legacyRecord?.target;
+        const retainedSlot = binding?.slot ?? legacyRecord?.slot;
+        const otherBindings = Array.from(workspaceBindings.values())
+          .filter((other) => other.bindingKey !== identity.bindingKey && other.slot)
+          .map((other) => ({
+            bindingKey: other.bindingKey,
+            slot: other.slot!.toLowerCase(),
+            protection: "unknown" as const,
+          }));
+        const nowMs = getNowMs();
+        const reservedSlots = [
+          ...Array.from(workspaceClaims.values()).map((claim) => claim.identity.slot),
+          ...Array.from(records.values())
+            .filter((record) => isCurrentThreadRecord(record) &&
+              !(retainedTarget && targetMatches(record.target, retainedTarget)))
+            .map((record) => record.slot),
+          ...reservations.filter((reservation) =>
+            reservation.expiresAtMs === undefined || reservation.expiresAtMs > nowMs,
+          ).map((reservation) => reservation.slot),
+          ...pendingProvisions.filter((provision) =>
+            isPendingProvisionLiveOrTargeted(provision, nowMs),
+          ).map((provision) => provision.slot),
+          ...externalReservedSlots,
+        ].filter((slot): slot is string => !!slot).map((slot) => slot.toLowerCase());
+        const retainedSlotKey = retainedSlot?.toLowerCase();
+        if (retainedSlotKey && reservedSlots.includes(retainedSlotKey)) return undefined;
+        const retainedSlotConflicts = !!retainedSlotKey &&
+          otherBindings.some((other) => other.slot === retainedSlotKey);
+        let slot = retainedSlotConflicts
+          ? Array.from(TELEGRAM_WORKSPACE_SLOTS).find((candidate) =>
+              !reservedSlots.includes(candidate) &&
+              !otherBindings.some((other) => other.slot === candidate),
+            )?.toUpperCase()
+          : retainedSlot;
+        if (!slot) {
+          const allocation = planTelegramWorkspaceSlotAllocation({
+            bindings: otherBindings,
+            reservedSlots,
+            nowMs,
+          });
+          if (allocation.kind === "blocked" && allocation.reason === "invalid-state") {
+            return undefined;
+          }
+          if (allocation.kind !== "free") {
+            capacityUnavailable = true;
+            return undefined;
+          }
+          slot = allocation.slot.toUpperCase();
+        }
+        if (!slot || !/^[A-Z]$/u.test(slot)) return undefined;
+        const claimedIdentity = { ...identity, slot };
+        workspaceClaims.set(mapKey, { identity: claimedIdentity, instanceId });
+        return { ...claimedIdentity };
+      };
+      if (options?.existingBindingOnly) {
+        const candidates = Array.from(workspaceBindings.values())
+          .filter((binding) => binding.cwd === normalizedCwd)
+          .sort((left, right) =>
+            left.instanceSlot.length - right.instanceSlot.length ||
+            left.instanceSlot.localeCompare(right.instanceSlot),
+          );
+        for (const binding of candidates) {
+          const claimed = claimIdentity({
+            cwd: binding.cwd,
+            workspaceKey: binding.workspaceKey,
+            instanceSlot: binding.instanceSlot,
+            bindingKey: binding.bindingKey,
+          });
+          if (claimed) return claimed;
+        }
+        if (!legacyRecord) return undefined;
+      }
+      if (targetBinding) {
+        const claimed = claimIdentity({
+          cwd: targetBinding.cwd,
+          workspaceKey: targetBinding.workspaceKey,
+          instanceSlot: targetBinding.instanceSlot,
+          bindingKey: targetBinding.bindingKey,
+        });
+        if (claimed) return claimed;
+        if (options?.existingBindingOnly) return undefined;
+        // A migrated live peer is not a handoff or a target for another slot.
+        legacyRecord = undefined;
+      }
+      const attemptLimit = workspaceBindings.size + workspaceClaims.size + 1;
+      for (let ordinal = 0; ordinal < attemptLimit; ordinal += 1) {
+        const identity = createTelegramWorkspaceBindingIdentityWithKey(
+          normalizedCwd,
+          workspaceKey,
+          ordinal,
+        );
+        if (!identity) return undefined;
+        const mapKey = getWorkspaceBindingMapKey(identity);
+        const binding = workspaceBindings.get(mapKey);
+        if (legacyRecord && binding) continue;
+        const claimed = claimIdentity(identity);
+        if (!claimed) continue;
+        if (legacyRecord && !binding) {
+          workspaceBindings.set(mapKey, {
+            ...identity,
+            target: { ...legacyRecord.target },
+            ...(legacyRecord.threadName
+              ? { threadName: legacyRecord.threadName }
+              : {}),
+            ...(legacyRecord.slot ? { slot: legacyRecord.slot } : {}),
+            updatedAtMs: getNowMs(),
+          });
+          reconcileWorkspaceSuffixExposure();
+          markDirty();
+        }
+        return claimed;
+      }
+      if (capacityUnavailable) options?.onCapacityUnavailable?.();
+      return undefined;
+    },
+    releaseWorkspaceClaim(instanceId) {
+      let released = false;
+      for (const [key, claim] of workspaceClaims) {
+        if (claim.instanceId !== instanceId) continue;
+        workspaceClaims.delete(key);
+        released = true;
+      }
+      return released;
+    },
+    upsertWorkspaceBinding(binding, claimInstanceId) {
+      if (workspaceRetirementCommitInFlight) return undefined;
+      const next = normalizeWorkspaceBindingRecord(binding);
+      if (next && hasWorkspaceRetirementConflict(next)) return undefined;
+      if (!next) return undefined;
+      if (next.slot && Array.from(workspaceBindings.values()).some((existing) =>
+        existing.bindingKey !== next.bindingKey && existing.slot === next.slot,
+      )) return undefined;
+      for (const existing of workspaceBindings.values()) {
+        if (
+          existing.workspaceKey === next.workspaceKey &&
+          existing.cwd !== next.cwd
+        ) {
+          return undefined;
+        }
+      }
+      const nextMapKey = getWorkspaceBindingMapKey(next);
+      const previous = workspaceBindings.get(nextMapKey);
+      if (previous?.showSlotSuffix) next.showSlotSuffix = true;
+      if (previous?.manualThreadName && !next.manualThreadName) {
+        next.manualThreadName = previous.manualThreadName;
+      }
+      if (previous) {
+        const journalBindingKeys = Array.from(new Set([
+          ...(previous.journalBindingKeys ?? []),
+          ...(next.journalBindingKeys ?? []),
+        ]));
+        if (journalBindingKeys.length) next.journalBindingKeys = journalBindingKeys;
+        else delete next.journalBindingKeys;
+        if (previous.journalBindingsComplete) next.journalBindingsComplete = true;
+        else delete next.journalBindingsComplete;
+      }
+      if (previous && !targetMatches(previous.target, next.target)) {
+        delete next.displayTitle;
+        delete next.inactiveSinceMs;
+      } else if (previous) {
+        if (previous.displayTitle) next.displayTitle = previous.displayTitle;
+        if (previous.inactiveSinceMs !== undefined) next.inactiveSinceMs = previous.inactiveSinceMs;
+      }
+      const claim = workspaceClaims.get(nextMapKey);
+      if (claimInstanceId) {
+        if (claim?.instanceId !== claimInstanceId) return undefined;
+        if (next.slot !== undefined && claim.identity.slot !== next.slot) return undefined;
+        next.slot = claim.identity.slot;
+      } else if (claim) {
+        return undefined;
+      }
+      for (const [key, existing] of workspaceBindings) {
+        if (key === nextMapKey) continue;
+        if (targetMatches(existing.target, next.target)) {
+          workspaceBindings.delete(key);
+        }
+      }
+      workspaceBindings.set(nextMapKey, next);
+      reconcileWorkspaceSuffixExposure();
+      if (claim) workspaceClaims.delete(nextMapKey);
+      markDirty();
+      return cloneWorkspaceBinding(next);
+    },
     upsert(record) {
       const next = cloneRecord(record);
       const nextOwnerKey = getRecordOwnerKey(next);
@@ -1735,27 +2961,31 @@ export function createTelegramTopicTargetStore(
       return count;
     },
     markStaleByTarget(target, syncStatus = "unknown", lastSyncError) {
-      for (const record of Array.from(records.values())) {
-        if (!targetMatches(record.target, target)) continue;
-        const nowMs = getNowMs();
-        syncObservations = syncObservations.filter(
-          (observation) => !targetMatches(observation.target, record.target),
-        );
-        syncObservations.push({
-          target: record.target,
-          syncStatus,
-          observedAtMs: nowMs,
-          ...(record.instanceId ? { instanceId: record.instanceId } : {}),
-          ...(record.slot ? { slot: record.slot } : {}),
-          ...(lastSyncError ? { lastSyncError } : {}),
-          lastReconcileAction: "mark-stale",
-        });
+      const record = Array.from(records.values()).find((entry) => targetMatches(entry.target, target));
+      const pending = syncStatus === "deleted" ? pendingProvisions.find((entry) =>
+        entry.target && targetMatches(entry.target, target),
+      ) : undefined;
+      const source = record ?? pending;
+      if (!source?.target) return false;
+      syncObservations = syncObservations.filter((entry) => !targetMatches(entry.target, target));
+      syncObservations.push({
+        target: { ...source.target }, syncStatus, observedAtMs: getNowMs(),
+        ...(source.instanceId ? { instanceId: source.instanceId } : {}),
+        ...(source.slot ? { slot: source.slot } : {}),
+        ...(lastSyncError ? { lastSyncError } : {}),
+        lastReconcileAction: "mark-stale",
+      });
+      if (record) {
         rememberIdentity(record);
         records.delete(getRecordOwnerKey(record));
-        markDirty();
-        return true;
       }
-      return false;
+      if (syncStatus === "deleted") {
+        pendingProvisions = pendingProvisions.filter((entry) =>
+          !entry.target || !targetMatches(entry.target, target),
+        );
+      }
+      markDirty();
+      return true;
     },
     markActiveByTarget(target) {
       const nowMs = getNowMs();
@@ -1773,16 +3003,45 @@ export function createTelegramTopicTargetStore(
       }
       return false;
     },
-    renameByTarget(target, threadName) {
+    renameByTarget(target, threadName, options) {
+      if (hasWorkspaceRetirementConflict({ target })) return undefined;
       const nowMs = getNowMs();
       const normalizedThreadName =
         normalizeTelegramTopicTargetThreadName(threadName);
       if (!normalizedThreadName) return undefined;
       for (const record of records.values()) {
         if (!targetMatches(record.target, target)) continue;
-        record.threadName = normalizedThreadName;
+        record.manualThreadName = normalizedThreadName;
         record.updatedAtMs = nowMs;
-        rememberIdentity(record);
+        for (const binding of workspaceBindings.values()) {
+          if (!targetMatches(binding.target, target)) continue;
+          const previousTitle = binding.displayTitle ?? binding.manualThreadName ??
+            binding.threadName;
+          binding.manualThreadName = normalizedThreadName;
+          binding.displayTitle = options?.updateDisplayTitle === false
+            ? previousTitle : normalizedThreadName;
+          binding.updatedAtMs = nowMs;
+        }
+        markDirty();
+        return cloneRecord(record);
+      }
+      return undefined;
+    },
+    clearManualNameByTarget(target, automaticTitle) {
+      if (hasWorkspaceRetirementConflict({ target })) return undefined;
+      const title = normalizeTelegramTopicTargetThreadName(automaticTitle);
+      if (!title) return undefined;
+      const nowMs = getNowMs();
+      for (const record of records.values()) {
+        if (!targetMatches(record.target, target)) continue;
+        delete record.manualThreadName;
+        record.updatedAtMs = nowMs;
+        for (const binding of workspaceBindings.values()) {
+          if (!targetMatches(binding.target, target)) continue;
+          delete binding.manualThreadName;
+          binding.displayTitle = title;
+          binding.updatedAtMs = nowMs;
+        }
         markDirty();
         return cloneRecord(record);
       }
@@ -1793,9 +3052,9 @@ export function createTelegramTopicTargetStore(
       const candidates = Array.from(records.values())
         .filter((record) => {
           if (record.instanceId) return false;
+          if (!record.slot || !/^[A-Z]$/u.test(record.slot)) return false;
           if (record.slot === "A") return false;
           if (record.status !== "pending") return false;
-          if (!record.slot) return true;
           return !Array.from(records.values()).some(
             (other) =>
               other !== record &&
@@ -1825,17 +3084,64 @@ export function createTelegramTopicTargetStore(
       markDirty();
       return cloneRecord(record);
     },
-    allocateSlot(profileKey, preferredSlot) {
+    allocateSlot(profileKey, preferredSlot, workspaceBindingKey, options) {
+      if (workspaceRetirementCommitInFlight) return undefined;
+      const externalReservedSlots = captureExternalReservedSlots();
+      if (!externalReservedSlots) return undefined;
+      const isExternalSlotOccupied = (slot: string): boolean =>
+        externalReservedSlots.includes(slot);
       const ownerKey = getTelegramThreadOwnerKey(
         getTelegramThreadOwnerFromProfileKey(profileKey),
       );
       const existing = records.get(ownerKey) ?? records.get(profileKey);
-      if (existing?.slot && isCurrentThreadRecord(existing)) {
-        return existing.slot;
-      }
       const nowMs = getNowMs();
+      const isWorkspaceSlotOccupied = (slot: string): boolean =>
+        Array.from(workspaceBindings.values()).some((binding) =>
+          binding.bindingKey !== workspaceBindingKey && binding.slot === slot,
+        );
+      const isWorkspaceClaimSlotOccupied = (slot: string): boolean =>
+        Array.from(workspaceClaims.values()).some((claim) =>
+          claim.identity.bindingKey !== workspaceBindingKey &&
+          claim.identity.slot === slot,
+        );
+      if (existing?.slot && isCurrentThreadRecord(existing) &&
+          !options?.excludeCurrentRecord) {
+        const bindingConflict = Array.from(workspaceBindings.values()).some(
+          (binding) => binding.bindingKey !== workspaceBindingKey &&
+            binding.slot === existing.slot &&
+            !targetMatches(binding.target, existing.target),
+        );
+        const claimConflict = Array.from(workspaceClaims.values()).some(
+          (claim) => claim.identity.bindingKey !== workspaceBindingKey &&
+            claim.identity.slot === existing.slot &&
+            claim.instanceId !== existing.instanceId,
+        );
+        return bindingConflict || claimConflict ||
+          isExternalSlotOccupied(existing.slot) ? undefined : existing.slot;
+      }
+      if (workspaceBindingKey) {
+        const claim = Array.from(workspaceClaims.values()).find((claim) =>
+          claim.identity.bindingKey === workspaceBindingKey,
+        );
+        const slot = claim?.identity.slot;
+        if (!slot) return undefined;
+        const foreignClaim = Array.from(workspaceClaims.values()).some((other) =>
+          other !== claim && other.identity.slot === slot,
+        );
+        const foreignBinding = Array.from(workspaceBindings.values()).some((binding) =>
+          binding.bindingKey !== workspaceBindingKey && binding.slot === slot,
+        );
+        if (foreignClaim || foreignBinding || isExternalSlotOccupied(slot) ||
+            isTelegramTopicTargetSlotOccupied(
+              slot, records, reservations, pendingProvisions, nowMs,
+            )) return undefined;
+        return slot;
+      }
       if (
         preferredSlot &&
+        !isExternalSlotOccupied(preferredSlot) &&
+        !isWorkspaceSlotOccupied(preferredSlot) &&
+        !isWorkspaceClaimSlotOccupied(preferredSlot) &&
         !isTelegramTopicTargetSlotOccupied(
           preferredSlot,
           records,
@@ -1846,13 +3152,25 @@ export function createTelegramTopicTargetStore(
       ) {
         return preferredSlot;
       }
-      return getNextMonotonicSlot(
+      const next = getNextMonotonicSlot(
         records,
         reservations,
         pendingProvisions,
         nowMs,
         botState.lastSlot,
       );
+      if (next && !isExternalSlotOccupied(next) &&
+          !isWorkspaceSlotOccupied(next) &&
+          !isWorkspaceClaimSlotOccupied(next)) return next;
+      return Array.from(TELEGRAM_WORKSPACE_SLOTS, (slot) => slot.toUpperCase())
+        .find((slot) =>
+          !isExternalSlotOccupied(slot) &&
+          !isWorkspaceSlotOccupied(slot) &&
+          !isWorkspaceClaimSlotOccupied(slot) &&
+          !isTelegramTopicTargetSlotOccupied(
+            slot, records, reservations, pendingProvisions, nowMs,
+          ),
+        );
     },
   };
 }
@@ -1944,15 +3262,58 @@ const TELEGRAM_THREAD_NAME_PALETTE: Record<string, readonly string[]> = {
   Z: ["Zenith", "Zephyr", "Zircon", "Zebra", "Zion"],
 };
 
+export function listOccupiedTelegramThreadIdentities(input: {
+  records: readonly TelegramTopicTargetRecord[];
+  workspaceBindings?: readonly TelegramWorkspaceThreadBinding[];
+  pendingProvisions?: readonly TelegramThreadPendingProvision[];
+  exceptTarget?: TelegramTarget;
+  exceptWorkspaceBindingKey?: string;
+}): string[] {
+  const occupied = new Set<string>();
+  const add = (threadName: string | undefined): void => {
+    if (!threadName) return;
+    occupied.add(getTelegramTopicIdentityName(threadName));
+  };
+  for (const record of input.records) {
+    if (!isCurrentThreadRecord(record)) continue;
+    if (input.exceptTarget && targetMatches(record.target, input.exceptTarget))
+      continue;
+    add(record.manualThreadName);
+    add(record.threadName);
+  }
+  for (const binding of input.workspaceBindings ?? []) {
+    if (binding.bindingKey === input.exceptWorkspaceBindingKey) continue;
+    if (input.exceptTarget && targetMatches(binding.target, input.exceptTarget))
+      continue;
+    add(binding.manualThreadName);
+    add(binding.threadName);
+  }
+  for (const pending of input.pendingProvisions ?? []) {
+    if (
+      input.exceptTarget &&
+      pending.target &&
+      targetMatches(pending.target, input.exceptTarget)
+    ) {
+      continue;
+    }
+    add(pending.threadName);
+  }
+  return Array.from(occupied);
+}
+
 export function chooseTelegramThreadName(input: {
   slot: string | undefined;
   entropy?: number | string;
   getRandom?: () => number;
+  occupied?: readonly string[];
 }): string | undefined {
   if (!input.slot || !/^[A-Z]$/.test(input.slot)) return undefined;
   const names = TELEGRAM_THREAD_NAME_PALETTE[input.slot];
   if (!names || names.length === 0) return undefined;
-  const index = input.getRandom
+  const occupied = new Set(
+    (input.occupied ?? []).map((name) => getTelegramTopicIdentityName(name)),
+  );
+  const start = input.getRandom
     ? Math.max(
         0,
         Math.min(
@@ -1961,7 +3322,16 @@ export function chooseTelegramThreadName(input: {
         ),
       )
     : getTelegramThreadNameEntropyIndex(input.entropy, names.length);
-  return names[index];
+  for (let offset = 0; offset < names.length; offset += 1) {
+    const name = names[(start + offset) % names.length];
+    if (!occupied.has(getTelegramTopicIdentityName(name))) return name;
+  }
+  for (const paletteSlot of "ABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+    for (const name of TELEGRAM_THREAD_NAME_PALETTE[paletteSlot] ?? []) {
+      if (!occupied.has(getTelegramTopicIdentityName(name))) return name;
+    }
+  }
+  return undefined;
 }
 
 function getTelegramThreadNameLeadingSlot(
@@ -1972,32 +3342,6 @@ function getTelegramThreadNameLeadingSlot(
   return first && /^[A-Z]$/.test(first) ? first : undefined;
 }
 
-function isTelegramSlotOccupiedByOtherCurrentRecord(
-  records: readonly TelegramTopicTargetRecord[],
-  slot: string,
-  currentRecord: TelegramTopicTargetRecord,
-): boolean {
-  return records.some(
-    (record) =>
-      !targetMatches(record.target, currentRecord.target) &&
-      isCurrentThreadRecord(record) &&
-      record.slot === slot,
-  );
-}
-
-function normalizeCurrentThreadNameSlots(
-  store: Pick<TelegramTopicTargetStore, "list" | "upsert">,
-): void {
-  for (const record of store.list()) {
-    if (!isCurrentThreadRecord(record)) continue;
-    const slot = getTelegramThreadNameLeadingSlot(record.threadName);
-    if (!slot || record.slot === slot) continue;
-    if (isTelegramSlotOccupiedByOtherCurrentRecord(store.list(), slot, record))
-      continue;
-    store.upsert({ ...record, slot });
-  }
-}
-
 function getNextTelegramThreadNamePaletteSlot(
   records: readonly TelegramTopicTargetRecord[],
   fallbackSlot: string | undefined,
@@ -2049,13 +3393,29 @@ export function getTelegramTopicThreadNameValidationError(
   if (genericLabels.has(identity.toLowerCase())) {
     reasons.push("it is a generic role label");
   }
-  if (/^[A-Z]$/.test(identity)) {
-    reasons.push("it is only a bare slot letter");
-  }
+  if (/^[A-Z]$/.test(identity)) reasons.push("it is only a bare slot letter");
   if (reasons.length === 0) return undefined;
   return `Invalid Telegram instance name: ${reasons.join("; ")}. Use exactly one capitalized Latin word with no spaces, punctuation, emoji, non-Latin letters, or digits; it must not be a generic role label or only a bare slot letter.`;
 }
 
+export function getTelegramManualThreadDisplayNameValidationError(
+  threadName: string,
+): string | undefined {
+  const trimmed = threadName.trim();
+  const normalized = trimmed.replace(/\s+/g, " ");
+  const reasons: string[] = [];
+  if (!trimmed) reasons.push("it is empty after trimming");
+  if (trimmed && /[^\x20-\x7E]/.test(trimmed)) {
+    reasons.push("it contains characters outside printable ASCII");
+  }
+  if (normalized.length > 96) reasons.push("it is longer than 96 characters");
+  if (/^[A-Z]$/.test(normalized)) {
+    reasons.push("a bare slot letter is reserved for reset to automatic");
+  }
+  if (reasons.length === 0) return undefined;
+  return `Invalid Telegram Thread display name: ${reasons.join("; ")}. Use 1–96 printable ASCII characters.`;
+}
+
 export function isTelegramTopicThreadNameValidForSlot(
   threadName: string,
   slot: string | undefined,
@@ -2121,6 +3481,35 @@ export async function promoteTelegramFollowerBindingToLeader(
         record.target.chatId === target.chatId &&
         record.target.threadId === target.threadId,
     );
+  const workspaceIdentity = deps.cwd
+    ? deps.store.claimWorkspaceIdentity(deps.cwd, deps.instanceId,
+        existing?.instanceId, { existingBindingOnly: true })
+    : undefined;
+  const workspaceBinding = workspaceIdentity
+    ? deps.store.getWorkspaceBinding(
+        workspaceIdentity.cwd, workspaceIdentity.instanceSlot,
+      )
+    : undefined;
+  const exactWorkspaceBinding = workspaceBinding &&
+    targetMatches(workspaceBinding.target, target)
+    ? workspaceBinding : undefined;
+  const slot = existing
+    ? deps.store.allocateSlot(existing.profileKey)
+    : exactWorkspaceBinding ? workspaceIdentity?.slot : undefined;
+  if (!slot || (deps.slot && deps.slot !== slot)) {
+    deps.store.releaseWorkspaceClaim(deps.instanceId);
+    return undefined;
+  }
+  if (exactWorkspaceBinding && exactWorkspaceBinding.slot !== slot) {
+    const committed = deps.store.upsertWorkspaceBinding({
+      ...exactWorkspaceBinding, slot, updatedAtMs: nowMs,
+    }, deps.instanceId);
+    if (!committed) {
+      deps.store.releaseWorkspaceClaim(deps.instanceId);
+      return undefined;
+    }
+    await deps.store.persist();
+  }
   const owner: TelegramThreadOwner = {
     kind: "leader",
     cwd: deps.cwd,
@@ -2138,9 +3527,7 @@ export async function promoteTelegramFollowerBindingToLeader(
       ? { threadName: existing?.threadName ?? deps.threadName }
       : {}),
     instanceId: deps.instanceId,
-    ...((existing?.slot ?? deps.slot)
-      ? { slot: existing?.slot ?? deps.slot }
-      : {}),
+    slot,
     ...(existing?.syncStatus ? { syncStatus: existing.syncStatus } : {}),
     ...(existing?.lastSyncObservedAtMs !== undefined
       ? { lastSyncObservedAtMs: existing.lastSyncObservedAtMs }
@@ -2151,6 +3538,7 @@ export async function promoteTelegramFollowerBindingToLeader(
       : {}),
   });
   await deps.store.persist();
+  deps.store.releaseWorkspaceClaim(deps.instanceId);
   return record;
 }
 
@@ -2159,6 +3547,12 @@ export interface TelegramOwnTopicProvisionDeps {
   instanceId: string;
   cwd?: string;
   telegramProfile?: string;
+  requestedThreadName?: string;
+  preferredSlot?: string;
+  workspaceBindingKey?: string;
+  resolveInitialWorkspaceDisplayTitle?: (
+    binding: TelegramWorkspaceDisplayBinding,
+  ) => string | undefined;
   getNowMs?: () => number;
   getRandom?: () => number;
   getCurrentLeaderEpoch?: () => number | string | undefined;
@@ -2183,6 +3577,7 @@ export interface TelegramOwnTopicProvisionResult {
   target: TelegramTarget & { threadId: number };
   slot: string;
   threadName?: string;
+  displayTitle?: string;
   reused: boolean;
 }
 
@@ -2335,7 +3730,7 @@ export async function provisionOwnBusTopic(
       });
       continue;
     }
-    if (isSameProcessInstance(record.instanceId, deps.instanceId)) {
+    if (isSameTelegramProcessInstance(record.instanceId, deps.instanceId)) {
       deps.store.upsert({
         ...record,
         profileKey,
@@ -2413,16 +3808,18 @@ export async function provisionOwnBusTopic(
     }
     if (isCleanupTargetProtected(action.target, action)) continue;
     deps.store.markStaleByTarget(record.target);
-    deps.store.reserveThread({
-      target: record.target,
-      slot: record.slot ?? "A",
-      reason: "previous-process-cleaned-without-visible-probe",
-      createdAtMs: nowMs,
-      updatedAtMs: nowMs,
-      expiresAtMs: nowMs + TELEGRAM_THREAD_RESERVATION_TTL_MS,
-      instanceId: record.instanceId,
-      lastReconcileAction: "leader-topic-previous-instance-cleaned-no-probe",
-    });
+    if (record.slot) {
+      deps.store.reserveThread({
+        target: record.target,
+        slot: record.slot,
+        reason: "previous-process-cleaned-without-visible-probe",
+        createdAtMs: nowMs,
+        updatedAtMs: nowMs,
+        expiresAtMs: nowMs + TELEGRAM_THREAD_RESERVATION_TTL_MS,
+        instanceId: record.instanceId,
+        lastReconcileAction: "leader-topic-previous-instance-cleaned-no-probe",
+      });
+    }
     deps.store.setBotState({
       threadMode: "enabled",
       updatedAtMs: nowMs,
@@ -2448,12 +3845,24 @@ export async function provisionOwnBusTopic(
     getNowMs: deps.getNowMs,
     getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
     getRandom: deps.getRandom,
+    resolveInitialWorkspaceDisplayTitle:
+      deps.resolveInitialWorkspaceDisplayTitle,
     claimPendingTargets: false,
   });
   let result = await provision({
     instanceId: deps.instanceId,
     owner: currentLeaderOwner,
     profileKey,
+    ...(deps.requestedThreadName
+      ? { threadName: deps.requestedThreadName }
+      : {}),
+    ...(deps.preferredSlot ? { preferredSlot: deps.preferredSlot } : {}),
+    ...(deps.workspaceBindingKey
+      ? {
+          workspaceBindingKey: deps.workspaceBindingKey,
+          ...(deps.cwd ? { workspaceCwd: deps.cwd } : {}),
+        }
+      : {}),
   });
   if (result.reused) {
     // Reused topics may already have a human-chosen Telegram title. Do not edit
@@ -2488,12 +3897,16 @@ export async function provisionOwnBusTopic(
     threadName: result.record.threadName,
     reused: result.reused,
   });
+  if (!result.record.slot) {
+    throw new Error("Telegram Thread slot authority is unavailable.");
+  }
   return {
     target: result.target,
-    slot: result.record.slot ?? "A",
+    slot: result.record.slot,
     ...(result.record.threadName
       ? { threadName: result.record.threadName }
       : {}),
+    ...(result.displayTitle ? { displayTitle: result.displayTitle } : {}),
     reused: result.reused,
   };
 }
@@ -2721,6 +4134,7 @@ export interface TelegramThreadStatusProjectionRuntimeDeps {
       }
     | undefined;
   getCurrentIdentity(): TelegramInstanceThreadIdentityCandidate;
+  getDisplayTitle?: (target: TelegramTarget) => string | undefined;
 }
 
 export function createTelegramThreadStatusProjectionRuntime(
@@ -2736,25 +4150,32 @@ export function createTelegramThreadStatusProjectionRuntime(
       return listTelegramThreadStatusFollowers({
         followers: deps.listFollowers(),
         records: deps.listRecords(),
-      });
+      }).map((follower) => ({
+        ...follower,
+        threadName: (follower.target ? deps.getDisplayTitle?.(follower.target) : undefined) ?? follower.threadName,
+      }));
     },
     getLocalBus() {
       const leaderSocketPath = deps.getLeaderSocketPath();
       const followerSocketPath = deps.getFollowerSocketPath();
       const leaderProtocol = deps.getLeaderProtocol?.();
+      const followerTarget = deps.getFollowerTarget();
       return {
         leaderSocketPath,
         leaderTransport: deps.getTransportKind(leaderSocketPath),
         followerSocketPath,
         followerTransport: deps.getTransportKind(followerSocketPath),
         followerRegistered: deps.isFollowerRegistered(),
-        followerTarget: deps.getFollowerTarget(),
+        followerTarget,
         followerSlot: deps.getFollowerSlot(),
-        followerThreadName: deps.getFollowerThreadName(),
+        followerThreadName: (followerTarget ? deps.getDisplayTitle?.(followerTarget) : undefined) ??
+          deps.getFollowerThreadName(),
         ...(leaderProtocol ? { leaderProtocol } : {}),
       };
     },
-    getTopicTargets: () => listTelegramThreadStatusTargets(deps.listRecords()),
+    getTopicTargets: () => listTelegramThreadStatusTargets(deps.listRecords()).map((record) => ({
+      ...record, threadName: deps.getDisplayTitle?.(record.target) ?? record.threadName,
+    })),
     getThreadReservations: () =>
       listTelegramThreadStatusReservations(deps.listReservations()),
     getTopicSyncObservations: () =>
@@ -2773,6 +4194,8 @@ export function createTelegramThreadStatusProjectionRuntime(
 export interface TelegramCurrentThreadAssemblyDeps {
   instanceId: string;
   listRecords: TelegramCurrentInstanceThreadRuntimeDeps["listRecords"];
+  listWorkspaceBindings?: () => readonly TelegramWorkspaceThreadBinding[];
+  getFollowerDisplayTitle?: () => string | undefined;
   getActiveTurnTarget(): TelegramTarget | undefined;
   getFollowerTarget(): TelegramTarget | undefined;
   isFollowerRegistered(): boolean;
@@ -2795,6 +4218,7 @@ export interface TelegramCurrentThreadAssemblyDeps {
 }
 
 export interface TelegramCurrentThreadAssembly {
+  getDisplayTitle: (target: TelegramTarget) => string | undefined;
   current: TelegramCurrentInstanceThreadRuntime;
   status: TelegramThreadStatusProjectionRuntime;
 }
@@ -2813,7 +4237,7 @@ export function createTelegramCurrentThreadAssembly(
       threadName: deps.getFollowerThreadName(),
     };
   };
-  const current = createTelegramCurrentInstanceThreadRuntime({
+  const namedCurrent = createTelegramCurrentInstanceThreadRuntime({
     instanceId: deps.instanceId,
     listRecords: deps.listRecords,
     getPreferredTarget: () =>
@@ -2823,7 +4247,25 @@ export function createTelegramCurrentThreadAssembly(
     getFollower,
     getLeader: deps.getLeaderIdentity,
   });
+  const getDisplayTitle = (target: TelegramTarget): string | undefined => {
+    const followerTarget = deps.getFollowerTarget();
+    if (followerTarget && targetMatches(followerTarget, target) && deps.isFollowerRegistered()) {
+      return deps.getFollowerDisplayTitle?.();
+    }
+    return deps.listWorkspaceBindings?.().find((binding) =>
+      targetMatches(binding.target, target),
+    )?.displayTitle;
+  };
+  const displayIdentity = (identity: TelegramInstanceThreadIdentityCandidate) => {
+    const title = identity.target ? getDisplayTitle(identity.target) : undefined;
+    return title ? { ...identity, threadName: title } : identity;
+  };
+  const current = {
+    ...namedCurrent,
+    getIdentity: (target?: TelegramTarget) => displayIdentity(namedCurrent.getIdentity(target)),
+  };
   return {
+    getDisplayTitle,
     current,
     status: createTelegramThreadStatusProjectionRuntime({
       ...deps.status,
@@ -2833,7 +4275,8 @@ export function createTelegramCurrentThreadAssembly(
       getFollowerSlot: deps.getFollowerSlot,
       getFollowerThreadName: deps.getFollowerThreadName,
       getLeaderProtocol: deps.getLeaderProtocol,
-      getCurrentIdentity: current.getRestorationIdentity,
+      getDisplayTitle,
+      getCurrentIdentity: () => displayIdentity(namedCurrent.getRestorationIdentity()),
     }),
   };
 }
@@ -3048,20 +4491,37 @@ export function createTelegramTopicTargetRenamer(
     );
     if (
       !threadName ||
-      !isTelegramTopicThreadNameValidForSlot(threadName, request.slot)
+      !!getTelegramManualThreadDisplayNameValidationError(threadName)
     )
       return undefined;
+    const occupied = new Set(
+      listOccupiedTelegramThreadIdentities({
+        records: deps.store.list(),
+        workspaceBindings: deps.store.listWorkspaceBindings(),
+        pendingProvisions: deps.store.listPendingProvisions(),
+        exceptTarget: request.target,
+      }),
+    );
+    if (occupied.has(getTelegramTopicIdentityName(threadName))) return undefined;
     const name = getTelegramTopicTitleForThreadName(
       threadName,
       request.slot ?? "",
       deps.topicNameTemplate,
     );
-    await deps.callApi("editForumTopic", {
-      chat_id: request.target.chatId,
-      message_thread_id: request.target.threadId,
-      name,
-    });
-    return deps.store.renameByTarget(request.target, threadName);
+    deps.assertAuthority?.();
+    const updateDisplayTitle = deps.shouldRenameDisplayedTitle?.() ?? true;
+    if (updateDisplayTitle) {
+      await deps.callApi("editForumTopic", {
+        chat_id: request.target.chatId,
+        message_thread_id: request.target.threadId,
+        name,
+      });
+    }
+    deps.assertAuthority?.();
+    if ((deps.shouldRenameDisplayedTitle?.() ?? true) !== updateDisplayTitle) {
+      throw new Error("Telegram display mode changed during Workspace rename.");
+    }
+    return deps.store.renameByTarget(request.target, threadName, { updateDisplayTitle });
   };
 }
 
@@ -3086,22 +4546,53 @@ export function createTelegramTopicTargetProvisioner(
       }
     };
     assertLeaderEpoch("start");
-    normalizeCurrentThreadNameSlots(deps.store);
-    const existing = deps.store.getByProfileKey(request.profileKey);
     const isManualFollowerRequest = request.owner?.kind === "manual-follower";
     const identity = deps.store.getIdentityByProfileKey(request.profileKey);
     const nowMs = getNowMs();
+    let pendingForRequest = deps.store
+      .listPendingProvisions()
+      .find((pending) =>
+        pending.profileKey === request.profileKey ||
+        pending.instanceId === request.instanceId,
+      );
+    if (pendingForRequest?.target) {
+      const target = pendingForRequest.target;
+      const observation = deps.store.listSyncObservations().find((entry) =>
+        targetMatches(entry.target, target),
+      );
+      assertTelegramPendingTopicRecoveryAllowed(deps.store, target);
+      if (observation?.syncStatus === "deleted") {
+        assertLeaderEpoch("before-deleted-provision-settlement");
+        deps.store.markStaleByTarget(target, "deleted");
+        await deps.store.persist();
+        assertLeaderEpoch("after-deleted-provision-settlement");
+        pendingForRequest = undefined;
+      }
+    }
+    const existing = deps.store.getByProfileKey(request.profileKey);
     if (existing && isCurrentThreadRecord(existing)) {
       const slot = existing.slot ?? deps.store.allocateSlot(request.profileKey);
+      if (!slot) {
+        throw new Error("Telegram Workspace slot reservation is unavailable.");
+      }
+      const occupied = listOccupiedTelegramThreadIdentities({
+        records: deps.store.list(),
+        workspaceBindings: deps.store.listWorkspaceBindings(),
+        pendingProvisions: deps.store.listPendingProvisions(),
+        exceptTarget: existing.target,
+        exceptWorkspaceBindingKey: request.workspaceBindingKey,
+      });
       const identityThreadName =
         identity?.threadName &&
-        isTelegramTopicThreadNameValidForSlot(identity.threadName, slot)
+        isTelegramTopicThreadNameValidForSlot(identity.threadName, slot) &&
+        !occupied.includes(getTelegramTopicIdentityName(identity.threadName))
           ? identity.threadName
           : undefined;
       const bakedThreadName = chooseTelegramThreadName({
         slot: getNextTelegramThreadNamePaletteSlot(deps.store.list(), slot),
         entropy: nowMs,
         getRandom,
+        occupied,
       });
       const record = deps.store.upsert({
         ...existing,
@@ -3114,16 +4605,23 @@ export function createTelegramTopicTargetProvisioner(
         owner: request.owner ?? existing.owner,
         lastError: undefined,
       });
-      return { target: record.target, reused: true, record };
+      const recoveredTitle = pendingForRequest?.target &&
+        targetMatches(pendingForRequest.target, record.target)
+        ? pendingForRequest.displayTitle : undefined;
+      if (pendingForRequest?.target && targetMatches(pendingForRequest.target, record.target)) {
+        if (!request.workspaceBindingKey) deps.store.removePendingProvision(pendingForRequest.id);
+        await deps.store.persist();
+        assertLeaderEpoch("after-recovered-current-binding");
+      }
+      return {
+        target: record.target, reused: true, record,
+        ...(recoveredTitle ? { displayTitle: recoveredTitle } : {}),
+      };
     }
-    const pendingForRequest = deps.store
-      .listPendingProvisions()
-      .find(
-        (pending) =>
-          pending.profileKey === request.profileKey ||
-          pending.instanceId === request.instanceId,
-      );
     if (pendingForRequest?.target) {
+      if (!pendingForRequest.slot) {
+        throw new Error("Telegram Workspace slot reservation is unavailable.");
+      }
       const record = deps.store.upsert({
         profileKey: request.profileKey,
         owner: request.owner,
@@ -3135,10 +4633,17 @@ export function createTelegramTopicTargetProvisioner(
         instanceId: request.instanceId,
         slot: pendingForRequest.slot,
       });
-      deps.store.removePendingProvision(pendingForRequest.id);
+      if (!request.workspaceBindingKey) deps.store.removePendingProvision(pendingForRequest.id);
       await deps.store.persist();
       assertLeaderEpoch("after-recovered-binding");
-      return { target: record.target, reused: true, record };
+      return {
+        target: record.target,
+        reused: true,
+        record,
+        ...(pendingForRequest.displayTitle
+          ? { displayTitle: pendingForRequest.displayTitle }
+          : {}),
+      };
     }
     if (pendingForRequest) {
       throw new Error(
@@ -3149,6 +4654,9 @@ export function createTelegramTopicTargetProvisioner(
       request.instanceId,
     );
     if (activeForInstance) {
+      if (!activeForInstance.slot) {
+        throw new Error("Telegram Workspace slot reservation is unavailable.");
+      }
       return {
         target: activeForInstance.target,
         reused: true,
@@ -3165,25 +4673,67 @@ export function createTelegramTopicTargetProvisioner(
         return { target: claimed.target, reused: true, record: claimed };
       }
     }
-    const candidateThreadName = identity?.threadName;
+    const occupied = listOccupiedTelegramThreadIdentities({
+      records: deps.store.list(),
+      workspaceBindings: deps.store.listWorkspaceBindings(),
+      pendingProvisions: deps.store.listPendingProvisions(),
+      exceptWorkspaceBindingKey: request.workspaceBindingKey,
+    });
+    const requestedThreadName =
+      request.threadName &&
+      isTelegramTopicThreadNameValidForSlot(request.threadName, undefined) &&
+      !occupied.includes(getTelegramTopicIdentityName(request.threadName))
+        ? normalizeTelegramTopicTargetThreadName(request.threadName)
+        : undefined;
+    const candidateThreadName = requestedThreadName ?? identity?.threadName;
     const preferredNameSlot =
       getTelegramThreadNameLeadingSlot(candidateThreadName) ??
       getNextTelegramThreadNamePaletteSlot(deps.store.list(), undefined) ??
       request.preferredSlot;
     const slot =
       existing?.slot ??
-      (candidateThreadName ? undefined : identity?.slot) ??
       deps.store.allocateSlot(
         request.profileKey,
         isManualFollowerRequest
           ? request.preferredSlot
-          : (request.preferredSlot ?? preferredNameSlot),
+          : (request.preferredSlot ??
+            (candidateThreadName ? undefined : identity?.slot) ??
+            preferredNameSlot),
+        request.workspaceBindingKey,
       );
-    const requestThreadName =
+    if (!slot) {
+      throw new Error("Telegram Workspace slot reservation is unavailable.");
+    }
+    const uniqueCandidate =
       candidateThreadName &&
-      isTelegramTopicThreadNameValidForSlot(candidateThreadName, slot)
+      isTelegramTopicThreadNameValidForSlot(candidateThreadName, slot) &&
+      !occupied.includes(getTelegramTopicIdentityName(candidateThreadName))
         ? candidateThreadName
-        : chooseTelegramThreadName({ slot, entropy: nowMs, getRandom });
+        : undefined;
+    const requestThreadName =
+      uniqueCandidate ??
+      chooseTelegramThreadName({ slot, entropy: nowMs, getRandom, occupied });
+    let displayTitle: string | undefined;
+    if (
+      deps.resolveInitialWorkspaceDisplayTitle &&
+      request.workspaceBindingKey &&
+      request.workspaceCwd
+    ) {
+      const projectedTitle = deps.resolveInitialWorkspaceDisplayTitle({
+        bindingKey: request.workspaceBindingKey,
+        cwd: request.workspaceCwd,
+        slot,
+        threadName: requestThreadName,
+      });
+      if (!projectedTitle?.trim()) {
+        throw new Error("Telegram Thread display identity is missing or ambiguous.");
+      }
+      displayTitle = getTelegramTopicName(
+        { ...request, threadName: projectedTitle },
+        "{threadName}",
+        slot,
+      );
+    }
     const pendingId = `provision:${request.instanceId}:${slot}:${nowMs}`;
     const pendingOwner =
       request.owner?.kind === "leader" ? "leader" : "manual-follower";
@@ -3194,6 +4744,7 @@ export function createTelegramTopicTargetProvisioner(
       instanceId: request.instanceId,
       profileKey: request.profileKey,
       threadName: requestThreadName,
+      ...(displayTitle ? { displayTitle } : {}),
       slot,
       startedAtMs: nowMs,
       ...(leaderEpoch !== undefined ? { leaderEpoch } : {}),
@@ -3208,7 +4759,7 @@ export function createTelegramTopicTargetProvisioner(
         "createForumTopic",
         {
           chat_id: deps.topicChatId,
-          name: getTelegramTopicName(
+          name: displayTitle ?? getTelegramTopicName(
             {
               ...request,
               ...(requestThreadName ? { threadName: requestThreadName } : {}),
@@ -3256,10 +4807,16 @@ export function createTelegramTopicTargetProvisioner(
         instanceId: request.instanceId,
         slot,
       });
-      deps.store.removePendingProvision(pendingId);
+      // Workspace commit consumes the exact title evidence in the same publication.
+      if (!request.workspaceBindingKey) deps.store.removePendingProvision(pendingId);
       await deps.store.persist();
       assertLeaderEpoch("after-active-binding");
-      return { target: record.target, reused: false, record };
+      return {
+        target: record.target,
+        reused: false,
+        record,
+        ...(displayTitle ? { displayTitle } : {}),
+      };
     } catch (error) {
       if (
         threadId !== undefined &&