@neuralnomads/codenomad-dev 0.18.0-dev-20260716-40cee071 → 0.18.0-dev-20260720-4c50829d

package/dist/workspaces/manager.js

@@ -2,6 +2,7 @@ import path from "path";
 import { spawnSync } from "child_process";
 import { randomUUID } from "node:crypto";
 import { connect } from "net";
+import { setTimeout as delay } from "node:timers/promises";
 import { FileSystemBrowser } from "../filesystem/browser";
 import { searchWorkspaceFiles } from "../filesystem/search";
 import { clearWorkspaceSearchCache } from "../filesystem/search-cache";
@@ -9,79 +10,93 @@ import { WorkspaceRuntime } from "./runtime";
 import { buildOpencodeConfigContent, getCodeNomadPluginUrl, resolveExistingOpencodeConfigContent, } from "../opencode-plugin.js";
 import { OPENCODE_SERVER_BASE_URL_ENV, buildOpencodeBasicAuthHeader, OPENCODE_SERVER_PASSWORD_ENV, OPENCODE_SERVER_USERNAME_ENV, resolveOpencodeServerAuth, } from "./opencode-auth";
 import { resolveWorkspaceIdentity } from "./workspace-identity";
+import { parseWslUncPath } from "./spawn";
 const STARTUP_STABILITY_DELAY_MS = 1500;
+const DEFAULT_LAUNCH_TIMEOUT_MS = 30_000;
+const ORDINARY_CREATION_OWNER = "";
+const WORKSPACE_STATE = Symbol("workspaceState");
+export function binaryPathsEqual(left, right, platform = process.platform) {
+    const leftWsl = parseWslUncPath(left);
+    const rightWsl = parseWslUncPath(right);
+    if (leftWsl || rightWsl) {
+        return Boolean(leftWsl
+            && rightWsl
+            && leftWsl.distro.toLowerCase() === rightWsl.distro.toLowerCase()
+            && leftWsl.linuxPath === rightWsl.linuxPath);
+    }
+    return platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
+}
 export class WorkspaceLaunchCancelledError extends Error {
     constructor(workspaceId) {
         super(`Workspace ${workspaceId} launch was cancelled`);
         this.name = "WorkspaceLaunchCancelledError";
     }
 }
-export class WorkspaceShutdownTimeoutError extends Error {
-    constructor(timeoutMs) {
-        super(`Workspace shutdown did not finish within ${timeoutMs}ms; remaining workspace cleanup can be retried`);
-        this.code = "WORKSPACE_SHUTDOWN_TIMEOUT";
+export class WorkspaceLaunchTimeoutError extends Error {
+    constructor(workspaceId, timeoutMs) {
+        super(`${workspaceId ? `Workspace ${workspaceId}` : "Workspace"} did not finish launching within ${timeoutMs}ms`);
+        this.code = "WORKSPACE_LAUNCH_TIMEOUT";
         this.retryable = true;
-        this.name = "WorkspaceShutdownTimeoutError";
+        this.name = "WorkspaceLaunchTimeoutError";
     }
 }
-export class WorkspaceLaunchSettlementTimeoutError extends Error {
-    constructor(workspaceId, timeoutMs) {
-        super(`Workspace ${workspaceId} launch cancellation did not settle within ${timeoutMs}ms; cleanup can be retried`);
-        this.code = "WORKSPACE_LAUNCH_SETTLEMENT_TIMEOUT";
+export class WorkspaceCleanupTimeoutError extends Error {
+    constructor(operation, timeoutMs) {
+        super(`Workspace ${operation} did not finish within ${timeoutMs}ms; cleanup can be retried`);
+        this.code = "WORKSPACE_CLEANUP_TIMEOUT";
         this.retryable = true;
-        this.name = "WorkspaceLaunchSettlementTimeoutError";
+        this.name = "WorkspaceCleanupTimeoutError";
     }
 }
-export class WorkspaceShutdownError extends Error {
+export class WorkspaceShutdownError extends AggregateError {
     constructor(errors) {
-        super(`Failed to stop ${errors.length} workspace${errors.length === 1 ? "" : "s"} during shutdown; cleanup can be retried`);
+        super(errors, `Failed to stop ${errors.length} workspace${errors.length === 1 ? "" : "s"} during shutdown; cleanup can be retried`);
         this.code = "WORKSPACE_SHUTDOWN_FAILED";
         this.retryable = true;
         this.name = "WorkspaceShutdownError";
-        this.errors = errors;
     }
 }
 export class WorkspaceManager {
     constructor(options) {
         this.options = options;
         this.workspaces = new Map();
-        this.workspaceIdentities = new Map();
         this.pendingWorkspaceCreations = new Map();
-        this.pendingWorkspaceOwners = new Map();
         this.cancelledCreationRequests = new Set();
         this.shuttingDown = false;
         this.opencodeAuth = new Map();
         this.runtime = options.runtime ?? new WorkspaceRuntime(this.options.eventBus, this.options.logger);
         this.codeNomadPluginUrl = getCodeNomadPluginUrl();
-        this.shutdownTimeoutMs = Math.max(1, options.shutdownTimeoutMs ?? 10000);
-        this.launchSettlementTimeoutMs = Math.max(1, options.launchSettlementTimeoutMs ?? 5000);
-        this.scheduleTimeout = options.setTimeout ?? setTimeout;
-        this.cancelTimeout = options.clearTimeout ?? clearTimeout;
     }
     list() {
         return Array.from(this.workspaces.values())
-            .filter((record) => record.published)
-            .map((record) => record.descriptor);
+            .filter((record) => record[WORKSPACE_STATE].published);
     }
     get(id) {
         const record = this.workspaces.get(id);
-        return record?.published ? record.descriptor : undefined;
+        return record?.[WORKSPACE_STATE].published ? record : undefined;
     }
     getInstancePort(id) {
         const record = this.workspaces.get(id);
-        return record?.published ? record.descriptor.port : undefined;
+        return record?.[WORKSPACE_STATE].published ? record.port : undefined;
     }
     getInstanceAuthorizationHeader(id) {
-        return this.workspaces.get(id)?.published ? this.opencodeAuth.get(id)?.authorization : undefined;
+        return this.workspaces.get(id)?.[WORKSPACE_STATE].published ? this.opencodeAuth.get(id)?.authorization : undefined;
+    }
+    findReadyInstanceIdByBinary(binaryPath) {
+        const resolvedPath = this.resolveBinaryPath(binaryPath);
+        return this.list().find((workspace) => {
+            return workspace.status === "ready" && binaryPathsEqual(workspace.binaryId, resolvedPath);
+        })?.id;
     }
     findReadyWorkspaceByIdentity(identityKey, includeRestoreOwned) {
-        for (const [workspaceId, record] of this.workspaces) {
-            if (record.published
-                && !record.lifecycle.cancelled
-                && (includeRestoreOwned || !record.descriptor.requestId)
-                && record.descriptor.status === "ready"
-                && this.workspaceIdentities.get(workspaceId) === identityKey) {
-                return record.descriptor;
+        for (const record of this.workspaces.values()) {
+            const state = record[WORKSPACE_STATE];
+            if (state.published
+                && !state.abortController.signal.aborted
+                && (includeRestoreOwned || !record.requestId)
+                && record.status === "ready"
+                && record.identityKey === identityKey) {
+                return record;
             }
         }
         return undefined;
@@ -130,74 +145,70 @@ export class WorkspaceManager {
         browser.writeFile(relativePath, contents);
     }
     async create(folder, name, options = {}) {
-        const { workspacePath, identityKey } = await resolveWorkspaceIdentity(folder, this.options.rootDir);
-        if (options.requestId && this.cancelledCreationRequests.delete(options.requestId)) {
-            throw new Error(`Workspace creation request ${options.requestId} was cancelled`);
-        }
-        if (this.shuttingDown) {
-            throw new Error("Workspace manager is shutting down");
-        }
-        if (options.forceNew) {
-            const ownership = this.createOwnership(options.requestId);
-            const result = await this.createResolvedWorkspace(workspacePath, identityKey, name, options, ownership);
-            return this.resultForCreationOwner(result, options.requestId, ownership);
-        }
-        const existing = this.findReadyWorkspaceByIdentity(identityKey, Boolean(options.requestId));
-        if (existing) {
-            this.options.logger.info({ workspaceId: existing.id, folder: workspacePath }, "Reusing existing workspace");
-            const record = this.workspaces.get(existing.id);
-            if (options.requestId && record && record.creationOwnership.requestIds.size > 0) {
-                record.creationOwnership.requestIds.add(options.requestId);
-                this.syncCreationOwnership(record);
-                return this.resultForCreationOwner({ workspace: existing, created: false }, options.requestId, record.creationOwnership);
+        const launchTimeoutMs = Math.max(1, this.options.launchTimeoutMs ?? DEFAULT_LAUNCH_TIMEOUT_MS);
+        const launchDeadlineAt = Date.now() + launchTimeoutMs;
+        try {
+            const { workspacePath, identityKey } = await this.withLaunchDeadline(resolveWorkspaceIdentity(folder, this.options.rootDir), undefined, launchDeadlineAt, launchTimeoutMs);
+            if (options.requestId && this.cancelledCreationRequests.has(options.requestId)) {
+                throw new Error(`Workspace creation request ${options.requestId} was cancelled`);
             }
-            return { workspace: existing, created: false };
-        }
-        const pending = this.pendingWorkspaceCreations.get(identityKey);
-        if (pending) {
-            pending.followerCount += 1;
-            if (options.requestId) {
-                pending.ownership.requestIds.add(options.requestId);
+            if (this.shuttingDown) {
+                throw new Error("Workspace manager is shutting down");
+            }
+            if (options.forceNew) {
+                const ownership = this.createOwnership(options.requestId);
+                const record = this.reserveWorkspace(workspacePath, identityKey, name, options, ownership, launchDeadlineAt);
+                const result = await this.startCreation(record, options, launchDeadlineAt, launchTimeoutMs);
+                return this.finishCreation(result, options.requestId, ownership);
             }
-            else {
-                const workspaceId = this.pendingWorkspaceOwners.get(identityKey);
-                if (workspaceId) {
-                    this.retainCreationOwnership(this.workspaces.get(workspaceId));
+            const existing = this.findReadyWorkspaceByIdentity(identityKey, Boolean(options.requestId));
+            if (existing) {
+                this.options.logger.info({ workspaceId: existing.id, folder: workspacePath }, "Reusing existing workspace");
+                const record = this.workspaces.get(existing.id);
+                if (options.requestId && record) {
+                    if (!record.ownership.has(options.requestId))
+                        record.ownership.set(options.requestId, "active");
+                    this.syncOwnership(record);
+                    return this.finishCreation({ workspace: existing, created: false }, options.requestId, record.ownership);
                 }
-                else {
-                    pending.ownership.sharedByNonRestoreCaller = true;
+                return { workspace: existing, created: false };
+            }
+            const pending = this.pendingWorkspaceCreations.get(identityKey);
+            if (pending) {
+                const state = pending[WORKSPACE_STATE];
+                const owner = options.requestId ?? ORDINARY_CREATION_OWNER;
+                if (!pending.ownership.has(owner))
+                    pending.ownership.set(owner, "active");
+                this.syncOwnership(pending);
+                const result = await state.creation;
+                return this.finishCreation({ workspace: result.workspace, created: false }, options.requestId, pending.ownership);
+            }
+            const ownership = this.createOwnership(options.requestId);
+            const record = this.reserveWorkspace(workspacePath, identityKey, name, options, ownership, launchDeadlineAt);
+            const creation = this.startCreation(record, options, launchDeadlineAt, launchTimeoutMs);
+            this.pendingWorkspaceCreations.set(identityKey, record);
+            try {
+                return this.finishCreation(await creation, options.requestId, ownership);
+            }
+            finally {
+                if (this.pendingWorkspaceCreations.get(identityKey) === record) {
+                    this.pendingWorkspaceCreations.delete(identityKey);
                 }
             }
-            const result = await pending.promise;
-            return this.resultForCreationOwner({ workspace: result.workspace, created: false }, options.requestId, pending.ownership);
-        }
-        const ownership = this.createOwnership(options.requestId);
-        const creation = this.createResolvedWorkspace(workspacePath, identityKey, name, options, ownership, (workspaceId) => {
-            this.pendingWorkspaceOwners.set(identityKey, workspaceId);
-        });
-        const pendingCreation = { promise: creation, ownership, followerCount: 0 };
-        this.pendingWorkspaceCreations.set(identityKey, pendingCreation);
-        try {
-            const result = await creation;
-            return this.resultForCreationOwner(options.requestId && pendingCreation.ownership.sharedByNonRestoreCaller
-                ? { workspace: result.workspace, created: false }
-                : result, options.requestId, pendingCreation.ownership);
         }
         finally {
-            if (this.pendingWorkspaceCreations.get(identityKey) === pendingCreation) {
-                this.pendingWorkspaceCreations.delete(identityKey);
-                this.pendingWorkspaceOwners.delete(identityKey);
-            }
+            if (options.requestId)
+                this.cancelledCreationRequests.delete(options.requestId);
         }
     }
-    async createResolvedWorkspace(workspacePath, identityKey, name, options, creationOwnership, onReserved) {
+    reserveWorkspace(workspacePath, identityKey, name, options, ownership, launchDeadlineAt) {
         const id = randomUUID();
         const binary = this.options.binaryResolver.resolve(options.binaryPath);
-        const resolvedBinaryPath = this.resolveBinaryPath(binary.path);
+        const resolvedBinaryPath = this.resolveBinaryPath(binary.path, Math.max(1, launchDeadlineAt - Date.now()));
         clearWorkspaceSearchCache(workspacePath);
         this.options.logger.info({ workspaceId: id, folder: workspacePath, binary: resolvedBinaryPath }, "Creating workspace");
         const proxyPath = `/workspaces/${id}/instance`;
-        const descriptor = {
+        const record = {
             id,
             requestId: options.requestId,
             path: workspacePath,
@@ -210,29 +221,60 @@ export class WorkspaceManager {
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
         };
-        let completeLaunch;
-        const completion = new Promise((resolve) => {
-            completeLaunch = resolve;
+        Object.defineProperties(record, {
+            identityKey: { value: identityKey },
+            ownership: { value: ownership },
+            [WORKSPACE_STATE]: { value: { abortController: new AbortController(), published: false, stoppedPublished: false } },
         });
-        const record = {
-            descriptor,
-            lifecycle: {
-                cancelled: false,
-                settled: false,
-                completion,
-                complete: completeLaunch,
-                stoppedEventPublished: false,
-            },
-            published: false,
-            creationOwnership,
-            releasedCreationRequestIds: new Set(),
-        };
         this.workspaces.set(id, record);
-        this.workspaceIdentities.set(id, identityKey);
-        onReserved?.(id);
-        if (options.requestId && this.cancelledCreationRequests.delete(options.requestId)) {
-            record.lifecycle.cancelled = true;
+        if (options.requestId && this.cancelledCreationRequests.has(options.requestId)) {
+            record[WORKSPACE_STATE].abortController.abort(new WorkspaceLaunchCancelledError(id));
+        }
+        return record;
+    }
+    startCreation(record, options, launchDeadlineAt, launchTimeoutMs) {
+        const creation = this.createWithDeadline(record, options, launchDeadlineAt, launchTimeoutMs);
+        record[WORKSPACE_STATE].creation = creation;
+        record[WORKSPACE_STATE].settlement = creation.then(() => undefined, () => undefined);
+        return creation;
+    }
+    async createWithDeadline(record, options, launchDeadlineAt, launchTimeoutMs) {
+        const timeoutMs = Math.max(1, launchDeadlineAt - Date.now());
+        const state = record[WORKSPACE_STATE];
+        let timeout = (this.options.setTimeout ?? setTimeout)(() => {
+            timeout = null;
+            if (!state.abortController.signal.aborted) {
+                state.abortController.abort(new WorkspaceLaunchTimeoutError(record.id, launchTimeoutMs));
+            }
+        }, timeoutMs);
+        try {
+            return await this.createResolvedWorkspace(record, options);
+        }
+        finally {
+            if (timeout)
+                (this.options.clearTimeout ?? clearTimeout)(timeout);
+        }
+    }
+    async withLaunchDeadline(operation, workspaceId, deadlineAt, launchTimeoutMs) {
+        const timeoutMs = Math.max(1, deadlineAt - Date.now());
+        let timeout = null;
+        const deadline = new Promise((_resolve, reject) => {
+            timeout = (this.options.setTimeout ?? setTimeout)(() => {
+                timeout = null;
+                reject(new WorkspaceLaunchTimeoutError(workspaceId, launchTimeoutMs));
+            }, timeoutMs);
+        });
+        try {
+            return await Promise.race([operation, deadline]);
+        }
+        finally {
+            if (timeout)
+                (this.options.clearTimeout ?? clearTimeout)(timeout);
         }
+    }
+    async createResolvedWorkspace(record, options) {
+        const state = record[WORKSPACE_STATE];
+        const { id, path: workspacePath, binaryId: resolvedBinaryPath, proxyPath } = record;
         try {
             this.throwIfCancelled(record);
             const serverConfig = this.options.settings.getOwner("config", "server");
@@ -262,291 +304,231 @@ export class WorkspaceManager {
                 [OPENCODE_SERVER_PASSWORD_ENV]: opencodePassword,
             };
             const logLevel = serverConfig?.logLevel;
-            const { pid, port, exitPromise, cancellationPromise, getLastOutput } = await this.runtime.launch({
+            const { pid, port, exitPromise, getLastOutput } = await this.runtime.launch({
                 workspaceId: id,
                 folder: workspacePath,
                 binaryPath: resolvedBinaryPath,
                 environment,
                 logLevel,
+                signal: state.abortController.signal,
                 onExit: (info) => this.handleProcessExit(info.workspaceId, info),
             });
-            descriptor.pid = pid;
-            descriptor.port = port;
+            record.pid = pid;
+            record.port = port;
             this.throwIfCancelled(record);
-            record.published = true;
-            this.options.eventBus.publish({ type: "workspace.created", workspace: descriptor });
+            state.published = true;
+            this.options.eventBus.publish({ type: "workspace.created", workspace: record });
             this.throwIfCancelled(record);
-            const readinessAbort = new AbortController();
-            const runtimeVersion = await Promise.race([
-                this.waitForWorkspaceReadiness({ workspaceId: id, port, exitPromise, getLastOutput, signal: readinessAbort.signal }),
-                cancellationPromise.then((error) => {
-                    readinessAbort.abort(error);
-                    throw error;
-                }),
-            ]);
+            const runtimeVersion = await this.waitForWorkspaceReadiness({
+                workspaceId: id,
+                port,
+                exitPromise,
+                getLastOutput,
+                signal: state.abortController.signal,
+            });
             this.throwIfCancelled(record);
             if (runtimeVersion) {
-                descriptor.binaryVersion = runtimeVersion;
+                record.binaryVersion = runtimeVersion;
             }
-            descriptor.status = "ready";
-            descriptor.updatedAt = new Date().toISOString();
-            this.options.eventBus.publish({ type: "workspace.started", workspace: descriptor });
+            record.status = "ready";
+            record.updatedAt = new Date().toISOString();
+            this.options.eventBus.publish({ type: "workspace.started", workspace: record });
             this.options.logger.info({ workspaceId: id, port }, "Workspace ready");
-            return { workspace: descriptor, created: true };
+            return { workspace: record, created: true };
         }
         catch (error) {
-            if (record.lifecycle.cancelled) {
-                await this.stopRuntime(id);
-                throw error instanceof WorkspaceLaunchCancelledError ? error : new WorkspaceLaunchCancelledError(id);
-            }
-            if (!record.published) {
-                try {
-                    await this.stopRuntime(id);
-                }
-                catch (cleanupError) {
-                    this.options.logger.error({ workspaceId: id, err: cleanupError }, "Unpublished workspace cleanup remains pending");
-                    throw cleanupError;
-                }
-                if (this.workspaces.get(id) === record) {
-                    this.workspaces.delete(id);
-                    this.workspaceIdentities.delete(id);
-                }
-                this.opencodeAuth.delete(id);
-                this.options.logger.error({ workspaceId: id, err: error }, "Workspace failed before identity publication");
-                throw error;
-            }
+            const launchFailure = state.abortController.signal.aborted ? state.abortController.signal.reason : error;
             let stopFailure;
-            await this.stopRuntime(id).catch((stopError) => {
+            await this.runtime.stop(id).catch((stopError) => {
                 stopFailure = stopError;
-                this.options.logger.warn({ workspaceId: id, err: stopError }, "Failed to stop workspace after startup error");
             });
             if (!stopFailure) {
-                this.publishStopped(record);
-                if (this.workspaces.get(id) === record) {
-                    this.workspaces.delete(id);
-                    this.workspaceIdentities.delete(id);
-                }
-                this.opencodeAuth.delete(id);
-                throw error;
+                this.removeRecord(id, record, state.published);
+                throw launchFailure;
+            }
+            if (!state.published) {
+                throw stopFailure;
             }
-            descriptor.status = "error";
-            descriptor.error = stopFailure instanceof Error
+            record.status = "error";
+            record.error = stopFailure instanceof Error
                 ? `Workspace startup failed and its process could not be stopped: ${stopFailure.message}`
-                : error instanceof Error ? error.message : String(error);
-            descriptor.updatedAt = new Date().toISOString();
-            if (this.workspaces.get(id) === record && record.published) {
-                this.options.eventBus.publish({ type: "workspace.error", workspace: descriptor });
+                : launchFailure instanceof Error ? launchFailure.message : String(launchFailure);
+            record.updatedAt = new Date().toISOString();
+            if (this.workspaces.get(id) === record && state.published) {
+                this.options.eventBus.publish({ type: "workspace.error", workspace: record });
             }
-            this.options.logger.error({ workspaceId: id, err: error }, "Workspace failed to start");
-            throw error;
-        }
-        finally {
-            record.lifecycle.settled = true;
-            record.lifecycle.complete();
+            this.options.logger.error({ workspaceId: id, err: launchFailure }, "Workspace failed to start");
+            throw launchFailure;
         }
     }
     delete(id) {
         const record = this.workspaces.get(id);
         if (!record)
             return Promise.resolve(undefined);
-        record.lifecycle.cancelled = true;
-        const identityKey = this.workspaceIdentities.get(id);
-        if (identityKey && this.pendingWorkspaceOwners.get(identityKey) === id) {
-            this.pendingWorkspaceCreations.delete(identityKey);
-            this.pendingWorkspaceOwners.delete(identityKey);
+        const state = record[WORKSPACE_STATE];
+        if (!state.abortController.signal.aborted) {
+            state.abortController.abort(new WorkspaceLaunchCancelledError(id));
+        }
+        const pending = this.pendingWorkspaceCreations.get(record.identityKey);
+        if (pending === record) {
+            this.pendingWorkspaceCreations.delete(record.identityKey);
         }
-        if (!record.lifecycle.deletePromise) {
+        if (!state.deletePromise) {
             let deletePromise;
             deletePromise = this.cleanupDeletedWorkspace(id, record).catch((error) => {
-                if (record.lifecycle.deletePromise === deletePromise) {
-                    record.lifecycle.deletePromise = undefined;
-                }
+                if (state.deletePromise === deletePromise)
+                    state.deletePromise = undefined;
                 throw error;
             });
-            record.lifecycle.deletePromise = deletePromise;
+            state.deletePromise = deletePromise;
         }
-        return record.lifecycle.deletePromise;
+        return state.deletePromise;
     }
     releaseCreationRequest(id, requestId) {
         const record = this.workspaces.get(id);
-        if (!record?.published)
+        if (!record?.[WORKSPACE_STATE].published)
             return false;
-        if (record.releasedCreationRequestIds.has(requestId))
+        const ownership = record.ownership;
+        const state = ownership.get(requestId);
+        if (state === "released")
             return true;
-        if (!record.creationOwnership.requestIds.has(requestId))
+        if (state === "cancelled")
+            return false;
+        if (state !== "active")
             return false;
-        this.retainCreationOwnership(record);
+        ownership.set(requestId, "released");
+        this.syncOwnership(record);
         return true;
     }
     async cancelCreationRequest(requestId) {
+        let matched = false;
         for (const [workspaceId, record] of this.workspaces) {
-            if (record.releasedCreationRequestIds.has(requestId))
-                return;
-            if (!record.creationOwnership.requestIds.delete(requestId))
+            const ownership = record.ownership;
+            const state = ownership.get(requestId);
+            if (state === "released") {
+                matched = true;
                 continue;
-            record.creationOwnership.cancelledRequestIds.add(requestId);
-            record.releasedCreationRequestIds.add(requestId);
-            this.syncCreationOwnership(record);
-            if (record.creationOwnership.requestIds.size > 0 || record.creationOwnership.sharedByNonRestoreCaller) {
+            }
+            if (state === "cancelled") {
+                matched = true;
+                if (this.hasActiveRequest(ownership) || this.isRetained(ownership))
+                    continue;
+                await this.delete(workspaceId);
                 return;
             }
+            if (state !== "active")
+                continue;
+            matched = true;
+            ownership.set(requestId, "cancelled");
+            this.syncOwnership(record);
+            if (this.hasActiveRequest(ownership) || this.isRetained(ownership))
+                return;
             await this.delete(workspaceId);
             return;
         }
-        if (this.cancelledCreationRequests.size >= 1024) {
-            const oldestRequestId = this.cancelledCreationRequests.values().next().value;
-            if (oldestRequestId)
-                this.cancelledCreationRequests.delete(oldestRequestId);
-        }
-        this.cancelledCreationRequests.add(requestId);
+        if (!matched)
+            this.cancelledCreationRequests.add(requestId);
     }
     createOwnership(requestId) {
-        return {
-            requestIds: new Set(requestId ? [requestId] : []),
-            cancelledRequestIds: new Set(),
-            sharedByNonRestoreCaller: !requestId,
-        };
+        return new Map([[requestId ?? ORDINARY_CREATION_OWNER, "active"]]);
     }
-    resultForCreationOwner(result, requestId, ownership) {
-        if (requestId && ownership.cancelledRequestIds.has(requestId)) {
+    finishCreation(result, requestId, ownership) {
+        if (requestId && ownership.get(requestId) === "cancelled") {
             throw new Error(`Workspace creation request ${requestId} was cancelled`);
         }
+        const retained = this.isRetained(ownership);
         return {
-            workspace: requestId && !ownership.sharedByNonRestoreCaller
-                ? { ...result.workspace, requestId }
-                : result.workspace,
-            created: result.created,
+            workspace: requestId ? { ...result.workspace, requestId } : result.workspace,
+            created: result.created && !(requestId && retained),
         };
     }
-    syncCreationOwnership(record) {
+    syncOwnership(record) {
         if (!record)
             return;
-        record.descriptor.requestId = record.creationOwnership.sharedByNonRestoreCaller
+        const ownership = record.ownership;
+        record.requestId = this.isRetained(ownership)
             ? undefined
-            : record.creationOwnership.requestIds.values().next().value;
+            : Array.from(ownership).find(([, state]) => state === "active")?.[0];
     }
-    retainCreationOwnership(record) {
-        if (!record)
-            return;
-        for (const requestId of record.creationOwnership.requestIds) {
-            record.releasedCreationRequestIds.add(requestId);
-        }
-        record.creationOwnership.requestIds.clear();
-        record.creationOwnership.sharedByNonRestoreCaller = true;
-        this.syncCreationOwnership(record);
+    isRetained(ownership) {
+        return ownership.has(ORDINARY_CREATION_OWNER) || Array.from(ownership.values()).includes("released");
+    }
+    hasActiveRequest(ownership) {
+        return Array.from(ownership).some(([requestId, state]) => Boolean(requestId) && state === "active");
     }
     async shutdown() {
         this.shuttingDown = true;
         this.options.logger.info("Shutting down all workspaces");
         const stopTasks = Array.from(this.workspaces.keys(), (id) => this.delete(id));
-        let stopFailures = [];
-        if (stopTasks.length > 0) {
-            const results = await this.withShutdownTimeout(Promise.allSettled(stopTasks));
-            stopFailures = results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
-        }
+        const results = stopTasks.length
+            ? await this.withTimeout(Promise.allSettled(stopTasks), this.options.shutdownTimeoutMs ?? 10000, "shutdown")
+            : [];
+        const stopFailures = results.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
         if (this.workspaces.size === 0) {
-            this.workspaceIdentities.clear();
             this.pendingWorkspaceCreations.clear();
-            this.pendingWorkspaceOwners.clear();
             this.cancelledCreationRequests.clear();
-            this.options.logger.info("All workspaces cleared");
         }
-        else {
-            this.options.logger.warn({ workspaceIds: Array.from(this.workspaces.keys()) }, "Some workspace records remain after failed shutdown cleanup");
-            if (stopFailures.length === 0) {
-                stopFailures.push(new Error(`Workspace cleanup remains incomplete for: ${Array.from(this.workspaces.keys()).join(", ")}`));
-            }
-        }
-        if (stopFailures.length > 0) {
+        else if (!stopFailures.length)
+            stopFailures.push(new Error(`Workspace cleanup remains incomplete for: ${Array.from(this.workspaces.keys()).join(", ")}`));
+        if (stopFailures.length)
             throw new WorkspaceShutdownError(stopFailures);
-        }
     }
-    async withShutdownTimeout(operation) {
+    async withTimeout(operation, timeoutMs, label) {
         let timeout = null;
         const deadline = new Promise((_resolve, reject) => {
-            timeout = this.scheduleTimeout(() => {
+            timeout = (this.options.setTimeout ?? setTimeout)(() => {
                 timeout = null;
-                reject(new WorkspaceShutdownTimeoutError(this.shutdownTimeoutMs));
-            }, this.shutdownTimeoutMs);
+                reject(new WorkspaceCleanupTimeoutError(label, timeoutMs));
+            }, timeoutMs);
         });
         try {
             return await Promise.race([operation, deadline]);
         }
         finally {
-            if (timeout) {
-                this.cancelTimeout(timeout);
-            }
+            if (timeout)
+                (this.options.clearTimeout ?? clearTimeout)(timeout);
         }
     }
     requireWorkspace(id) {
         const record = this.workspaces.get(id);
-        if (!record?.published) {
+        if (!record?.[WORKSPACE_STATE].published)
             throw new Error("Workspace not found");
-        }
-        return record.descriptor;
+        return record;
     }
     throwIfCancelled(record) {
-        if (record.lifecycle.cancelled) {
-            throw new WorkspaceLaunchCancelledError(record.descriptor.id);
-        }
-    }
-    async stopRuntime(workspaceId) {
-        try {
-            await this.runtime.stop(workspaceId);
-        }
-        catch (error) {
-            this.options.logger.warn({ workspaceId, err: error }, "Failed to stop workspace process cleanly");
-            throw error;
-        }
+        record[WORKSPACE_STATE].abortController.signal.throwIfAborted();
     }
     async cleanupDeletedWorkspace(id, record) {
-        this.options.logger.info({ workspaceId: id }, "Stopping workspace");
         // Stop once immediately, then again after launch settlement to cover a child
         // that became available while cancellation was propagating.
-        await this.stopRuntime(id);
-        if (!record.lifecycle.settled) {
-            await this.withLaunchSettlementTimeout(id, record.lifecycle.completion);
-        }
-        try {
-            await this.runtime.stop(id);
-        }
-        catch (error) {
-            this.options.logger.warn({ workspaceId: id, err: error }, "Failed final workspace process cleanup");
-            throw error;
-        }
-        if (this.workspaces.get(id) === record) {
-            this.workspaces.delete(id);
-            this.workspaceIdentities.delete(id);
-            this.opencodeAuth.delete(id);
-            clearWorkspaceSearchCache(record.descriptor.path);
-            this.publishStopped(record);
-        }
-        return record.descriptor;
-    }
-    async withLaunchSettlementTimeout(workspaceId, completion) {
-        let timeout = null;
-        const deadline = new Promise((_resolve, reject) => {
-            timeout = this.scheduleTimeout(() => {
-                timeout = null;
-                reject(new WorkspaceLaunchSettlementTimeoutError(workspaceId, this.launchSettlementTimeoutMs));
-            }, this.launchSettlementTimeoutMs);
+        const immediateStop = this.runtime.stop(id).catch((error) => {
+            this.options.logger.warn({ workspaceId: id, err: error }, "Initial workspace process cleanup failed; retrying after launch settles");
         });
-        try {
-            await Promise.race([completion, deadline]);
-        }
-        finally {
-            if (timeout) {
-                this.cancelTimeout(timeout);
-            }
-        }
-    }
-    publishStopped(record) {
-        if (record.lifecycle.stoppedEventPublished)
+        await this.withTimeout(record[WORKSPACE_STATE].settlement, this.options.launchSettlementTimeoutMs ?? 5000, `${id} launch cancellation`);
+        await immediateStop;
+        await this.runtime.stop(id);
+        this.removeRecord(id, record, true);
+        return record;
+    }
+    removeRecord(id, record, publishStopped) {
+        if (this.workspaces.get(id) !== record)
             return;
-        record.lifecycle.stoppedEventPublished = true;
-        this.options.eventBus.publish({ type: "workspace.stopped", workspaceId: record.descriptor.id });
+        this.workspaces.delete(id);
+        this.opencodeAuth.delete(id);
+        clearWorkspaceSearchCache(record.path);
+        if (publishStopped)
+            this.publishStopped(record, "deleted");
+    }
+    publishStopped(record, reason = "stopped") {
+        const state = record[WORKSPACE_STATE];
+        if (!state.published || state.stoppedPublished)
+            return;
+        state.stoppedPublished = true;
+        record.status = "stopped";
+        record.error = undefined;
+        this.options.eventBus.publish({ type: "workspace.stopped", workspaceId: record.id, reason });
     }
-    resolveBinaryPath(identifier) {
+    resolveBinaryPath(identifier, timeoutMs = DEFAULT_LAUNCH_TIMEOUT_MS) {
         if (!identifier) {
             return identifier;
         }
@@ -556,7 +538,7 @@ export class WorkspaceManager {
         }
         const locator = process.platform === "win32" ? "where" : "which";
         try {
-            const result = spawnSync(locator, [identifier], { encoding: "utf8" });
+            const result = spawnSync(locator, [identifier], { encoding: "utf8", timeout: Math.max(1, timeoutMs) });
             if (result.status === 0 && result.stdout) {
                 const candidates = result.stdout
                     .split(/\r?\n/)
@@ -594,25 +576,19 @@ export class WorkspaceManager {
     async waitForWorkspaceReadiness(params) {
         await Promise.race([
             this.waitForPortAvailability(params.port, 5000, params.signal),
-            params.exitPromise.then((info) => {
-                throw this.buildStartupError(params.workspaceId, "exited before becoming ready", info, params.getLastOutput());
-            }),
+            this.exitDuringStartup(params, "exited before becoming ready"),
         ]);
         const version = await this.waitForInstanceHealth(params);
         await Promise.race([
-            this.delay(STARTUP_STABILITY_DELAY_MS, params.signal),
-            params.exitPromise.then((info) => {
-                throw this.buildStartupError(params.workspaceId, "exited shortly after start", info, params.getLastOutput());
-            }),
+            delay(STARTUP_STABILITY_DELAY_MS, undefined, { signal: params.signal }),
+            this.exitDuringStartup(params, "exited shortly after start"),
         ]);
         return version;
     }
     async waitForInstanceHealth(params) {
         const probeResult = await Promise.race([
             this.probeInstance(params.workspaceId, params.port, params.signal),
-            params.exitPromise.then((info) => {
-                throw this.buildStartupError(params.workspaceId, "exited during health checks", info, params.getLastOutput());
-            }),
+            this.exitDuringStartup(params, "exited during health checks"),
         ]);
         if (probeResult.ok) {
             return probeResult.version;
@@ -624,6 +600,11 @@ export class WorkspaceManager {
         const reason = probeResult.reason ?? "Health check failed";
         throw new Error(`Workspace ${params.workspaceId} failed health check: ${reason}.`);
     }
+    exitDuringStartup(params, phase) {
+        return params.exitPromise.then((info) => {
+            throw this.buildStartupError(params.workspaceId, phase, info, params.getLastOutput());
+        });
+    }
     async probeInstance(workspaceId, port, signal) {
         const url = `http://127.0.0.1:${port}/global/health`;
         try {
@@ -665,34 +646,28 @@ export class WorkspaceManager {
             const deadline = Date.now() + timeoutMs;
             let settled = false;
             let retryTimer = null;
-            let socket = null;
             const cleanup = () => {
                 settled = true;
                 if (retryTimer) {
                     clearTimeout(retryTimer);
                     retryTimer = null;
                 }
-                signal?.removeEventListener("abort", onAbort);
-            };
-            const onAbort = () => {
-                if (settled)
-                    return;
-                cleanup();
-                socket?.destroy();
-                reject(signal?.reason instanceof Error ? signal.reason : new Error("Workspace readiness was cancelled"));
             };
             const tryConnect = () => {
-                if (settled) {
+                if (settled)
                     return;
-                }
-                socket = connect({ port, host: "127.0.0.1" }, () => {
+                const socket = connect({ port, host: "127.0.0.1", signal }, () => {
                     cleanup();
-                    socket?.end();
+                    socket.end();
                     resolve();
                 });
                 socket.once("error", () => {
-                    socket?.destroy();
-                    if (settled) {
+                    socket.destroy();
+                    if (settled)
+                        return;
+                    if (signal?.aborted) {
+                        cleanup();
+                        reject(signal.reason);
                         return;
                     }
                     if (Date.now() >= deadline) {
@@ -707,35 +682,11 @@ export class WorkspaceManager {
                     }
                 });
             };
-            if (signal?.aborted) {
-                onAbort();
-                return;
-            }
-            signal?.addEventListener("abort", onAbort, { once: true });
+            if (signal?.aborted)
+                return reject(signal.reason);
             tryConnect();
         });
     }
-    delay(durationMs, signal) {
-        if (durationMs <= 0) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                signal?.removeEventListener("abort", onAbort);
-                resolve();
-            }, durationMs);
-            const onAbort = () => {
-                clearTimeout(timer);
-                signal?.removeEventListener("abort", onAbort);
-                reject(signal?.reason instanceof Error ? signal.reason : new Error("Workspace readiness was cancelled"));
-            };
-            if (signal?.aborted) {
-                onAbort();
-                return;
-            }
-            signal?.addEventListener("abort", onAbort, { once: true });
-        });
-    }
     describeExit(info) {
         if (info.signal) {
             return `signal ${info.signal}`;
@@ -749,15 +700,13 @@ export class WorkspaceManager {
         const record = this.workspaces.get(workspaceId);
         if (!record)
             return;
-        const workspace = record.descriptor;
+        const workspace = record;
         this.opencodeAuth.delete(workspaceId);
         this.options.logger.info({ workspaceId, ...info }, "Workspace process exited");
         workspace.pid = undefined;
         workspace.port = undefined;
         workspace.updatedAt = new Date().toISOString();
-        if (record.lifecycle.cancelled || info.requested || info.code === 0) {
-            workspace.status = "stopped";
-            workspace.error = undefined;
+        if (record[WORKSPACE_STATE].abortController.signal.aborted || info.requested || info.code === 0) {
             this.publishStopped(record);
         }
         else {