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

package/dist/workspaces/manager.test.js

@@ -2,8 +2,8 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import pino from "pino";
 import { EventBus } from "../events/bus";
-import { WorkspaceRuntimeIdentityCaptureError, WorkspaceRuntimeLaunchCancelledError, WorkspaceWindowsTreeCleanupIncompleteError, } from "./runtime";
-import { WorkspaceLaunchCancelledError, WorkspaceLaunchSettlementTimeoutError, WorkspaceManager, WorkspaceShutdownError, WorkspaceShutdownTimeoutError, } from "./manager";
+import { WorkspaceWindowsTreeCleanupIncompleteError, } from "./runtime";
+import { WorkspaceCleanupTimeoutError, WorkspaceLaunchCancelledError, WorkspaceLaunchTimeoutError, WorkspaceManager, WorkspaceShutdownError, } from "./manager";
 function deferred() {
     let resolve;
     let reject;
@@ -17,302 +17,274 @@ class ControlledRuntime {
     constructor() {
         this.launchResult = deferred();
         this.launchCalled = deferred();
-        this.cancellation = deferred();
         this.active = new Set();
-        this.stopCalls = [];
-        this.launchCalls = 0;
+        this.stopCalls = 0;
         this.failStops = 0;
         this.launch = (options) => {
-            this.launchCalls += 1;
             this.active.add(options.workspaceId);
+            this.onExit = options.onExit;
             this.launchCalled.resolve(options.workspaceId);
+            options.signal?.addEventListener("abort", () => this.launchResult.reject(options.signal?.reason), { once: true });
             return this.launchResult.promise;
         };
         this.stop = async (workspaceId) => {
-            this.stopCalls.push(workspaceId);
-            this.cancellation.resolve(new WorkspaceRuntimeLaunchCancelledError(workspaceId));
-            if (this.failStops > 0) {
-                this.failStops -= 1;
+            this.stopCalls += 1;
+            if (this.failStops-- > 0)
                 throw new Error("controlled stop failure");
-            }
             this.active.delete(workspaceId);
         };
     }
-    resolveLaunch(workspaceId) {
+    resolveLaunch() {
         this.launchResult.resolve({
             pid: 1234,
             port: 4321,
             exitPromise: new Promise(() => undefined),
-            cancellationPromise: this.cancellation.promise,
             getLastOutput: () => "",
         });
     }
 }
-function createHarness(managerOptions = {}) {
+function createHarness(options = {}) {
     const eventBus = new EventBus();
     const runtime = new ControlledRuntime();
     const readiness = deferred();
     const started = [];
-    let createdId = "";
-    eventBus.on("workspace.created", (event) => {
-        createdId = event.workspace.id;
-    });
+    const stopped = [];
     eventBus.on("workspace.started", (event) => started.push(event.workspace.id));
+    eventBus.on("workspace.stopped", (event) => stopped.push(event.workspaceId));
     const manager = new WorkspaceManager({
         rootDir: process.cwd(),
         settings: { getOwner: () => ({}) },
-        binaryResolver: {
-            resolve: () => ({ path: "test-opencode", label: "test-opencode" }),
-        },
+        binaryResolver: { resolve: () => ({ path: "test-opencode", label: "test-opencode" }) },
         eventBus,
         logger: pino({ level: "silent" }),
         getServerBaseUrl: () => "http://127.0.0.1:4000",
         runtime,
-        ...managerOptions,
+        ...options,
     });
-    manager.waitForWorkspaceReadiness = () => readiness.promise;
-    return { manager, runtime, readiness, started, eventBus, getCreatedId: () => createdId };
+    manager.waitForWorkspaceReadiness = ({ signal }) => Promise.race([
+        readiness.promise,
+        new Promise((_resolve, reject) => {
+            const cancel = () => reject(signal?.reason);
+            signal?.addEventListener("abort", cancel, { once: true });
+            if (signal?.aborted)
+                cancel();
+        }),
+    ]);
+    return { manager, runtime, readiness, started, stopped };
 }
-describe("workspace manager launch cancellation", () => {
-    it("keeps a launched workspace unpublished until runtime identity launch succeeds", async () => {
-        const harness = createHarness();
-        let deletion;
-        harness.eventBus.on("workspace.created", (event) => {
-            deletion = harness.manager.delete(event.workspace.id);
-        });
-        const creation = harness.manager.create(process.cwd());
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        assert.equal(harness.getCreatedId(), "");
-        assert.deepEqual(harness.manager.list(), []);
-        assert.equal(harness.manager.getInstancePort(workspaceId), undefined);
-        assert.equal(harness.manager.getInstanceAuthorizationHeader(workspaceId), undefined);
-        harness.runtime.resolveLaunch(workspaceId);
-        await assert.rejects(creation, WorkspaceLaunchCancelledError);
-        await deletion;
-        assert.equal(harness.runtime.launchCalls, 1);
-        assert.equal(harness.runtime.active.size, 0);
-        assert.deepEqual(harness.started, []);
-        assert.deepEqual(harness.manager.list(), []);
-    });
-    it("stops a late launch and shares cleanup across concurrent deletes", async () => {
-        const harness = createHarness();
-        const creation = harness.manager.create(process.cwd());
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        const firstDelete = harness.manager.delete(workspaceId);
-        const secondDelete = harness.manager.delete(workspaceId);
-        assert.strictEqual(firstDelete, secondDelete);
-        assert.equal(harness.manager.get(workspaceId), undefined);
-        harness.runtime.resolveLaunch(workspaceId);
-        await assert.rejects(creation, WorkspaceLaunchCancelledError);
-        await Promise.all([firstDelete, secondDelete]);
-        assert.equal(harness.runtime.active.has(workspaceId), false);
-        assert.deepEqual(harness.started, []);
-        assert.equal(harness.manager.get(workspaceId), undefined);
-        assert.deepEqual(harness.manager.list(), []);
-    });
-    it("does not publish or retain a workspace when mandatory identity launch fails", async () => {
-        const events = [];
-        const eventBus = new EventBus();
-        eventBus.on("workspace.created", () => events.push("created"));
-        eventBus.on("workspace.started", () => events.push("started"));
-        eventBus.on("workspace.error", () => events.push("error"));
-        const runtime = {
-            launch: ((options) => Promise.reject(new WorkspaceRuntimeIdentityCaptureError(options.workspaceId, "probe unavailable"))),
-            stop: (() => Promise.resolve()),
-        };
-        const manager = new WorkspaceManager({
-            rootDir: process.cwd(),
-            settings: { getOwner: () => ({}) },
-            binaryResolver: { resolve: () => ({ path: "test-opencode", label: "test-opencode" }) },
-            eventBus,
-            logger: pino({ level: "silent" }),
-            getServerBaseUrl: () => "http://127.0.0.1:4000",
-            runtime,
-        });
-        await assert.rejects(manager.create(process.cwd()), WorkspaceRuntimeIdentityCaptureError);
-        assert.deepEqual(events, []);
-        assert.deepEqual(manager.list(), []);
-    });
-    it("retains an unpublished cleanup record when identity-failure cleanup cannot be proven", async () => {
-        let workspaceId = "";
-        let stopAttempts = 0;
-        const runtime = {
-            launch: ((options) => {
-                workspaceId = options.workspaceId;
-                return Promise.reject(new WorkspaceRuntimeIdentityCaptureError(options.workspaceId, "probe unavailable"));
-            }),
-            stop: (async () => {
-                stopAttempts += 1;
-                if (stopAttempts === 1)
-                    throw new Error("cleanup proof unavailable");
-            }),
-        };
-        const manager = new WorkspaceManager({
-            rootDir: process.cwd(),
-            settings: { getOwner: () => ({}) },
-            binaryResolver: { resolve: () => ({ path: "test-opencode", label: "test-opencode" }) },
-            eventBus: new EventBus(),
-            logger: pino({ level: "silent" }),
-            getServerBaseUrl: () => "http://127.0.0.1:4000",
-            runtime,
+async function createReady(harness) {
+    const creation = harness.manager.create(process.cwd());
+    const workspaceId = await harness.runtime.launchCalled.promise;
+    harness.runtime.resolveLaunch();
+    harness.readiness.resolve(undefined);
+    await creation;
+    return workspaceId;
+}
+describe("workspace manager lifecycle", () => {
+    for (const boundary of ["launch", "readiness", "shutdown"]) {
+        it(`cancels and cleans a workspace during ${boundary}`, async () => {
+            const harness = createHarness();
+            const creation = harness.manager.create(process.cwd());
+            const workspaceId = await harness.runtime.launchCalled.promise;
+            let cleanup;
+            if (boundary === "readiness") {
+                harness.runtime.resolveLaunch();
+                await new Promise((resolve) => setImmediate(resolve));
+                cleanup = harness.manager.delete(workspaceId);
+            }
+            else {
+                cleanup = boundary === "shutdown" ? harness.manager.shutdown() : harness.manager.delete(workspaceId);
+                harness.runtime.resolveLaunch();
+            }
+            await assert.rejects(creation, WorkspaceLaunchCancelledError);
+            await cleanup;
+            assert.deepEqual([harness.runtime.active.size, harness.started, harness.manager.list(), harness.stopped], [0, [], [], boundary === "readiness" ? [workspaceId] : []]);
         });
-        await assert.rejects(manager.create(process.cwd()), /cleanup proof unavailable/);
-        assert.deepEqual(manager.list(), []);
-        assert.equal(manager.get(workspaceId), undefined);
-        await manager.delete(workspaceId);
-        assert.equal(stopAttempts, 3);
-    });
-    it("actively cancels pending readiness without publishing workspace.started", async () => {
+    }
+    it("shares failed cleanup and allows a later delete retry", async () => {
         const harness = createHarness();
-        const creation = harness.manager.create(process.cwd());
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        harness.runtime.resolveLaunch(workspaceId);
-        await new Promise((resolve) => setImmediate(resolve));
-        const deletion = harness.manager.delete(workspaceId);
-        await assert.rejects(creation, WorkspaceLaunchCancelledError);
-        await deletion;
+        const workspaceId = await createReady(harness);
+        harness.runtime.failStops = 2;
+        const first = harness.manager.delete(workspaceId);
+        const concurrent = harness.manager.delete(workspaceId);
+        assert.strictEqual(first, concurrent);
+        const failures = await Promise.allSettled([first, concurrent]);
+        assert.deepEqual(failures.map((result) => result.status), ["rejected", "rejected"]);
+        assert.equal(harness.runtime.active.has(workspaceId), true);
+        await harness.manager.delete(workspaceId);
         assert.equal(harness.runtime.active.has(workspaceId), false);
-        assert.deepEqual(harness.started, []);
         assert.equal(harness.manager.get(workspaceId), undefined);
     });
-    it("cancels and cleans a starting child during shutdown", async () => {
+    it("retries cancellation deletion for an already-cancelled request", async () => {
         const harness = createHarness();
-        const creation = harness.manager.create(process.cwd());
+        const creation = harness.manager.create(process.cwd(), undefined, { requestId: "retry-cancel" });
         const workspaceId = await harness.runtime.launchCalled.promise;
-        const shutdown = harness.manager.shutdown();
-        harness.runtime.resolveLaunch(workspaceId);
-        await assert.rejects(creation, WorkspaceLaunchCancelledError);
-        await shutdown;
-        assert.equal(harness.runtime.active.size, 0);
-        assert.deepEqual(harness.started, []);
-        assert.deepEqual(harness.manager.list(), []);
-    });
-    it("still starts and deletes an ordinary ready workspace", async () => {
-        const harness = createHarness();
-        const creation = harness.manager.create(process.cwd(), "ordinary");
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        harness.runtime.resolveLaunch(workspaceId);
-        harness.readiness.resolve("2.0.0");
-        const { workspace } = await creation;
-        assert.equal(workspace.id, harness.getCreatedId());
-        assert.equal(workspace.status, "ready");
-        assert.equal(workspace.binaryVersion, "2.0.0");
-        assert.deepEqual(harness.started, [workspaceId]);
+        harness.runtime.resolveLaunch();
+        harness.readiness.resolve(undefined);
+        await creation;
+        harness.runtime.failStops = 2;
+        await assert.rejects(harness.manager.cancelCreationRequest("retry-cancel"), /controlled stop failure/);
+        assert.equal(harness.manager.get(workspaceId)?.id, workspaceId);
         assert.equal(harness.runtime.active.has(workspaceId), true);
-        await harness.manager.delete(workspaceId);
-        assert.equal(harness.runtime.active.has(workspaceId), false);
+        await harness.manager.cancelCreationRequest("retry-cancel");
         assert.equal(harness.manager.get(workspaceId), undefined);
+        assert.equal(harness.runtime.active.has(workspaceId), false);
+        assert.deepEqual(harness.stopped, [workspaceId]);
+    });
+    it("gives release and cancellation one terminal winner", async () => {
+        const cancelled = createHarness();
+        const cancelledCreation = cancelled.manager.create(process.cwd(), undefined, { requestId: "cancel-wins" });
+        const cancelledId = await cancelled.runtime.launchCalled.promise;
+        cancelled.runtime.resolveLaunch();
+        cancelled.readiness.resolve(undefined);
+        await cancelledCreation;
+        const stopStarted = deferred();
+        const finishStop = deferred();
+        const originalStop = cancelled.runtime.stop;
+        cancelled.runtime.stop = async (workspaceId) => {
+            stopStarted.resolve();
+            await finishStop.promise;
+            await originalStop(workspaceId);
+        };
+        const cancellation = cancelled.manager.cancelCreationRequest("cancel-wins");
+        await stopStarted.promise;
+        assert.equal(cancelled.manager.releaseCreationRequest(cancelledId, "cancel-wins"), false);
+        assert.equal(cancelled.manager.get(cancelledId)?.id, cancelledId);
+        finishStop.resolve();
+        await cancellation;
+        assert.equal(cancelled.manager.get(cancelledId), undefined);
+        const released = createHarness();
+        const releasedCreation = released.manager.create(process.cwd(), undefined, { requestId: "release-wins" });
+        const releasedId = await released.runtime.launchCalled.promise;
+        released.runtime.resolveLaunch();
+        released.readiness.resolve(undefined);
+        await releasedCreation;
+        assert.equal(released.manager.releaseCreationRequest(releasedId, "release-wins"), true);
+        await released.manager.cancelCreationRequest("release-wins");
+        assert.equal(released.manager.releaseCreationRequest(releasedId, "release-wins"), true);
+        assert.equal(released.manager.get(releasedId)?.id, releasedId);
+        assert.equal(released.runtime.active.has(releasedId), true);
     });
-    it("publishes stopped and removes a workspace after readiness fails", async () => {
+    it("retains unresolved pre-creation cancellation until its delayed create", async () => {
         const harness = createHarness();
-        const stopped = [];
-        harness.eventBus.on("workspace.stopped", (event) => stopped.push(event.workspaceId));
-        const creation = harness.manager.create(process.cwd());
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        harness.runtime.resolveLaunch(workspaceId);
-        await new Promise((resolve) => setImmediate(resolve));
-        harness.readiness.reject(new Error("readiness failed"));
-        await assert.rejects(creation, /readiness failed/);
-        assert.deepEqual(stopped, [workspaceId]);
-        assert.equal(harness.manager.get(workspaceId), undefined);
-        assert.deepEqual(harness.manager.list(), []);
+        const requestIds = Array.from({ length: 1_025 }, (_, index) => `pending-cancel-${index}`);
+        await Promise.all(requestIds.map((requestId) => harness.manager.cancelCreationRequest(requestId)));
+        assert.equal(harness.manager.cancelledCreationRequests.size, requestIds.length);
+        await assert.rejects(harness.manager.create(process.cwd(), undefined, { requestId: requestIds[0] }), /was cancelled/);
+        assert.equal(harness.manager.cancelledCreationRequests.has(requestIds[0]), false);
+        assert.equal(harness.manager.cancelledCreationRequests.size, requestIds.length - 1);
     });
-    it("retains a cancelled record after failed cleanup and allows delete retry", async () => {
+    it("returns scoped correlation while an ordinary shared launch remains retained", async () => {
         const harness = createHarness();
-        const creation = harness.manager.create(process.cwd());
+        const ordinary = harness.manager.create(process.cwd());
         const workspaceId = await harness.runtime.launchCalled.promise;
-        harness.runtime.resolveLaunch(workspaceId);
+        const scoped = harness.manager.create(process.cwd(), undefined, { requestId: "restore-shared" });
+        harness.runtime.resolveLaunch();
         harness.readiness.resolve(undefined);
-        await creation;
-        harness.runtime.failStops = 1;
-        const firstDelete = harness.manager.delete(workspaceId);
-        const concurrentDelete = harness.manager.delete(workspaceId);
-        assert.strictEqual(firstDelete, concurrentDelete);
-        const failedDeletes = await Promise.allSettled([firstDelete, concurrentDelete]);
-        assert.equal(failedDeletes[0].status, "rejected");
-        assert.equal(failedDeletes[1].status, "rejected");
-        if (failedDeletes[0].status === "rejected" && failedDeletes[1].status === "rejected") {
-            assert.strictEqual(failedDeletes[0].reason, failedDeletes[1].reason);
-            assert.match(String(failedDeletes[0].reason), /controlled stop failure/);
-        }
-        assert.equal(harness.manager.get(workspaceId)?.status, "ready");
+        const [ordinaryResult, scopedResult] = await Promise.all([ordinary, scoped]);
+        assert.equal(ordinaryResult.created, true);
+        assert.equal(ordinaryResult.workspace.requestId, undefined);
+        assert.equal(scopedResult.created, false);
+        assert.equal(scopedResult.workspace.id, workspaceId);
+        assert.equal(scopedResult.workspace.requestId, "restore-shared");
+        assert.equal(harness.manager.releaseCreationRequest(workspaceId, "restore-shared"), true);
+        assert.equal(harness.manager.get(workspaceId)?.id, workspaceId);
         assert.equal(harness.runtime.active.has(workspaceId), true);
-        const retryDelete = harness.manager.delete(workspaceId);
-        assert.notStrictEqual(retryDelete, firstDelete);
-        await retryDelete;
-        assert.equal(harness.runtime.active.has(workspaceId), false);
-        assert.equal(harness.manager.get(workspaceId), undefined);
+        const reused = await harness.manager.create(process.cwd(), undefined, { requestId: "restore-reused" });
+        assert.equal(reused.workspace.requestId, "restore-reused");
+        await harness.manager.cancelCreationRequest("restore-reused");
+        assert.equal(harness.manager.get(workspaceId)?.id, workspaceId);
+        assert.equal(harness.runtime.active.has(workspaceId), true);
+        await assert.rejects(harness.manager.create(process.cwd(), undefined, { requestId: "restore-reused" }), /was cancelled/);
+        assert.equal(harness.manager.releaseCreationRequest(workspaceId, "restore-reused"), false);
     });
-    it("rejects shutdown at its deadline instead of waiting forever", async () => {
+    for (const boundary of ["runtime launch", "health readiness"]) {
+        it(`applies one shared end-to-end deadline during ${boundary} and cleans up`, async () => {
+            const deadlines = [];
+            const harness = createHarness({
+                launchTimeoutMs: 25,
+                setTimeout: ((callback) => {
+                    const timer = { active: true };
+                    deadlines.push(() => { if (timer.active)
+                        callback(); });
+                    return timer;
+                }),
+                clearTimeout: ((timer) => { timer.active = false; }),
+            });
+            const first = harness.manager.create(process.cwd(), undefined, { requestId: "deadline-one" });
+            const workspaceId = await harness.runtime.launchCalled.promise;
+            const shared = harness.manager.create(process.cwd(), undefined, { requestId: "deadline-two" });
+            while ([...harness.manager.pendingWorkspaceCreations.values()][0]?.ownership.size !== 2) {
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+            if (boundary === "health readiness") {
+                harness.runtime.resolveLaunch();
+                await new Promise((resolve) => setImmediate(resolve));
+            }
+            for (const fire of deadlines)
+                fire();
+            const outcomes = await Promise.allSettled([first, shared]);
+            assert.deepEqual(outcomes.map((outcome) => outcome.status), ["rejected", "rejected"]);
+            assert.ok(outcomes.every((outcome) => outcome.status === "rejected" && outcome.reason instanceof WorkspaceLaunchTimeoutError));
+            assert.strictEqual(outcomes[0].reason, outcomes[1].reason);
+            assert.equal(harness.runtime.active.has(workspaceId), false);
+            assert.equal(harness.runtime.stopCalls >= 1, true);
+            assert.deepEqual(harness.manager.list(), []);
+        });
+    }
+    it("bounds shutdown instead of waiting forever", async () => {
         let fireDeadline;
-        const timer = {};
+        let cleared = 0;
         const harness = createHarness({
             shutdownTimeoutMs: 25,
-            setTimeout: (callback) => {
+            setTimeout: ((callback) => {
                 fireDeadline = callback;
-                return timer;
-            },
-            clearTimeout: () => undefined,
+                return {};
+            }),
+            clearTimeout: () => { cleared += 1; },
         });
-        const creation = harness.manager.create(process.cwd());
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        harness.runtime.resolveLaunch(workspaceId);
-        harness.readiness.resolve(undefined);
-        await creation;
+        const workspaceId = await createReady(harness);
+        cleared = 0;
         harness.runtime.stop = () => new Promise(() => undefined);
         const shutdown = harness.manager.shutdown();
-        assert.ok(fireDeadline);
         fireDeadline();
-        await assert.rejects(shutdown, WorkspaceShutdownTimeoutError);
-        assert.equal(harness.manager.get(workspaceId)?.status, "ready");
-    });
-    it("rejects failed shutdown cleanup and allows a later delete retry", async () => {
-        const harness = createHarness();
-        const creation = harness.manager.create(process.cwd());
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        harness.runtime.resolveLaunch(workspaceId);
-        harness.readiness.resolve(undefined);
-        await creation;
-        harness.runtime.failStops = 1;
-        await assert.rejects(harness.manager.shutdown(), WorkspaceShutdownError);
+        await assert.rejects(shutdown, WorkspaceCleanupTimeoutError);
         assert.equal(harness.manager.get(workspaceId)?.status, "ready");
-        assert.equal(harness.runtime.active.has(workspaceId), true);
-        await harness.manager.delete(workspaceId);
-        assert.equal(harness.manager.get(workspaceId), undefined);
-        assert.equal(harness.runtime.active.has(workspaceId), false);
+        assert.equal(cleared, 1);
     });
-    it("reports incomplete Windows tree cleanup during shutdown", async () => {
-        const harness = createHarness();
-        const creation = harness.manager.create(process.cwd());
-        const workspaceId = await harness.runtime.launchCalled.promise;
-        harness.runtime.resolveLaunch(workspaceId);
-        harness.readiness.resolve(undefined);
-        await creation;
-        harness.runtime.stop = async () => {
-            throw new WorkspaceWindowsTreeCleanupIncompleteError(workspaceId, 4242, ["taskkill /T failed: unavailable"]);
-        };
-        await assert.rejects(harness.manager.shutdown(), (error) => {
-            assert.ok(error instanceof WorkspaceShutdownError);
-            assert.ok(error.errors[0] instanceof WorkspaceWindowsTreeCleanupIncompleteError);
-            return true;
-        });
-        assert.equal(harness.manager.get(workspaceId)?.status, "ready");
-        assert.equal(harness.runtime.active.has(workspaceId), true);
+    it("publishes stopped exactly once for normal exit, readiness failure, and manager cleanup", async () => {
+        const normal = createHarness();
+        const normalId = await createReady(normal);
+        normal.runtime.onExit?.({ workspaceId: normalId, code: 0, signal: null, requested: false });
+        await normal.manager.delete(normalId);
+        assert.deepEqual(normal.stopped, [normalId]);
+        const failed = createHarness();
+        const failedCreation = failed.manager.create(process.cwd());
+        const failedId = await failed.runtime.launchCalled.promise;
+        failed.runtime.resolveLaunch();
+        failed.readiness.reject(new Error("not ready"));
+        await assert.rejects(failedCreation, /not ready/);
+        assert.deepEqual(failed.stopped, [failedId]);
+        const cleaned = createHarness();
+        const cleanedId = await createReady(cleaned);
+        await cleaned.manager.shutdown();
+        assert.deepEqual(cleaned.stopped, [cleanedId]);
     });
-    it("bounds cleanup when a runtime does not settle its cancelled launch", async () => {
-        let fireDeadline;
-        const timer = {};
-        const harness = createHarness({
-            launchSettlementTimeoutMs: 25,
-            setTimeout: (callback) => {
-                fireDeadline = callback;
-                return timer;
-            },
-            clearTimeout: () => undefined,
+    for (const [name, failure] of [
+        ["cleanup failures", new Error("stop failed")],
+        ["incomplete Windows tree cleanup", new WorkspaceWindowsTreeCleanupIncompleteError("workspace", 4242, ["taskkill failed"])],
+    ]) {
+        it(`aggregates ${name} during shutdown`, async () => {
+            const harness = createHarness();
+            const workspaceId = await createReady(harness);
+            harness.runtime.stop = async () => { throw failure; };
+            await assert.rejects(harness.manager.shutdown(), (error) => {
+                assert.ok(error instanceof WorkspaceShutdownError);
+                assert.strictEqual(error.errors[0], failure);
+                return true;
+            });
+            assert.equal(harness.manager.get(workspaceId)?.status, "ready");
+            assert.equal(harness.runtime.active.has(workspaceId), true);
         });
-        const deletion = harness.manager.withLaunchSettlementTimeout("workspace-1", new Promise(() => undefined));
-        assert.ok(fireDeadline);
-        fireDeadline();
-        await assert.rejects(deletion, WorkspaceLaunchSettlementTimeoutError);
-    });
+    }
 });

package/dist/workspaces/process-identity.darwin.test.js

@@ -0,0 +1,88 @@
+import assert from "node:assert/strict";
+import { spawn, spawnSync } from "node:child_process";
+import { once } from "node:events";
+import { setTimeout as delay } from "node:timers/promises";
+import { it } from "node:test";
+import { LAUNCH_CLEANUP_TOKEN_ENV, probePosixProcesses, signalOwnedPosixProcessGroup, signalPosixProcesses, } from "./process-identity";
+const darwinOnly = { skip: process.platform !== "darwin", timeout: 10_000 };
+async function spawnDetachedGroup(cleanupToken) {
+    const leader = spawn(process.execPath, ["-e", `
+    const { spawn } = require("node:child_process")
+    spawn(process.execPath, ["-e", "setInterval(() => {}, 1000)"], { stdio: "ignore" })
+    process.stdout.write("ready\\n")
+    setInterval(() => {}, 1000)
+  `], {
+        detached: true,
+        stdio: ["ignore", "pipe", "ignore"],
+        env: { ...process.env, ...(cleanupToken ? { [LAUNCH_CLEANUP_TOKEN_ENV]: cleanupToken } : {}) },
+    });
+    assert.ok(leader.pid);
+    await once(leader.stdout, "data");
+    return leader;
+}
+async function assertGroupGone(groupId) {
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        const remaining = probePosixProcesses(spawnSync, 1_000, "darwin", { groupId });
+        if (remaining.ok && remaining.processes.size === 0)
+            return;
+        await delay(50);
+    }
+    assert.fail("owned Darwin process group remained alive after signaling");
+}
+it("uses real Darwin ps identities to stop an owned detached process group", darwinOnly, async () => {
+    const leader = await spawnDetachedGroup();
+    try {
+        const snapshot = probePosixProcesses(spawnSync, 1_000, "darwin", {
+            pids: [leader.pid],
+            groupId: leader.pid,
+        });
+        assert.equal(snapshot.ok, true);
+        assert.equal(snapshot.ok && snapshot.processes.get(leader.pid)?.groupId, leader.pid);
+        assert.equal(snapshot.ok && snapshot.processes.size >= 2, true);
+        const signaled = signalOwnedPosixProcessGroup(spawnSync, leader.pid, "SIGTERM", 1_000);
+        assert.equal(signaled.ok && signaled.matched, true);
+        assert.equal(signaled.ok && signaled.signalSent, true);
+        await assertGroupGone(leader.pid);
+    }
+    finally {
+        try {
+            process.kill(-leader.pid, "SIGKILL");
+        }
+        catch {
+            // The successful path has already removed the process group.
+        }
+    }
+});
+it("uses a retained real Darwin identity anchor after the group leader exits", darwinOnly, async () => {
+    const cleanupToken = "darwin-integration-cleanup-token";
+    const leader = await spawnDetachedGroup(cleanupToken);
+    try {
+        const snapshot = probePosixProcesses(spawnSync, 1_000, "darwin", { groupId: leader.pid });
+        assert.equal(snapshot.ok, true);
+        const leaderIdentity = snapshot.ok ? snapshot.processes.get(leader.pid) : undefined;
+        assert.ok(leaderIdentity);
+        assert.equal(snapshot.ok && snapshot.processes.size >= 2, true);
+        leader.kill("SIGTERM");
+        if (leader.exitCode === null)
+            await once(leader, "exit");
+        const signaled = signalPosixProcesses(spawnSync, {
+            leader: leaderIdentity,
+            groupId: leader.pid,
+            members: [],
+            signal: "SIGTERM",
+            allowLeaderlessGroup: true,
+            cleanupToken,
+        }, 1_000, "darwin");
+        assert.equal(signaled.ok && signaled.matched, true);
+        assert.equal(signaled.ok && signaled.signalSent, true);
+        await assertGroupGone(leader.pid);
+    }
+    finally {
+        try {
+            process.kill(-leader.pid, "SIGKILL");
+        }
+        catch {
+            // The successful path has already removed the process group.
+        }
+    }
+});