@ponythewhite/base-context 1.0.0 → 1.0.2

package/dist/modes/daemon/daemon-supervisor.js

@@ -28,13 +28,14 @@ import { CompactAssistantStreamReconstructor, isCompactAssistantDelta } from "./
 import { DAEMON_CATALOG_ROLE_ENV, DaemonCatalogClient } from "./daemon-catalog-process.js";
 import { deserializeDaemonError, serializeDaemonError } from "./daemon-errors.js";
 import { CANONICAL_SESSION_OWNERSHIP_COMPATIBILITY, collectDaemonClientEnv, createDaemonEventMeta, DAEMON_COMMAND_COMPATIBILITY, DAEMON_COMMAND_ENVELOPE_MIN_PROTOCOL_VERSION, DAEMON_DEFAULT_CLIENT_CAPABILITIES, DAEMON_DEFAULT_SERVER_CAPABILITIES, DAEMON_PROTOCOL_INFO, DAEMON_SCHEMA_ID, DAEMON_SCHEMA_REVISION, DAEMON_UPDATE_RESTART_FORMAT_VERSION, failure, isDaemonCommandEnvelope, isDaemonMutatingCommand, isLegacyDaemonInspection, salvageDaemonCommandId, success, UPDATE_RESTART_DRAIN_COMMANDS, } from "./daemon-protocol.js";
+import { DaemonRlmCapacityCoordinator } from "./daemon-rlm-capacity-coordinator.js";
 import { getDaemonRuntimeIdentity } from "./daemon-runtime-identity.js";
 import { matchesSessionIdSuffix } from "./daemon-session-id.js";
 import { classifySessionRosterStatus, isEvictableEmptySessionSummary, isSessionSummaryBusy, summaryForInactiveSession, } from "./daemon-session-list.js";
 import { acquireDaemonSocketPathLease, cleanupDaemonSocketPath, defaultDaemonSocketDir, defaultDaemonSocketPath, getDaemonSocketIdentity, normalizeSocketPath, prepareDaemonSocketPath, restrictDaemonSocketPath, } from "./daemon-socket.js";
 import { acquireDaemonSupervisorOwnership, isDaemonShutdownAdmissionActive, waitForDaemonStartupFence, } from "./daemon-supervisor-ownership.js";
 import { DaemonWorkerAuthenticationError, DaemonWorkerClient, DaemonWorkerCompatibilityError, DaemonWorkerProbeTimeoutError, } from "./daemon-worker-client.js";
-import { DAEMON_WORKER_ACTIVE_SESSION_ID_ENV, DAEMON_WORKER_INSTANCE_ID_ENV, DAEMON_WORKER_PEER_TRANSPORT_CAPABILITY, DAEMON_WORKER_RECOVERY_JOURNAL_ENV, DAEMON_WORKER_ROLE_ENV, DAEMON_WORKER_ROSTER_CAPABILITY, DAEMON_WORKER_STARTUP_GATE_COMMIT, DAEMON_WORKER_STARTUP_GATE_FD_ENV, DAEMON_WORKER_SUPERVISOR_SOCKET_ENV, DAEMON_WORKER_TOKEN_ENV, durableDaemonCreateCommand, durableDaemonWorkerDescriptor, ROSTER_HEARTBEAT_INTERVAL_MS, SESSION_LEASE_OWNER_ID_ENV, SESSION_LEASES_ENABLED_ENV, } from "./daemon-worker-protocol.js";
+import { DAEMON_WORKER_ACTIVE_SESSION_ID_ENV, DAEMON_WORKER_INSTANCE_ID_ENV, DAEMON_WORKER_PEER_TRANSPORT_CAPABILITY, DAEMON_WORKER_RECOVERY_JOURNAL_ENV, DAEMON_WORKER_ROLE_ENV, DAEMON_WORKER_ROSTER_CAPABILITY, DAEMON_WORKER_STARTUP_GATE_COMMIT, DAEMON_WORKER_STARTUP_GATE_FD_ENV, DAEMON_WORKER_SUPERVISOR_SOCKET_ENV, DAEMON_WORKER_TOKEN_ENV, durableDaemonCreateCommand, durableDaemonWorkerDescriptor, isDaemonRlmCapacitySnapshot, ROSTER_HEARTBEAT_INTERVAL_MS, SESSION_LEASE_OWNER_ID_ENV, SESSION_LEASES_ENABLED_ENV, } from "./daemon-worker-protocol.js";
 import { MutationDrainLatch } from "./mutation-drain-latch.js";
 import { createRlmLedgerRegistrySeedSource, RlmSpawnLedger, rlmLedgerPath, tombstoneSavedSessionDelete, } from "./rlm-ledger.js";
 import { captureSavedSessionPageQuery } from "./saved-session-page.js";
@@ -86,6 +87,7 @@ const DAEMON_COMMAND_TYPES = new Set([
     "list",
     "list_agent_peers",
     "rlm_ledger_mutate",
+    "rlm_capacity",
     "get_direct_worker_transport",
     "roster_subscribe",
     "roster_unsubscribe",
@@ -177,6 +179,8 @@ const DAEMON_COMMAND_TYPES = new Set([
     "set_session_name",
     "get_rlm_max_depth_status",
     "set_rlm_max_depth",
+    "get_rlm_max_subagents_status",
+    "set_rlm_max_subagents",
     "rename_saved_session",
     "delete_saved_session",
     "get_session_context",
@@ -448,6 +452,9 @@ export class DaemonSupervisor {
     pendingSessionNames = new Set();
     catalog;
     settingsManager;
+    rlmCapacity;
+    pendingRlmCapacity = new Set();
+    releasedDuringCapacityRecovery = new Map();
     rosterStore;
     pendingRosterChanged = new Set();
     pendingRosterRemoved = new Set();
@@ -482,6 +489,7 @@ export class DaemonSupervisor {
         this.snapshotCacheRoot = join(this.descriptorDir, "snapshot-cache", this.generation);
         this.catalog = new DaemonCatalogClient((message) => this.log(message));
         this.settingsManager = SettingsManager.create(process.cwd(), this.defaultSessionConfig.agentDir ?? agentDir);
+        this.rlmCapacity = new DaemonRlmCapacityCoordinator(this.settingsManager);
     }
     async start() {
         try {
@@ -515,6 +523,8 @@ export class DaemonSupervisor {
             this.commandJournal = new CommandRecoveryJournal(join(this.descriptorDir, "command-journal.jsonl"));
             this.loadWorkerDescriptors();
             const workersToAdopt = [...this.workers.values()];
+            for (const worker of workersToAdopt)
+                this.pendingRlmCapacity.add(worker);
             this.server = createServer((socket) => this.handleConnection(socket));
             await this.listen();
             this.assertSocketLeaseHeld();
@@ -542,7 +552,7 @@ export class DaemonSupervisor {
             let adoptionFailed = false;
             await Promise.all(workersToAdopt.map(async (worker) => {
                 try {
-                    await this.adoptOrRecoverWorker(worker);
+                    await this.adoptOrRecoverWorker(worker, this.ready);
                 }
                 catch (error) {
                     if (!adoptionFailed) {
@@ -1389,7 +1399,8 @@ export class DaemonSupervisor {
     isWorkerLedgerEnvelope(line) {
         try {
             const parsed = JSON.parse(line);
-            return isDaemonCommandEnvelope(parsed) && parsed.command.type === "rlm_ledger_mutate";
+            return (isDaemonCommandEnvelope(parsed) &&
+                (parsed.command.type === "rlm_ledger_mutate" || parsed.command.type === "rlm_capacity"));
         }
         catch {
             return false;
@@ -1449,7 +1460,7 @@ export class DaemonSupervisor {
             return;
         }
         try {
-            await waitForPromptAdmission(this.assertServingCurrentOwnership(command.type === "rlm_ledger_mutate"), parsedAdmission?.controller.signal);
+            await waitForPromptAdmission(this.assertServingCurrentOwnership(command.type === "rlm_ledger_mutate" || command.type === "rlm_capacity"), parsedAdmission?.controller.signal);
         }
         catch (error) {
             if (parsedAdmission)
@@ -1481,7 +1492,7 @@ export class DaemonSupervisor {
         const restartRejected = phase === "draining"
             ? !UPDATE_RESTART_DRAIN_COMMANDS.has(command.type)
             : phase !== undefined && !(phase === "prepared" && command.type === "shutdown");
-        if (restartRejected && mutation && command.type !== "rlm_ledger_mutate") {
+        if (restartRejected && mutation && command.type !== "rlm_ledger_mutate" && command.type !== "rlm_capacity") {
             if (parsedAdmission)
                 this.deletePromptAdmission(parsedAdmission);
             this.write(client, failure(command.id, command.type, "Daemon is preparing an update restart"));
@@ -1492,7 +1503,7 @@ export class DaemonSupervisor {
             if (idleEvictionFence) {
                 await idleEvictionFence;
                 try {
-                    await this.assertServingCurrentOwnership(command.type === "rlm_ledger_mutate");
+                    await this.assertServingCurrentOwnership(command.type === "rlm_ledger_mutate" || command.type === "rlm_capacity");
                 }
                 catch (error) {
                     if (parsedAdmission)
@@ -1569,6 +1580,146 @@ export class DaemonSupervisor {
                 this.mutationDrain.end();
         }
     }
+    rlmCapacityOwner(worker) {
+        return `${worker.descriptor.workerId}:${worker.descriptor.workerInstanceId ?? "unavailable"}`;
+    }
+    async rlmCapacityFamily(sessionFile, owner, sessionId) {
+        if (!sessionFile)
+            return `memory:${owner}:${sessionId}`;
+        const parents = new Map((await this.rlmSpawnLedger().liveEdges({ strict: true })).map((edge) => [canonicalSessionPath(edge.child), canonicalSessionPath(edge.parent)]));
+        let root = canonicalSessionPath(sessionFile);
+        const visited = new Set();
+        while (parents.has(root)) {
+            if (visited.has(root))
+                throw new Error("RLM family ancestry contains a cycle");
+            visited.add(root);
+            const parent = parents.get(root);
+            if (parent === undefined)
+                break;
+            root = parent;
+        }
+        return `file:${root}`;
+    }
+    isRlmMainRoot(sessionFile, family) {
+        return sessionFile === undefined || family === `file:${canonicalSessionPath(sessionFile)}`;
+    }
+    releaseWorkerRlmCapacity(worker) {
+        this.rlmCapacity.releaseOwner(this.rlmCapacityOwner(worker));
+        this.pendingRlmCapacity.delete(worker);
+        this.releasedDuringCapacityRecovery.delete(worker);
+    }
+    async assertRlmCapacityKnown(family) {
+        for (const worker of [...this.pendingRlmCapacity]) {
+            const identity = this.processIdentity(worker.descriptor.pid, worker.descriptor.processStartId);
+            if (identity === "gone" || identity === "replaced") {
+                this.releaseWorkerRlmCapacity(worker);
+                continue;
+            }
+            const path = worker.descriptor.sessionFile ?? worker.descriptor.createCommand.sessionPath;
+            const pendingFamily = path
+                ? await this.rlmCapacityFamily(path, this.rlmCapacityOwner(worker), worker.descriptor.rootSessionId ?? "pending")
+                : undefined;
+            if (this.pendingRlmCapacity.has(worker) && (pendingFamily === undefined || pendingFamily === family)) {
+                throw new Error("RLM family capacity is waiting for a live worker to reconnect");
+            }
+        }
+    }
+    async restoreWorkerRlmCapacity(worker, client) {
+        if (!this.pendingRlmCapacity.has(worker))
+            return;
+        const owner = this.rlmCapacityOwner(worker);
+        const response = await client.requestWorker({ type: "worker_get_rlm_capacity" }, 2000);
+        if (!response.success)
+            throw deserializeDaemonError(response);
+        if (!isDaemonRlmCapacitySnapshot(response.data))
+            throw new Error("Worker returned an invalid RLM capacity snapshot");
+        const recovered = await Promise.all(response.data.reservations.map(async (reservation) => ({
+            reservation,
+            family: await this.rlmCapacityFamily(reservation.sessionFile, owner, reservation.sessionId),
+        })));
+        if (this.rlmCapacityOwner(worker) !== owner || !this.pendingRlmCapacity.has(worker))
+            return;
+        const released = this.releasedDuringCapacityRecovery.get(worker);
+        for (const { reservation, family } of recovered) {
+            if (released?.has(reservation.reservationId))
+                continue;
+            if (reservation.residentRoot && this.isRlmMainRoot(reservation.sessionFile, family))
+                continue;
+            this.rlmCapacity.restore(owner, reservation.reservationId, family);
+        }
+        this.pendingRlmCapacity.delete(worker);
+        this.releasedDuringCapacityRecovery.delete(worker);
+    }
+    async handleRlmCapacity(command) {
+        const worker = [...this.workers.values()].find((candidate) => candidate.descriptor.authenticationToken === command.workerToken &&
+            candidate.descriptor.workerInstanceId === command.workerInstanceId);
+        if (!worker ||
+            !command.workerInstanceId ||
+            worker.compatibilityError ||
+            this.processIdentity(worker.descriptor.pid, worker.descriptor.processStartId) !== "current") {
+            throw new Error("Worker authentication failed for RLM capacity");
+        }
+        const owner = this.rlmCapacityOwner(worker);
+        const journal = this.assertRlmJournalAdmission();
+        const scope = this.rlmJournalScope(worker.descriptor.sessionDir ?? this.defaultSessionConfig.sessionDir);
+        if (canonicalSessionPath(scope.journalPath) !== journal.ledgerPath) {
+            throw new Error("Worker RLM family is not owned by this supervisor");
+        }
+        const operation = command.operation;
+        if (!operation || typeof operation !== "object")
+            throw new Error("Invalid RLM capacity operation");
+        if (operation.op === "release") {
+            if (typeof operation.reservationId !== "string" || !operation.reservationId)
+                throw new Error("Invalid RLM reservation id");
+            this.rlmCapacity.release(owner, operation.reservationId);
+            if (this.pendingRlmCapacity.has(worker)) {
+                let released = this.releasedDuringCapacityRecovery.get(worker);
+                if (!released) {
+                    released = new Set();
+                    this.releasedDuringCapacityRecovery.set(worker, released);
+                }
+                released.add(operation.reservationId);
+            }
+            return success(command.id, command.type);
+        }
+        if (operation.op !== "status" && operation.op !== "set" && operation.op !== "reserve")
+            throw new Error("Unknown RLM capacity operation");
+        if (typeof operation.sessionId !== "string" ||
+            !operation.sessionId ||
+            (operation.sessionFile !== undefined && (typeof operation.sessionFile !== "string" || !operation.sessionFile))) {
+            throw new Error("Invalid RLM capacity origin");
+        }
+        const family = await this.rlmCapacityFamily(operation.sessionFile, owner, operation.sessionId);
+        await this.assertServingCurrentOwnership(true);
+        if (this.rlmCapacityOwner(worker) !== owner || worker.descriptor.authenticationToken !== command.workerToken) {
+            throw new Error("RLM capacity worker incarnation changed");
+        }
+        if (operation.op === "status")
+            return success(command.id, command.type, this.rlmCapacity.getStatus(family));
+        if (this.shuttingDown || this.updateRestartPhase !== undefined || worker.descriptor.stopRequestedAt) {
+            throw new Error("RLM capacity admission is closed while the worker or daemon is stopping");
+        }
+        if (operation.op === "set") {
+            return success(command.id, command.type, await this.rlmCapacity.setMaxSubagents(family, operation.maxSubagents));
+        }
+        if (typeof operation.reservationId !== "string" ||
+            !operation.reservationId ||
+            (operation.residentRoot !== undefined && operation.residentRoot !== true))
+            throw new Error("Invalid RLM reservation");
+        if (operation.residentRoot && this.isRlmMainRoot(operation.sessionFile, family)) {
+            return success(command.id, command.type, this.rlmCapacity.getStatus(family));
+        }
+        await this.assertRlmCapacityKnown(family);
+        await this.assertServingCurrentOwnership();
+        if (this.updateRestartPhase !== undefined ||
+            worker.descriptor.stopRequestedAt ||
+            this.rlmCapacityOwner(worker) !== owner ||
+            this.workers.get(worker.descriptor.workerId) !== worker ||
+            this.processIdentity(worker.descriptor.pid, worker.descriptor.processStartId) !== "current") {
+            throw new Error("RLM capacity admission changed while resolving its family");
+        }
+        return success(command.id, command.type, this.rlmCapacity.reserve(owner, operation.reservationId, family));
+    }
     async handleCommand(client, command, cancellationAdmission) {
         switch (command.type) {
             case "cancel_prompt_admission": {
@@ -1631,6 +1782,8 @@ export class DaemonSupervisor {
                 });
                 return success(command.id, command.type, { peers });
             }
+            case "rlm_capacity":
+                return this.handleRlmCapacity(command);
             case "rlm_ledger_mutate": {
                 const worker = [...this.workers.values()].find((candidate) => candidate.descriptor.authenticationToken === command.workerToken);
                 if (!worker ||
@@ -2774,7 +2927,6 @@ export class DaemonSupervisor {
                 rootActiveSessionId,
                 ownerClientId: existing?.descriptor.ownerClientId ?? ownerClientId,
                 sessionDir: createCommand.config?.sessionDir,
-                telemetryDisabled: createCommand.config?.telemetryDisabled,
                 createdAt: existing?.descriptor.createdAt ?? now,
                 updatedAt: now,
                 lifecycle: "starting",
@@ -2954,6 +3106,7 @@ export class DaemonSupervisor {
                     if (!workerAuthAdvertisesRoster(authResponse.data)) {
                         throw new PreRosterWorkerError("Session worker predates the roster protocol and must be restarted");
                     }
+                    await this.restoreWorkerRlmCapacity(worker, client);
                     worker.peerTransportCapable = workerAuthAdvertisesPeerTransport(authResponse.data);
                     worker.lastFrameAt = Date.now();
                     worker.client?.close();
@@ -3014,7 +3167,7 @@ export class DaemonSupervisor {
             throw new Error(response.error);
         }
     }
-    async adoptOrRecoverWorker(worker) {
+    async adoptOrRecoverWorker(worker, recoveryReady) {
         await this.assertRecoveryAllowed();
         if (worker.descriptor.stopRequestedAt) {
             try {
@@ -3078,6 +3231,17 @@ export class DaemonSupervisor {
                 return;
             }
             this.log(`Could not adopt worker ${worker.descriptor.workerId}: ${String(error)}`);
+            if (recoveryReady) {
+                // Recovery can create workers that call back for capacity. Keep it single-flight,
+                // but let adoption finish before those callbacks need the normal ready gate.
+                void this.recoverWorker(worker, {
+                    ready: recoveryReady,
+                    ...(error instanceof PreRosterWorkerError && worker.descriptor.ownerClientId === undefined
+                        ? { preRoster: { observedProcessStartId } }
+                        : {}),
+                }).catch((recoveryError) => this.log(`Could not recover worker ${worker.descriptor.workerId}: ${String(recoveryError)}`));
+                return;
+            }
             // A client-owned worker's launch env lives only with its owner; recoverWorker parks it instead.
             if (error instanceof PreRosterWorkerError && worker.descriptor.ownerClientId === undefined) {
                 try {
@@ -3103,7 +3267,13 @@ export class DaemonSupervisor {
         }
     }
     async restartPreRosterWorker(worker, observedProcessStartId) {
+        const stopRevision = worker.stopRevision;
+        const workerInstanceId = worker.descriptor.workerInstanceId;
         await this.assertRecoveryAllowed();
+        if (this.isWorkerRecoveryCancelled(worker) ||
+            worker.stopRevision !== stopRevision ||
+            worker.descriptor.workerInstanceId !== workerInstanceId)
+            return;
         if (worker.descriptor.processStartId === undefined && observedProcessStartId !== undefined) {
             worker.descriptor.processStartId = observedProcessStartId;
         }
@@ -3390,11 +3560,12 @@ export class DaemonSupervisor {
             validation.resolve();
         }
     }
-    async recoverWorker(worker) {
+    async recoverWorker(worker, startup) {
         if (this.isWorkerRecoveryCancelled(worker)) {
             return;
         }
         if (worker.descriptor.ownerClientId && !worker.launchEnv && !isProcessAlive(worker.descriptor.pid)) {
+            this.releaseWorkerRlmCapacity(worker);
             worker.descriptor.lifecycle = "failed";
             worker.descriptor.lastError = "Waiting for the owning client to reconnect";
             this.persistWorker(worker);
@@ -3403,7 +3574,27 @@ export class DaemonSupervisor {
         if (worker.recovery) {
             return worker.recovery;
         }
+        const stopRevision = worker.stopRevision;
+        const workerInstanceId = worker.descriptor.workerInstanceId;
         worker.recovery = (async () => {
+            if (startup) {
+                await startup.ready;
+                if (this.isWorkerRecoveryCancelled(worker) ||
+                    worker.stopRevision !== stopRevision ||
+                    worker.descriptor.workerInstanceId !== workerInstanceId)
+                    return;
+                if (startup.preRoster) {
+                    try {
+                        await this.restartPreRosterWorker(worker, startup.preRoster.observedProcessStartId);
+                        return;
+                    }
+                    catch (restartError) {
+                        if (isSupervisorRecoveryCancelled(restartError))
+                            return;
+                        this.log(`Could not restart pre-roster worker ${worker.descriptor.workerId}: ${String(restartError)}`);
+                    }
+                }
+            }
             let keepProbingLiveWorker = false;
             for (const retryDelay of WORKER_RETRY_DELAYS_MS) {
                 await delay(retryDelay);
@@ -3455,6 +3646,7 @@ export class DaemonSupervisor {
                         keepProbingLiveWorker = true;
                         throw new Error(`Cannot safely replace live session worker ${worker.descriptor.workerId} without a verified process identity`);
                     }
+                    this.releaseWorkerRlmCapacity(worker);
                     const recoveryCommand = worker.descriptor.ownerClientId ? worker.transientCreateCommand : undefined;
                     if (!recoveryCommand || !worker.launchEnv) {
                         await this.recoverUncertainWorkerOperations(worker);
@@ -3773,6 +3965,16 @@ export class DaemonSupervisor {
         return worker === undefined || this.isVisibleWorker(worker);
     }
     writeRosterEntry(entry, worker, statusLabel) {
+        const existing = entry.summary.sessionFile
+            ? this.roster().bySessionFile(entry.summary.sessionFile)
+            : this.roster().get(entry.agentId);
+        // A parent's saved-child row cannot replace that child's independent live worker.
+        if (worker &&
+            !entry.summary.activeSessionId &&
+            existing?.summary.activeSessionId &&
+            existing.workerId !== undefined &&
+            existing.workerId !== worker.descriptor.workerId)
+            return existing;
         const previousDirect = this.roster().get(entry.agentId)?.summary.directAttachedClients ?? 0;
         const stored = this.roster().write(entry, worker?.descriptor.workerId, statusLabel);
         // Direct peers attach and detach on the worker socket, so their last detach arrives
@@ -4433,16 +4635,12 @@ export class DaemonSupervisor {
             if (ownedWorker.descriptor.ownerClientId !== this.protocolClientId(client)) {
                 throw new Error(`Unknown active session: ${command.activeSessionId}`);
             }
-            this.assertTelemetryAttachAllowed(ownedWorker, command.telemetryDisabled);
             ownedWorker.launchEnv = command.launchEnv ?? ownedWorker.launchEnv;
             if (!ownedWorker.client || ownedWorker.descriptor.lifecycle !== "ready") {
                 if (command.recoveryConfig) {
                     ownedWorker.transientCreateCommand = {
                         ...ownedWorker.descriptor.createCommand,
-                        config: {
-                            ...command.recoveryConfig,
-                            ...(ownedWorker.descriptor.telemetryDisabled === true ? { telemetryDisabled: true } : {}),
-                        },
+                        config: command.recoveryConfig,
                         env: command.env,
                         launchEnv: command.launchEnv,
                         lifecycle: "client_owned",
@@ -4462,7 +4660,6 @@ export class DaemonSupervisor {
             }
         }
         const match = await this.findWorkerForClient(client, command.activeSessionId);
-        this.assertTelemetryAttachAllowed(match.worker, command.telemetryDisabled);
         this.requireAvailableWorkerClient(match.worker);
         const activeSessionId = match.summary.activeSessionId ?? match.summary.id;
         const duplicateValidation = this.currentSnapshotGeneration(match.worker, activeSessionId)?.validation;
@@ -4609,11 +4806,6 @@ export class DaemonSupervisor {
             throw error;
         }
     }
-    assertTelemetryAttachAllowed(worker, telemetryDisabled) {
-        if (telemetryDisabled && worker.descriptor.telemetryDisabled !== true) {
-            throw new Error("Cannot attach to this active agent while telemetry is disabled for the current invocation. Stop the agent and retry so it can restart without telemetry.");
-        }
-    }
     cacheLoadedSnapshot(worker, activeSessionId, loaded, observedSnapshotId) {
         const currentTranscript = worker.transcriptCaches.get(activeSessionId);
         const currentGeneration = this.currentSnapshotGeneration(worker, activeSessionId);
@@ -5721,6 +5913,7 @@ export class DaemonSupervisor {
         if (removeDescriptor && worker.descriptor.ownerClientId !== undefined) {
             ephemeralCancelSettled = await this.cancelEphemeralWorkerScheduledJobs(worker);
         }
+        this.releaseWorkerRlmCapacity(worker);
         this.workers.delete(worker.descriptor.workerId);
         this.flipWorkerRosterEntriesInactive(worker);
         // A failed cancel keeps the stop tombstone as the durable intent; the enumeration retry or the next boot finishes it.