@llblab/pi-kit 0.19.1 → 0.20.0

package/node_modules/@llblab/pi-telegram/dist/lib/bus-leader.js

@@ -11,8 +11,9 @@ import { getTelegramApiErrorRequestTarget, isTelegramApiCommitUnknownError, } fr
 import * as Threads from "./threads.js";
 import { createTelegramBusLocalServer, createUnauthorizedBusAck, getTelegramBusEnvelopeTrafficClass, getTelegramBusProtocolCompatibility, hasTelegramBusCapability, isTelegramBusEnvelopeAuthorized, getTelegramBusFollowerSocketPath, sendTelegramBusLocalEnvelope, stripTelegramBusApiMetadata, TELEGRAM_BUS_CAPABILITY_DURABLE_FOLLOWER_ADMISSION, TELEGRAM_BUS_CAPABILITY_QUEUE_HANDOFF, TELEGRAM_BUS_CAPABILITY_WORKSPACE_FOLLOWER_AUTO_CONNECT, TELEGRAM_BUS_CAPABILITY_WORKSPACE_THREAD_RENAME, TELEGRAM_BUS_CAPABILITY_THREAD_DISPLAY_MODE, TELEGRAM_BUS_CAPABILITY_DIRECTORY_DISPLAY_FORMAT, } from "./bus.js";
 import { getTelegramBusTransportRetryPolicy } from "./bus-transport.js";
-import { createTelegramWorkspaceOperationRuntime, } from "./workspace-retirement.js";
+import { createTelegramWorkspaceOperationRuntime, createTelegramWorkspaceSlotRotation, } from "./workspace-retirement.js";
 import { createTelegramWorkspaceAdmissionOperationId, runWithTelegramWorkspaceAdmissionsAsync, } from "./workspace-admission.js";
+import { TELEGRAM_WORKSPACE_SLOTS, TelegramWorkspaceSlotUnavailableError } from "./workspace-slots.js";
 export const TELEGRAM_BUS_FOLLOWER_STALE_AFTER_MS = 15_000;
 function escapeHtml(text) {
     return text
@@ -56,6 +57,13 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
                 });
             },
         }).run;
+    const runWithWorkspaceCapacity = deps.workspaceRotation && deps.captureWorkspaceExternalProtection &&
+        deps.getCurrentLeaderEpoch ? createTelegramWorkspaceSlotRotation({
+        ...deps.workspaceRotation, store: deps.topicTargetStore,
+        getLeaderEpoch: deps.getCurrentLeaderEpoch,
+        getExternalProtection: deps.captureWorkspaceExternalProtection,
+        recordEvent(message, details) { deps.recordRuntimeEvent("bus", message, details); },
+    }) : undefined;
     const captureLiveBindingKeys = (bindings) => resolveTelegramLiveWorkspaceBindingKeys(bindings, deps.topicTargetStore.getActiveByInstanceId(deps.instanceId)?.target, deps.runtime.followerRegistry.list());
     const provisionerPorts = {
         getAllowedUserId: deps.getAllowedUserId,
@@ -114,13 +122,40 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
         operationKind: "workspace.reconcile-display",
         scopes: [{ kind: "profile" }],
     }, reconcileThreadDisplayOperation);
+    let startupDisplayTimer;
+    let startupDisplayGeneration = 0;
+    let startupDisplaySettled = true;
+    const cancelStartupDisplayStabilization = () => {
+        startupDisplayGeneration += 1;
+        startupDisplaySettled = true;
+        if (startupDisplayTimer)
+            clearTimeout(startupDisplayTimer);
+        startupDisplayTimer = undefined;
+    };
     const scheduleDisplay = () => {
-        if (!display)
+        if (!display || !startupDisplaySettled)
             return;
         void reconcileThreadDisplay().catch((error) => {
             deps.recordRuntimeEvent("bus", error, { phase: "thread-display-reconcile" });
         });
     };
+    const beginStartupDisplayStabilization = () => {
+        cancelStartupDisplayStabilization();
+        startupDisplaySettled = false;
+    };
+    const armStartupDisplayReconciliation = () => {
+        const generation = startupDisplayGeneration;
+        const delayMs = deps.runtime.followerStaleAfterMs ??
+            TELEGRAM_BUS_FOLLOWER_STALE_AFTER_MS;
+        startupDisplayTimer = setTimeout(() => {
+            if (startupDisplayGeneration !== generation)
+                return;
+            startupDisplayTimer = undefined;
+            startupDisplaySettled = true;
+            scheduleDisplay();
+        }, delayMs);
+        startupDisplayTimer.unref?.();
+    };
     let modeTail = Promise.resolve();
     const applyThreadDisplayMode = (mode, isCurrent) => {
         const epoch = deps.getCurrentLeaderEpoch?.();
@@ -299,7 +334,7 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
         onFollowerRegistered: scheduleDisplay,
         provisionLeaderTarget: (ctx) => {
             const chatId = deps.getAllowedUserId();
-            return runWorkspaceOperation({
+            const provision = () => runWorkspaceOperation({
                 operationId: `leader-provision:${deps.instanceId}`,
                 operationKind: "workspace.provision-leader",
                 scopes: [
@@ -308,6 +343,7 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
                         : { kind: "profile" },
                 ],
             }, () => provisionLeaderTarget(ctx));
+            return runWithWorkspaceCapacity ? runWithWorkspaceCapacity(provision) : provision();
         },
         getFollowerDisplayTitle(follower) {
             const binding = deps.topicTargetStore.listWorkspaceBindings().find((binding) => binding.target.chatId === follower.target?.chatId &&
@@ -399,13 +435,50 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
             }, () => cleanupConfirmedDeadFollower(follower));
             scheduleDisplay();
         },
+        async onFollowerConfirmedDeadPreserved(follower, isDetached, operationId) {
+            const epoch = deps.getCurrentLeaderEpoch?.();
+            const profile = deps.getTelegramProfile?.();
+            if (epoch === undefined || !follower.registrationGeneration ||
+                typeof follower.target?.threadId !== "number")
+                return false;
+            const isCurrent = () => isDetached() && deps.getCurrentLeaderEpoch?.() === epoch &&
+                deps.getTelegramProfile?.() === profile;
+            if (!isCurrent())
+                return false;
+            const settled = await runWorkspaceOperation({
+                operationId,
+                operationKind: "workspace.preserve-dead-follower",
+                scopes: [{ kind: "profile" }],
+            }, async () => {
+                if (!isCurrent())
+                    return false;
+                await deps.topicTargetStore.load();
+                if (!isCurrent())
+                    return false;
+                const record = deps.topicTargetStore.getActiveByInstanceId(follower.instanceId);
+                if (!record || (follower.profileKey && record.profileKey !== follower.profileKey) ||
+                    record.target.chatId !== follower.target.chatId ||
+                    record.target.threadId !== follower.target.threadId)
+                    return true;
+                const committed = await deps.topicTargetStore.detachTargetOwner(record, isCurrent);
+                if (!committed && isCurrent()) {
+                    throw new Error("Telegram preserved follower detachment was not committed.");
+                }
+                return committed;
+            });
+            if (settled && isCurrent())
+                scheduleDisplay();
+            return settled;
+        },
         provisionFollowerTarget: (registration, options) => runWorkspaceOperation({
             operationId: `follower-provision:${registration.instanceId}:${registration.registrationGeneration}`,
             operationKind: "workspace.provision-follower",
             scopes: [{ kind: "profile" }],
         }, () => provisionFollowerTarget(registration, options)),
         getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
+        getTelegramProfile: deps.getTelegramProfile,
         runWorkspaceAdmission,
+        runWithWorkspaceCapacity,
         callApi: createTelegramBusLeaderApiProxy({
             call: deps.callApi,
             callMultipart: deps.callMultipart,
@@ -423,9 +496,21 @@ export function createTelegramBusLeaderRuntimeAssembly(deps) {
         resetThreadNameAdmitted,
         captureWorkspaceExternalProtection: deps.captureWorkspaceExternalProtection,
         async startPolling(ctx) {
-            await runtime.startPolling(ctx);
             if (display)
-                scheduleDisplay();
+                beginStartupDisplayStabilization();
+            try {
+                await runtime.startPolling(ctx);
+            }
+            catch (error) {
+                cancelStartupDisplayStabilization();
+                throw error;
+            }
+            if (display)
+                armStartupDisplayReconciliation();
+        },
+        async stopPolling() {
+            cancelStartupDisplayStabilization();
+            await runtime.stopPolling();
         },
     };
     if (!display)
@@ -495,7 +580,7 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
             if (options?.existingWorkspaceBindingOnly)
                 return undefined;
             if (capacityUnavailable) {
-                throw new Error("Telegram Workspace slot reservation is unavailable.");
+                throw new TelegramWorkspaceSlotUnavailableError();
             }
             throw new Error("Telegram Workspace identity is already claimed.");
         }
@@ -591,7 +676,7 @@ export function createTelegramBusFollowerTargetProvisioner(deps) {
             const requestedSlot = workspaceIdentity?.slot ?? workspaceBinding?.slot ?? registration.slot ?? recoveryHint?.slot;
             const recoveredSlot = deps.topicTargetStore.allocateSlot(followerProfileKey, requestedSlot, workspaceIdentity?.bindingKey);
             if (!recoveredSlot) {
-                throw new Error("Telegram Workspace slot reservation is unavailable.");
+                throw new TelegramWorkspaceSlotUnavailableError();
             }
             const recoveredRecord = {
                 profileKey: followerProfileKey,
@@ -945,9 +1030,7 @@ function createTelegramBusFollowerCleanupHandler(deps, trigger) {
             isCleanupTargetProtected,
             callApi: deps.callApi,
             markStaleByTarget(target, syncStatus, lastSyncError) {
-                const stale = deps.topicTargetStore.markStaleByTarget(target, syncStatus, lastSyncError);
-                const inactive = deps.topicTargetStore.markWorkspaceBindingInactiveByTarget(target, (deps.getNowMs ?? Date.now)());
-                return stale || inactive;
+                return deps.topicTargetStore.markStaleByTarget(target, syncStatus, lastSyncError);
             },
             removeCleanupIntentById: deps.topicTargetStore.removePendingCleanup,
             persist: deps.topicTargetStore.persist,
@@ -1440,11 +1523,15 @@ export function createTelegramBusLeaderEnvelopeHandler(deps) {
                                 : "missing-capability")}.`,
                     };
                 }
+                if (!envelope.registration.registrationGeneration) {
+                    return {
+                        kind: "bus.ack", requestId: envelope.requestId, ok: false,
+                        protocol: deps.protocolIdentity,
+                        message: "Telegram follower registration requires an exact generation.",
+                    };
+                }
                 const registrationOperation = () => runFollowerMutation(envelope.registration, async () => {
                     try {
-                        if (!envelope.registration.registrationGeneration) {
-                            throw new Error("Telegram follower registration requires an exact generation.");
-                        }
                         const leaderEpoch = deps.getCurrentLeaderEpoch?.();
                         if (deps.getCurrentLeaderEpoch && leaderEpoch === undefined) {
                             throw new Error("Telegram follower registration requires leader ownership.");
@@ -1502,6 +1589,9 @@ export function createTelegramBusLeaderEnvelopeHandler(deps) {
                         };
                     }
                     catch (error) {
+                        if (!restoringWorkspace && deps.runWithWorkspaceCapacity &&
+                            error instanceof TelegramWorkspaceSlotUnavailableError)
+                            throw error;
                         return {
                             kind: "bus.ack",
                             requestId: envelope.requestId,
@@ -1513,14 +1603,14 @@ export function createTelegramBusLeaderEnvelopeHandler(deps) {
                         };
                     }
                 });
-                if (!deps.runWorkspaceAdmission)
-                    return registrationOperation();
+                const register = () => deps.runWorkspaceAdmission ? deps.runWorkspaceAdmission({
+                    operationId: `follower-registration:${envelope.requestId}`,
+                    operationKind: "workspace.register-follower",
+                    scopes: [{ kind: "profile" }],
+                }, registrationOperation) : registrationOperation();
                 try {
-                    return await deps.runWorkspaceAdmission({
-                        operationId: `follower-registration:${envelope.requestId}`,
-                        operationKind: "workspace.register-follower",
-                        scopes: [{ kind: "profile" }],
-                    }, registrationOperation);
+                    return await (!restoringWorkspace && deps.runWithWorkspaceCapacity
+                        ? deps.runWithWorkspaceCapacity(register) : register());
                 }
                 catch (error) {
                     return {
@@ -1981,8 +2071,19 @@ export function createTelegramBusLeaderRuntime(deps) {
     let pruneInterval;
     let pruneGeneration = 0;
     let prunePromise;
+    const pendingPreservations = new Map();
+    const forgetPreservation = (observation) => {
+        if (!observation)
+            return;
+        if (pendingPreservations.get(observation.follower.instanceId) === observation) {
+            pendingPreservations.delete(observation.follower.instanceId);
+        }
+        observation.registration.release();
+    };
     const stopPruning = () => {
         pruneGeneration += 1;
+        for (const observation of pendingPreservations.values())
+            forgetPreservation(observation);
         if (pruneInterval)
             clearInterval(pruneInterval);
         pruneInterval = undefined;
@@ -1997,92 +2098,146 @@ export function createTelegramBusLeaderRuntime(deps) {
         }
     };
     const pruneFollowers = async (expectedGeneration) => {
-        const isCurrent = () => pruneGeneration === expectedGeneration;
+        const epoch = deps.getCurrentLeaderEpoch?.();
+        const profile = deps.getTelegramProfile?.();
+        const isCurrent = () => pruneGeneration === expectedGeneration &&
+            deps.getTelegramProfile?.() === profile &&
+            (!deps.getCurrentLeaderEpoch || (epoch !== undefined && deps.getCurrentLeaderEpoch() === epoch));
         try {
             await localServer.ensureEndpoint();
         }
         catch (error) {
-            recordPruneEvent(error, {
-                phase: "leader-endpoint-recovery",
-            });
+            recordPruneEvent(error, { phase: "leader-endpoint-recovery" });
+        }
+        if (pruneGeneration !== expectedGeneration)
+            return;
+        for (const observation of pendingPreservations.values()) {
+            if (!observation.isCurrent())
+                forgetPreservation(observation);
         }
         if (!isCurrent())
             return;
+        const attempts = [...pendingPreservations.values()].map((observation) => ({
+            follower: observation.follower, observation, fresh: false,
+        }));
         const removed = deps.followerRegistry.pruneStale(getNowMs(), followerStaleAfterMs);
         for (const follower of removed) {
+            forgetPreservation(pendingPreservations.get(follower.instanceId));
+            let observation;
+            if (deps.onFollowerConfirmedDeadPreserved && epoch !== undefined &&
+                follower.registrationGeneration && Number.isSafeInteger(follower.pid) && follower.pid > 0 &&
+                Number.isSafeInteger(follower.target?.threadId) && follower.target.threadId > 0) {
+                if (pendingPreservations.size < TELEGRAM_WORKSPACE_SLOTS.length) {
+                    const registration = deps.followerRegistry.observeUnregistered(follower);
+                    let current = true;
+                    observation = {
+                        follower, registration,
+                        // Reuse exact admission authority after a lost acquisition acknowledgement.
+                        operationId: createTelegramWorkspaceAdmissionOperationId(),
+                        isCurrent() {
+                            current = current && isCurrent() && registration.isCurrent();
+                            return current;
+                        },
+                    };
+                    pendingPreservations.set(follower.instanceId, observation);
+                }
+                else {
+                    recordPruneEvent("Telegram follower preservation observation capacity exhausted; retaining binding", {
+                        phase: "follower-preservation-capacity", instanceId: follower.instanceId,
+                    });
+                }
+            }
+            attempts.push({ follower, observation, fresh: true });
+        }
+        for (const { follower, observation, fresh } of attempts) {
+            if (!isCurrent())
+                return;
+            if (observation && !observation.isCurrent()) {
+                forgetPreservation(observation);
+                continue;
+            }
             let processConfirmedDead = false;
-            if (follower.pid !== undefined && deps.isFollowerProcessAlive) {
+            if (follower.pid !== undefined && Number.isSafeInteger(follower.pid) &&
+                follower.pid > 0 && deps.isFollowerProcessAlive) {
                 try {
-                    processConfirmedDead = !deps.isFollowerProcessAlive(follower.pid);
+                    processConfirmedDead = deps.isFollowerProcessAlive(follower.pid) === false;
                 }
                 catch (error) {
-                    recordPruneEvent(error, {
-                        phase: "follower-process-liveness",
-                        instanceId: follower.instanceId,
-                        pid: follower.pid,
-                    });
+                    if (fresh)
+                        recordPruneEvent(error, {
+                            phase: "follower-process-liveness", instanceId: follower.instanceId, pid: follower.pid,
+                        });
                 }
             }
             if (!processConfirmedDead) {
-                recordPruneEvent("Telegram bus follower heartbeat stale; preserving thread binding", {
-                    phase: "follower-pruned",
-                    instanceId: follower.instanceId,
-                    processLiveness: follower.pid === undefined || !deps.isFollowerProcessAlive
-                        ? "unknown"
-                        : "alive-or-unknown",
-                });
+                if (fresh)
+                    recordPruneEvent("Telegram bus follower heartbeat stale; preserving thread binding", {
+                        phase: "follower-pruned", instanceId: follower.instanceId,
+                        processLiveness: follower.pid === undefined || !deps.isFollowerProcessAlive ? "unknown" : "alive-or-unknown",
+                    });
                 continue;
             }
-            let cleanupEnabled = false;
+            let cleanupEnabled;
             try {
-                cleanupEnabled =
-                    (await deps.shouldCleanupConfirmedDeadFollower?.()) ?? false;
+                cleanupEnabled = await deps.shouldCleanupConfirmedDeadFollower?.();
             }
             catch (error) {
                 recordPruneEvent(error, {
-                    phase: "follower-confirmed-dead-cleanup-policy",
-                    instanceId: follower.instanceId,
-                    pid: follower.pid,
+                    phase: "follower-confirmed-dead-cleanup-policy", instanceId: follower.instanceId, pid: follower.pid,
                 });
             }
-            if (!isCurrent())
+            if (!isCurrent()) {
+                forgetPreservation(observation);
                 return;
-            if (!cleanupEnabled || !deps.onFollowerConfirmedDead) {
-                recordPruneEvent("Telegram bus follower process confirmed dead; preserving thread binding", {
-                    phase: "follower-confirmed-dead-preserved",
-                    instanceId: follower.instanceId,
-                    pid: follower.pid,
-                    cleanupEnabled,
-                });
+            }
+            const recordPreserved = () => recordPruneEvent("Telegram bus follower process confirmed dead; preserving thread binding", { phase: "follower-confirmed-dead-preserved", instanceId: follower.instanceId,
+                pid: follower.pid, cleanupEnabled });
+            // Deferred observations authorize only non-destructive publication, never deletion retries.
+            if (cleanupEnabled === true && !fresh) {
+                forgetPreservation(observation);
+                recordPreserved();
                 continue;
             }
+            const onConfirmedDead = cleanupEnabled === true ? deps.onFollowerConfirmedDead :
+                cleanupEnabled === false && observation ? deps.onFollowerConfirmedDeadPreserved : undefined;
+            if (!onConfirmedDead) {
+                if (cleanupEnabled === true)
+                    forgetPreservation(observation);
+                if (fresh)
+                    recordPreserved();
+                continue;
+            }
+            const findReplacement = () => deps.followerRegistry.list().find((candidate) => candidate.instanceId === follower.instanceId ||
+                (!!follower.profileKey && candidate.profileKey === follower.profileKey) ||
+                (!!follower.target && candidate.target?.chatId === follower.target.chatId &&
+                    candidate.target?.threadId === follower.target.threadId));
+            let settled = false;
             try {
                 await runFollowerMutation(follower, async () => {
-                    if (!isCurrent())
-                        return;
-                    const replacement = deps.followerRegistry.list().find((candidate) => follower.profileKey
-                        ? candidate.profileKey === follower.profileKey
-                        : candidate.instanceId === follower.instanceId);
-                    if (replacement) {
-                        recordPruneEvent("Telegram bus follower replaced before confirmed-dead cleanup; preserving thread binding", {
-                            phase: "follower-confirmed-dead-replaced",
-                            instanceId: follower.instanceId,
-                            replacementInstanceId: replacement.instanceId,
-                        });
+                    const isDetached = () => isCurrent() && (!observation || observation.isCurrent()) &&
+                        !findReplacement() && deps.isFollowerProcessAlive?.(follower.pid) === false;
+                    if (!isDetached())
                         return;
-                    }
-                    await deps.onFollowerConfirmedDead(follower);
+                    if (cleanupEnabled === true)
+                        await deps.onFollowerConfirmedDead(follower);
+                    else
+                        settled = await deps.onFollowerConfirmedDeadPreserved(follower, isDetached, observation.operationId);
                 });
+                if (!cleanupEnabled)
+                    recordPreserved();
             }
             catch (error) {
                 recordPruneEvent(error, {
-                    phase: "follower-confirmed-dead-cleanup",
-                    instanceId: follower.instanceId,
-                    pid: follower.pid,
-                    chatId: follower.target?.chatId,
-                    threadId: follower.target?.threadId,
+                    phase: cleanupEnabled ? "follower-confirmed-dead-cleanup" : "follower-confirmed-dead-preserve",
+                    instanceId: follower.instanceId, pid: follower.pid,
+                    chatId: follower.target?.chatId, threadId: follower.target?.threadId,
                 });
             }
+            finally {
+                if (settled || cleanupEnabled === true || (observation && !observation.isCurrent())) {
+                    forgetPreservation(observation);
+                }
+            }
         }
     };
     const requestPrune = () => {
@@ -2121,7 +2276,11 @@ export function createTelegramBusLeaderRuntime(deps) {
         resolveAgentTarget: deps.resolveAgentTarget,
         routeAgentMessage: deps.routeAgentMessage,
         routeQueueHandoff: deps.routeQueueHandoff,
-        provisionFollowerTarget: deps.provisionFollowerTarget,
+        provisionFollowerTarget: deps.provisionFollowerTarget ? (registration, options) => {
+            // Same-instance ownership can change in the store before registry publication.
+            forgetPreservation(pendingPreservations.get(registration.instanceId));
+            return deps.provisionFollowerTarget(registration, options);
+        } : undefined,
         onFollowerDisconnected: deps.onFollowerDisconnected,
         renameFollowerThread: deps.renameFollowerThread,
         resetFollowerThreadName: deps.resetFollowerThreadName,
@@ -2132,6 +2291,7 @@ export function createTelegramBusLeaderRuntime(deps) {
         getCurrentLeaderEpoch: deps.getCurrentLeaderEpoch,
         runFollowerMutation,
         runWorkspaceAdmission: deps.runWorkspaceAdmission,
+        runWithWorkspaceCapacity: deps.runWithWorkspaceCapacity,
     });
     const routeQueueHandoffEnvelope = async (input) => {
         const recipient = deps.followerRegistry.get(input.recipientInstanceId);

package/node_modules/@llblab/pi-telegram/dist/lib/bus.d.ts

@@ -512,6 +512,10 @@ export interface TelegramBusFollowerRegistry {
     list: () => TelegramBusFollowerView[];
     remove: (instanceId: string) => boolean;
     clear: () => void;
+    observeUnregistered: (follower: TelegramBusFollowerView) => {
+        isCurrent: () => boolean;
+        release: () => void;
+    };
     pruneStale: (nowMs: number, staleAfterMs: number) => TelegramBusFollowerView[];
 }
 export declare function createTelegramBusForwardOwnershipValidator(registry: Pick<TelegramBusFollowerRegistry, "get">): (ownership: TelegramBusForwardOwnership) => boolean;

package/node_modules/@llblab/pi-telegram/dist/lib/bus.js

@@ -1317,8 +1317,15 @@ export function createTelegramBusForwardOwnershipValidator(registry) {
         } : undefined);
     };
 }
+function hasTelegramBusFollowerIdentityOverlap(first, second) {
+    return first.instanceId === second.instanceId ||
+        (first.profileKey !== undefined && first.profileKey === second.profileKey) ||
+        (first.target !== undefined && first.target.chatId === second.target?.chatId &&
+            first.target.threadId === second.target.threadId);
+}
 export function createTelegramBusFollowerRegistry() {
     const followers = new Map();
+    const observations = new Set();
     const clone = (follower) => ({
         ...follower,
         target: follower.target ? { ...follower.target } : undefined,
@@ -1337,12 +1344,7 @@ export function createTelegramBusFollowerRegistry() {
             for (const [instanceId, follower] of followers.entries()) {
                 if (instanceId === registration.instanceId)
                     continue;
-                const sameProfile = registration.profileKey !== undefined &&
-                    registration.profileKey === follower.profileKey;
-                const sameTarget = registration.target !== undefined &&
-                    follower.target?.chatId === registration.target.chatId &&
-                    follower.target.threadId === registration.target.threadId;
-                if (sameProfile || sameTarget)
+                if (hasTelegramBusFollowerIdentityOverlap(registration, follower))
                     followers.delete(instanceId);
             }
             const next = {
@@ -1359,6 +1361,12 @@ export function createTelegramBusFollowerRegistry() {
                 lastHeartbeatMs: existing?.lastHeartbeatMs ?? registration.connectedAtMs,
             };
             followers.set(registration.instanceId, next);
+            for (const observation of observations) {
+                if (!hasTelegramBusFollowerIdentityOverlap(next, observation.follower))
+                    continue;
+                observation.current = false;
+                observations.delete(observation);
+            }
             return clone(next);
         },
         heartbeat: (instanceId, nowMs) => {
@@ -1384,7 +1392,26 @@ export function createTelegramBusFollowerRegistry() {
         },
         list: () => [...followers.values()].map(clone),
         remove: (instanceId) => followers.delete(instanceId),
-        clear: () => followers.clear(),
+        clear: () => {
+            followers.clear();
+            for (const observation of observations)
+                observation.current = false;
+            observations.clear();
+        },
+        observeUnregistered: (follower) => {
+            // This watches replacement, not process death or delivery authority.
+            const observation = { follower: clone(follower), current: ![...followers.values()]
+                    .some((current) => hasTelegramBusFollowerIdentityOverlap(current, follower)) };
+            if (observation.current)
+                observations.add(observation);
+            return {
+                isCurrent: () => observation.current,
+                release() {
+                    observation.current = false;
+                    observations.delete(observation);
+                },
+            };
+        },
         pruneStale: (nowMs, staleAfterMs) => {
             const removed = [];
             for (const [instanceId, follower] of followers.entries()) {

package/node_modules/@llblab/pi-telegram/dist/lib/extension.js

@@ -79,7 +79,7 @@ export default function (pi) {
     const workspaceAdmissionRuntime = WorkspaceAdmission.createTelegramWorkspaceAdmissionRuntimeBinding({
         getProfileName: configStore.getActiveProfileName,
         getBotToken: configStore.getBotToken,
-        getPath: Paths.resolveTelegramWorkspaceAdmissionPath,
+        getPath: Paths.resolveTelegramWorkspaceAdmissionPathForProfile,
         owner: {
             processId: telegramProcessId,
             processBirthId: telegramQueueProcessBirthId,
@@ -146,7 +146,7 @@ export default function (pi) {
             },
             getWorkspaceAdmission: workspaceAdmissionRuntime.resolve,
         },
-        getLeaderJournalPath: Paths.resolveTelegramUpdateJournalPath,
+        getLeaderJournalPath: Paths.resolveTelegramUpdateJournalPathForProfile,
         getFollowerJournalPath(bindingKey, profileName) {
             return Paths.resolveTelegramFollowerJournalPath(bindingKey, undefined, profileName);
         },
@@ -295,6 +295,45 @@ export default function (pi) {
                 : "clear";
         },
     });
+    const reclaimTelegramWorkspaceDeadOwnerQueue = WorkspaceRetirement.createTelegramWorkspaceDeadOwnerQueueReclaimer({
+        getExternalProtection: captureWorkspaceExternalProtection,
+        getActiveTurnTarget: activeTurnRuntime.getTarget,
+        getQueuedItems: telegramQueueStore.getQueuedItems,
+        resolveLeaderJournal: resolveTelegramUpdateJournalBinding,
+        createFollowerJournalResolver: telegramJournalBindingRuntime.createRecipientResolver,
+        discoverFollowerJournals() {
+            return Journal.discoverTelegramFollowerJournalPaths({
+                directory: Paths.resolveTelegramTempDir(),
+                profileName: configStore.getActiveProfileName(),
+            });
+        },
+        createJournalPathResolver: telegramJournalBindingRuntime.createPathResolver,
+        withJournalReference(binding, operation) {
+            if (!binding.recoveryKey)
+                throw new Error("Telegram workspace journal reference identity is unavailable.");
+            return telegramJournalReferenceRegistry.withReference({
+                referenceClass: "workspace-retirement",
+                recoveryKey: binding.recoveryKey,
+            }, operation);
+        },
+        getRecoveryOwner() {
+            return {
+                instanceId: telegramInstanceId,
+                processId: telegramProcessId,
+                processBirthId: telegramQueueProcessBirthId,
+                sessionGeneration: telegramSessionContextStore.getGeneration(),
+            };
+        },
+        getQueueOwnerLiveness: Bus.getTelegramProcessLiveness,
+        onMutationError(error) {
+            recordRuntimeEvent("Telegram dead-owner queue reclamation was refused.", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        },
+        isBindingCurrent(binding) {
+            return WorkspaceRetirement.isCurrentTelegramWorkspaceBinding(threadStore, binding);
+        },
+    });
     const inactiveThreadCleanupReviewRuntime = ThreadCleanupManager.createTelegramInactiveThreadCleanupReviewRuntime({
         getProfileName() { return configStore.getActiveProfileName() ?? "default"; },
         listBindings: threadStore.listWorkspaceBindings,
@@ -1169,6 +1208,18 @@ export default function (pi) {
         getWorkspaceAdmission: workspaceAdmissionRuntime.resolve,
         runWorkspaceOperation: telegramWorkspaceOperationRuntime.run,
         captureWorkspaceExternalProtection,
+        workspaceRotation: {
+            getAdmission: workspaceAdmissionRuntime.resolve,
+            runExclusive: telegramWorkspaceOperationRuntime.runExclusive,
+            deleteThread: directTelegramApiRuntime.deleteWorkspaceThread,
+            reclaimDeadOwnerQueuedWork(binding, isCurrent) {
+                return telegramWorkspaceOperationRuntime.run({
+                    operationId: WorkspaceAdmission.createTelegramWorkspaceAdmissionOperationId(),
+                    operationKind: "workspace.reclaim-dead-owner-queue",
+                    scopes: [{ kind: "target", target: binding.target }],
+                }, reclaimTelegramWorkspaceDeadOwnerQueue.bind(undefined, binding, isCurrent));
+            },
+        },
         callApi(method, body, options) {
             return directTelegramApiRuntime.call(method, body, options);
         },
@@ -1282,6 +1333,15 @@ export default function (pi) {
         recordRuntimeEvent,
         runWorkspaceOperation: telegramWorkspaceOperationRuntime.run,
     });
+    const prepareThreadPreservationOnQuit = Sync.createTelegramPreservedLeaderQuitHandler({
+        instanceId: telegramInstanceId,
+        topicTargetStore: threadStore,
+        getCurrentLeaderEpoch,
+        getProfileName: configStore.getActiveProfileName,
+        isPollingSuspended: lockedPollingRuntime.isSuspended,
+        resolveAutomaticThreadCleanupEnabled: configControls.resolveAutomaticThreadCleanupEnabled,
+        runWorkspaceOperation: telegramWorkspaceOperationRuntime.run,
+    });
     const telegramBridgeSessionLifecycleDeps = Lifecycle.createTelegramBridgeSessionLifecycleDeps({
         contextStore: telegramSessionContextStore,
         queue: {
@@ -1335,6 +1395,7 @@ export default function (pi) {
             capabilityMonitor: telegramThreadCapabilityMonitor,
             queueWatchdog: queueDispatchWatchdogRuntime,
             guestPlaceholder: { stopAll: guestPlaceholderRuntime.stopAll },
+            prepareThreadPreservationOnQuit,
         },
     });
     const sessionLifecycleRuntime = Lifecycle.createTelegramBridgeSessionLifecycleAssembly(telegramBridgeSessionLifecycleDeps);