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

package/dist/usage/service.test.js

@@ -2,7 +2,6 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { getProviderUsage, resolveUsageProvider, selectModelWindows } from "./service";
 const providerIds = [
-    "claude",
     "codex",
     "github-copilot",
     "google",
@@ -24,12 +23,15 @@ test("registers every supported usage provider", () => {
     }
 });
 test("maps OpenCode provider aliases to their usage provider", () => {
-    assert.equal(resolveUsageProvider("anthropic")?.id, "claude");
     assert.equal(resolveUsageProvider("openai")?.id, "codex");
     assert.equal(resolveUsageProvider("copilot")?.id, "github-copilot");
     assert.equal(resolveUsageProvider("gemini")?.id, "google");
     assert.equal(resolveUsageProvider("opencode")?.id, "opencode-go");
 });
+test("does not use Claude subscription OAuth credentials", () => {
+    assert.equal(resolveUsageProvider("anthropic"), null);
+    assert.equal(resolveUsageProvider("claude"), null);
+});
 test("selects model-specific windows by normalized model id", () => {
     const result = {
         providerId: "google",
@@ -42,7 +44,7 @@ test("selects model-specific windows by normalized model id", () => {
             models: {
                 "gemini/gemini-2.5-flash": {
                     windows: {
-                        daily: { usedPercent: 25, remainingPercent: 75, windowSeconds: 86400, resetAt: null },
+                        daily: { usedPercent: 25, remainingPercent: 75, windowSeconds: 86_400, resetAt: null },
                     },
                 },
             },

package/dist/usage/shared.js

@@ -1,7 +1,7 @@
 import fs from "fs";
 import os from "os";
 import path from "path";
-const REQUEST_TIMEOUT_MS = 15000;
+const REQUEST_TIMEOUT_MS = 15_000;
 function authFileCandidates() {
     const home = os.homedir();
     const candidates = [
@@ -68,7 +68,7 @@ export function toNumber(value) {
 }
 export function toTimestamp(value) {
     if (typeof value === "number" && Number.isFinite(value))
-        return value < 1000000000000 ? value * 1000 : value;
+        return value < 1_000_000_000_000 ? value * 1000 : value;
     if (typeof value === "string" && value.trim()) {
         const parsed = Date.parse(value);
         return Number.isNaN(parsed) ? null : parsed;
@@ -88,8 +88,8 @@ export function toUsageWindow(input) {
 export function resolveWindowLabel(windowSeconds) {
     if (!windowSeconds)
         return "usage";
-    if (windowSeconds % 86400 === 0) {
-        const days = windowSeconds / 86400;
+    if (windowSeconds % 86_400 === 0) {
+        const days = windowSeconds / 86_400;
         return days === 7 ? "weekly" : `${days}d`;
     }
     if (windowSeconds % 3600 === 0)

package/dist/usage/shared.test.js

@@ -8,11 +8,11 @@ test("reads the explicit OpenCode auth file without exposing credentials through
     const directory = fs.mkdtempSync(path.join(os.tmpdir(), "codenomad-usage-"));
     const authFile = path.join(directory, "auth.json");
     const previous = process.env.OPENCODE_AUTH_FILE;
-    fs.writeFileSync(authFile, JSON.stringify({ anthropic: { type: "oauth", access: "secret-token" } }));
+    fs.writeFileSync(authFile, JSON.stringify({ openai: { type: "oauth", access: "secret-token" } }));
     process.env.OPENCODE_AUTH_FILE = authFile;
     try {
-        assert.equal(readOpenCodeAuth().anthropic.access, "secret-token");
-        assert.equal(getCredential(["anthropic"], ["access"]), "secret-token");
+        assert.equal(readOpenCodeAuth().openai.access, "secret-token");
+        assert.equal(getCredential(["openai"], ["access"]), "secret-token");
     }
     finally {
         if (previous === undefined)
@@ -29,5 +29,5 @@ test("normalizes percentages and timestamps", () => {
         windowSeconds: null,
         resetAt: null,
     });
-    assert.equal(toTimestamp(1700000000), 1700000000000);
+    assert.equal(toTimestamp(1_700_000_000), 1_700_000_000_000);
 });

package/dist/workspaces/__tests__/spawn.test.js

@@ -41,7 +41,7 @@ describe("buildWindowsSpawnSpec", () => {
     it("conservatively classifies bare commands as wrappers", () => {
         assert.equal(buildWindowsSpawnSpec("opencode", []).processKind, "windows-wrapper");
     });
-    it("resolves a bare cmd shim from a quoted PATH entry and wraps its absolute path", () => {
+    it("resolves a bare cmd shim from a quoted PATH entry and wraps its absolute path", { skip: process.platform !== "win32" }, () => {
         const root = mkdtempSync(path.join(tmpdir(), "codenomad-spawn-"));
         const cwd = path.join(root, "workspace");
         const bin = path.join(root, "bin with spaces");
@@ -63,7 +63,7 @@ describe("buildWindowsSpawnSpec", () => {
             rmSync(root, { recursive: true, force: true });
         }
     });
-    it("honors PATHEXT precedence when both native and shim files exist", () => {
+    it("honors PATHEXT precedence when both native and shim files exist", { skip: process.platform !== "win32" }, () => {
         const root = mkdtempSync(path.join(tmpdir(), "codenomad-spawn-"));
         writeFileSync(path.join(root, "opencode.cmd"), "@echo off\r\n");
         writeFileSync(path.join(root, "opencode.exe"), "");

package/dist/workspaces/__tests__/workspace-identity.test.js

@@ -8,14 +8,16 @@ import { EventBus } from "../../events/bus";
 import { WorkspaceManager } from "../manager";
 import { normalizeWorkspaceIdentityPath, resolveWorkspaceIdentity } from "../workspace-identity";
 const temporaryDirectories = [];
+const runtimeResult = (pid = 123) => ({
+    pid,
+    port: 4321,
+    exitPromise: new Promise(() => undefined),
+    getLastOutput: () => "",
+});
 function deferred() {
     let resolve;
-    let reject;
-    const promise = new Promise((resolvePromise, rejectPromise) => {
-        resolve = resolvePromise;
-        reject = rejectPromise;
-    });
-    return { promise, resolve, reject };
+    const promise = new Promise((resolvePromise) => { resolve = resolvePromise; });
+    return { promise, resolve };
 }
 afterEach(async () => {
     await Promise.all(temporaryDirectories.splice(0).map((directory) => rm(directory, { force: true, recursive: true })));
@@ -34,167 +36,99 @@ function createManager(rootDir) {
     const manager = new WorkspaceManager({
         rootDir,
         settings: { getOwner: () => ({ environmentVariables: {} }) },
-        binaryResolver: {
-            resolve: () => ({ path: process.execPath, label: "Node.js", version: process.version }),
-        },
+        binaryResolver: { resolve: () => ({ path: process.execPath, label: "Node.js", version: process.version }) },
         eventBus: new EventBus(logger),
         logger,
         getServerBaseUrl: () => "http://127.0.0.1:3000",
     });
-    const internal = manager;
-    internal.runtime.launch = async () => ({
-        pid: 123,
-        port: 4321,
-        exitPromise: new Promise(() => { }),
-        cancellationPromise: new Promise(() => { }),
-        getLastOutput: () => "",
-    });
-    internal.waitForWorkspaceReadiness = async () => undefined;
+    manager.runtime.launch = async () => runtimeResult();
+    manager.runtime.stop = async () => undefined;
+    manager.waitForWorkspaceReadiness = async () => undefined;
     return manager;
 }
+async function waitForOwners(manager, count) {
+    while ([...manager.pendingWorkspaceCreations.values()][0]?.ownership.size !== count) {
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+}
+async function createSharedLaunch() {
+    const { root, target, link } = await createLinkedWorkspace();
+    const manager = createManager(root);
+    const launchGate = deferred();
+    let launches = 0;
+    manager.runtime.launch = async () => {
+        launches += 1;
+        await launchGate.promise;
+        return runtimeResult();
+    };
+    const leader = manager.create(target, undefined, { requestId: "leader" });
+    const follower = manager.create(link, undefined, { requestId: "follower" });
+    await waitForOwners(manager, 2);
+    return { manager, launchGate, leader, follower, launches: () => launches };
+}
 describe("workspace identity", () => {
-    it("normalizes Windows drive and UNC paths without affecting POSIX case", () => {
+    it("normalizes Windows paths without affecting POSIX case", () => {
         assert.equal(normalizeWorkspaceIdentityPath("C:\\Projects\\CodeNomad\\", "win32"), "c:\\projects\\codenomad\\");
         assert.equal(normalizeWorkspaceIdentityPath(String.raw `\\Server\Share\Repo`, "win32"), String.raw `\\server\share\repo`);
         assert.equal(normalizeWorkspaceIdentityPath("/Projects/CodeNomad/", "linux"), "/Projects/CodeNomad/");
     });
-    it("resolves a symlink and its target to the same canonical launch path", async () => {
+    it("canonicalizes aliases and falls back to an absolute identity for missing paths", async () => {
         const { root, target, link } = await createLinkedWorkspace();
-        const targetResult = await resolveWorkspaceIdentity(target, root);
-        const linkResult = await resolveWorkspaceIdentity(link, root);
+        const [targetResult, linkResult, missing] = await Promise.all([
+            resolveWorkspaceIdentity(target, root),
+            resolveWorkspaceIdentity(link, root),
+            resolveWorkspaceIdentity("missing", root),
+        ]);
+        const expectedMissing = path.resolve(root, "missing");
         assert.equal(linkResult.identityKey, targetResult.identityKey);
         assert.equal(linkResult.workspacePath, targetResult.workspacePath);
-        assert.notEqual(linkResult.workspacePath, path.normalize(link));
-    });
-    it("falls back to a normalized absolute identity when realpath fails", async () => {
-        const root = await mkdtemp(path.join(os.tmpdir(), "codenomad-workspace-missing-"));
-        temporaryDirectories.push(root);
-        const result = await resolveWorkspaceIdentity("missing", root);
-        const expected = path.resolve(root, "missing");
-        assert.equal(result.workspacePath, expected);
-        assert.equal(result.identityKey, normalizeWorkspaceIdentityPath(expected));
+        assert.equal(missing.workspacePath, expectedMissing);
+        assert.equal(missing.identityKey, normalizeWorkspaceIdentityPath(expectedMissing));
     });
-    it("atomically reuses an active workspace reached through a symlink", async () => {
+    it("deduplicates active canonical aliases", async () => {
         const { root, target, link } = await createLinkedWorkspace();
         const manager = createManager(root);
-        const [targetResult, linkResult] = await Promise.all([manager.create(target), manager.create(link)]);
-        assert.equal(Number(targetResult.created) + Number(linkResult.created), 1);
-        assert.equal(targetResult.workspace.id, linkResult.workspace.id);
-        assert.equal(manager.list().length, 1);
-    });
-    it("shares an in-flight startup between canonical aliases", async () => {
-        const { root, target, link } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const launchGate = deferred();
-        let launches = 0;
-        manager.runtime.launch = async () => {
-            launches += 1;
-            await launchGate.promise;
-            return {
-                pid: 123,
-                port: 4321,
-                exitPromise: new Promise(() => { }),
-                cancellationPromise: new Promise(() => { }),
-                getLastOutput: () => "",
-            };
-        };
-        const firstPromise = manager.create(target, undefined, { requestId: "restore-request" });
-        const secondPromise = manager.create(link);
-        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-        launchGate.resolve();
-        const [first, second] = await Promise.all([firstPromise, secondPromise]);
-        assert.equal(launches, 1);
-        assert.equal(first.created, false);
-        assert.equal(first.workspace.requestId, undefined);
-        assert.equal(first.workspace.id, second.workspace.id);
-        assert.equal(first.workspace.status, "ready");
-        assert.equal(second.workspace.status, "ready");
-    });
-    it("keeps both cleanup owners when two restore requests share a canonical launch", async () => {
-        const { root, target, link } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const [first, second] = await Promise.all([
-            manager.create(target, undefined, { requestId: "restore-first" }),
-            manager.create(link, undefined, { requestId: "restore-second" }),
-        ]);
+        const [first, second] = await Promise.all([manager.create(target), manager.create(link)]);
         assert.equal(Number(first.created) + Number(second.created), 1);
         assert.equal(first.workspace.id, second.workspace.id);
-        assert.equal(first.workspace.requestId, "restore-first");
-        assert.equal(second.workspace.requestId, "restore-second");
-        assert.equal(manager.releaseCreationRequest(first.workspace.id, "restore-first"), true);
-        assert.equal(manager.releaseCreationRequest(first.workspace.id, "restore-second"), true);
-    });
-    it("detaches a cancelled restore follower without stopping the leader launch", async () => {
-        const { root, target, link } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const launchGate = deferred();
-        let launches = 0;
-        manager.runtime.launch = async () => {
-            launches += 1;
-            await launchGate.promise;
-            return {
-                pid: 123,
-                port: 4321,
-                exitPromise: new Promise(() => { }),
-                cancellationPromise: new Promise(() => { }),
-                getLastOutput: () => "",
-            };
-        };
-        const leader = manager.create(target, undefined, { requestId: "restore-leader" });
-        const follower = manager.create(link, undefined, { requestId: "restore-follower" });
-        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-        await manager.cancelCreationRequest("restore-follower");
-        launchGate.resolve();
-        const leaderResult = await leader;
-        await assert.rejects(follower, /creation request restore-follower was cancelled/);
-        assert.equal(launches, 1);
-        assert.equal(leaderResult.workspace.requestId, "restore-leader");
-        assert.equal(manager.list().length, 1);
-    });
-    it("detaches a cancelled restore leader without stopping a follower launch", async () => {
-        const { root, target, link } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const launchGate = deferred();
-        manager.runtime.launch = async () => {
-            await launchGate.promise;
-            return {
-                pid: 123,
-                port: 4321,
-                exitPromise: new Promise(() => { }),
-                cancellationPromise: new Promise(() => { }),
-                getLastOutput: () => "",
-            };
-        };
-        const leader = manager.create(target, undefined, { requestId: "restore-leader" });
-        const follower = manager.create(link, undefined, { requestId: "restore-follower" });
-        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-        await manager.cancelCreationRequest("restore-leader");
-        launchGate.resolve();
-        await assert.rejects(leader, /creation request restore-leader was cancelled/);
-        const followerResult = await follower;
-        assert.equal(followerResult.workspace.requestId, "restore-follower");
         assert.equal(manager.list().length, 1);
     });
-    it("retains a shared workspace after one restore owner releases and another cancels", async () => {
-        const { root, target, link } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const [first, second] = await Promise.all([
-            manager.create(target, undefined, { requestId: "restore-first" }),
-            manager.create(link, undefined, { requestId: "restore-second" }),
-        ]);
-        assert.equal(manager.releaseCreationRequest(first.workspace.id, "restore-first"), true);
-        await manager.cancelCreationRequest("restore-second");
-        assert.equal(manager.list().length, 1);
-        assert.equal(manager.get(second.workspace.id)?.requestId, undefined);
-        assert.equal(manager.releaseCreationRequest(second.workspace.id, "restore-second"), true);
-    });
-    it("releases a failed identity reservation so creation can be retried", async () => {
+    it("shares one in-flight launch between canonical aliases", async () => {
+        const shared = await createSharedLaunch();
+        shared.launchGate.resolve();
+        const [leader, follower] = await Promise.all([shared.leader, shared.follower]);
+        assert.equal(shared.launches(), 1);
+        assert.equal(leader.workspace.id, follower.workspace.id);
+        assert.equal(Number(leader.created) + Number(follower.created), 1);
+        assert.equal(leader.workspace.status, "ready");
+    });
+    for (const cancelledRole of ["leader", "follower"]) {
+        it(`detaches a cancelled ${cancelledRole} without stopping its shared owner`, async () => {
+            const shared = await createSharedLaunch();
+            await shared.manager.cancelCreationRequest(cancelledRole);
+            shared.launchGate.resolve();
+            const cancelled = shared[cancelledRole];
+            const survivor = shared[cancelledRole === "leader" ? "follower" : "leader"];
+            await assert.rejects(cancelled, new RegExp(`creation request ${cancelledRole} was cancelled`));
+            const result = await survivor;
+            assert.equal(shared.launches(), 1);
+            assert.equal(result.workspace.requestId, cancelledRole === "leader" ? "follower" : "leader");
+            assert.equal(shared.manager.list().length, 1);
+        });
+    }
+    for (const releasedRole of ["leader", "follower"]) {
+        it(`retains shared ownership when the ${releasedRole} releases and the other owner cancels`, async () => {
+            const shared = await createSharedLaunch();
+            shared.launchGate.resolve();
+            const [leader, follower] = await Promise.all([shared.leader, shared.follower]);
+            assert.equal(leader.workspace.id, follower.workspace.id);
+            assert.equal(shared.manager.releaseCreationRequest(leader.workspace.id, releasedRole), true);
+            await shared.manager.cancelCreationRequest(releasedRole === "leader" ? "follower" : "leader");
+            assert.equal(shared.manager.list().length, 1);
+            assert.equal(shared.manager.get(leader.workspace.id)?.requestId, undefined);
+        });
+    }
+    it("releases a failed canonical reservation for retry", async () => {
         const { root, target, link } = await createLinkedWorkspace();
         const manager = createManager(root);
         const launchGate = deferred();
@@ -204,152 +138,26 @@ describe("workspace identity", () => {
             await launchGate.promise;
             throw new Error("launch failed");
         };
-        const firstFailure = manager.create(target);
-        const secondFailure = manager.create(link);
-        while (![...manager.pendingWorkspaceCreations.values()][0]?.followerCount) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
+        const failures = [
+            manager.create(target, undefined, { requestId: "first" }),
+            manager.create(link, undefined, { requestId: "second" }),
+        ];
+        await waitForOwners(manager, 2);
         launchGate.resolve();
-        const failed = await Promise.allSettled([firstFailure, secondFailure]);
-        assert.deepEqual(failed.map((result) => result.status), ["rejected", "rejected"]);
+        assert.deepEqual((await Promise.allSettled(failures)).map((result) => result.status), ["rejected", "rejected"]);
         assert.equal(launches, 1);
-        manager.runtime.launch = async () => ({
-            pid: 456,
-            port: 5432,
-            exitPromise: new Promise(() => { }),
-            cancellationPromise: new Promise(() => { }),
-            getLastOutput: () => "",
-        });
-        const retry = await manager.create(target);
-        assert.equal(retry.created, true);
-        assert.equal(retry.workspace.status, "ready");
-    });
-    it("allows an explicit second workspace for the same canonical path", async () => {
-        const { root, target, link } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const [first, second] = await Promise.all([
-            manager.create(target, undefined, { forceNew: true }),
-            manager.create(link, undefined, { forceNew: true }),
-        ]);
-        assert.equal(first.created, true);
-        assert.equal(second.created, true);
-        assert.notEqual(first.workspace.id, second.workspace.id);
-        assert.equal(manager.list().length, 2);
+        manager.runtime.launch = async () => runtimeResult(456);
+        assert.equal((await manager.create(target)).created, true);
     });
-    it("does not reuse restore-owned workspaces until hydration releases ownership", async () => {
+    it("allows forced canonical duplicates without replacing the reusable workspace", async () => {
         const { root, target, link } = await createLinkedWorkspace();
         const manager = createManager(root);
-        const restore = await manager.create(target, undefined, {
-            forceNew: true,
-            requestId: "restore-request",
-        });
-        const concurrent = await manager.create(link);
-        assert.equal(concurrent.created, true);
-        assert.notEqual(concurrent.workspace.id, restore.workspace.id);
-        assert.equal(manager.releaseCreationRequest(restore.workspace.id, "wrong-request"), false);
-        assert.equal(manager.releaseCreationRequest(restore.workspace.id, "restore-request"), true);
-        assert.equal(manager.releaseCreationRequest(restore.workspace.id, "restore-request"), true);
-        await manager.delete(concurrent.workspace.id);
+        const normal = await manager.create(target);
+        const forced = await manager.create(link, undefined, { forceNew: true });
+        assert.notEqual(normal.workspace.id, forced.workspace.id);
+        await manager.delete(forced.workspace.id);
         const reused = await manager.create(link);
         assert.equal(reused.created, false);
-        assert.equal(reused.workspace.id, restore.workspace.id);
-    });
-    it("keeps the canonical reservation when a forced duplicate is deleted", async () => {
-        const { root, target, link } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const normalLaunch = deferred();
-        const forcedLaunch = deferred();
-        let launches = 0;
-        const launchedWorkspaceIds = [];
-        manager.runtime.launch = (options) => {
-            launches += 1;
-            launchedWorkspaceIds.push(options.workspaceId);
-            return launches === 1 ? normalLaunch.promise : forcedLaunch.promise;
-        };
-        const first = manager.create(target);
-        while (launchedWorkspaceIds.length < 1) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-        const forced = manager.create(link, undefined, { forceNew: true });
-        const forcedRejected = assert.rejects(forced, /launch was cancelled/);
-        while (launchedWorkspaceIds.length < 2) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-        const forcedDeletion = manager.delete(launchedWorkspaceIds[1]);
-        const reused = manager.create(link);
-        normalLaunch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
-        forcedLaunch.resolve({ pid: 456, port: 5432, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
-        await forcedDeletion;
-        const [firstResult, reusedResult] = await Promise.all([first, reused]);
-        await forcedRejected;
-        assert.equal(launches, 2);
-        assert.equal(firstResult.workspace.id, reusedResult.workspace.id);
-        assert.equal(reusedResult.created, false);
-    });
-    it("cancels an in-flight startup when its workspace is deleted", async () => {
-        const { root, target } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const launch = deferred();
-        let workspaceId = "";
-        manager.runtime.launch = (options) => {
-            workspaceId = options.workspaceId;
-            return launch.promise;
-        };
-        const events = [];
-        manager.options.eventBus.onEvent((event) => events.push(event));
-        const creation = manager.create(target);
-        const creationRejected = assert.rejects(creation, /launch was cancelled/);
-        while (!workspaceId) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-        const deletion = manager.delete(workspaceId);
-        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
-        await Promise.all([creationRejected, deletion]);
-        assert.equal(manager.get(workspaceId), undefined);
-        assert.equal(events.filter((event) => event.type === "workspace.stopped" && event.workspaceId === workspaceId).length, 1);
-    });
-    it("cancels an in-flight restore startup by request id", async () => {
-        const { root, target } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const launch = deferred();
-        let workspaceId = "";
-        manager.runtime.launch = (options) => {
-            workspaceId = options.workspaceId;
-            return launch.promise;
-        };
-        const creation = manager.create(target, undefined, { requestId: "cancel-restore" });
-        const creationRejected = assert.rejects(creation, /launch was cancelled/);
-        while (!workspaceId)
-            await new Promise((resolve) => setImmediate(resolve));
-        const cancellation = manager.cancelCreationRequest("cancel-restore");
-        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
-        await Promise.all([creationRejected, cancellation]);
-        assert.equal(manager.get(workspaceId), undefined);
-    });
-    it("remembers cancellation that arrives before restore reservation", async () => {
-        const { root, target } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        await manager.cancelCreationRequest("early-cancel");
-        await assert.rejects(manager.create(target, undefined, { requestId: "early-cancel" }), /creation request early-cancel was cancelled/);
-        assert.equal(manager.list().length, 0);
-    });
-    it("waits for and cancels forced creations during shutdown", async () => {
-        const { root, target } = await createLinkedWorkspace();
-        const manager = createManager(root);
-        const launch = deferred();
-        let workspaceId = "";
-        manager.runtime.launch = (options) => {
-            workspaceId = options.workspaceId;
-            return launch.promise;
-        };
-        const creation = manager.create(target, undefined, { forceNew: true });
-        const creationRejected = assert.rejects(creation, /launch was cancelled/);
-        while (!workspaceId) {
-            await new Promise((resolve) => setImmediate(resolve));
-        }
-        const shutdown = manager.shutdown();
-        launch.resolve({ pid: 123, port: 4321, exitPromise: new Promise(() => { }), cancellationPromise: new Promise(() => { }), getLastOutput: () => "" });
-        await Promise.all([creationRejected, shutdown]);
-        assert.equal(manager.list().length, 0);
+        assert.equal(reused.workspace.id, normal.workspace.id);
     });
 });

package/dist/workspaces/binary-path.test.js

@@ -0,0 +1,10 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { binaryPathsEqual } from "./manager";
+test("matches regular Windows binary paths without case sensitivity", () => {
+    assert.equal(binaryPathsEqual(String.raw `C:\Tools\OpenCode.cmd`, String.raw `c:\tools\opencode.CMD`, "win32"), true);
+});
+test("matches WSL distro names without changing Linux path casing", () => {
+    assert.equal(binaryPathsEqual(String.raw `\\wsl.localhost\Ubuntu\home\dev\OpenCode`, String.raw `\\wsl$\ubuntu\home\dev\OpenCode`, "win32"), true);
+    assert.equal(binaryPathsEqual(String.raw `\\wsl.localhost\Ubuntu\home\dev\OpenCode`, String.raw `\\wsl$\ubuntu\home\dev\opencode`, "win32"), false);
+});

package/dist/workspaces/instance-client.js

@@ -1,6 +1,6 @@
 import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";
 const INSTANCE_HOST = "127.0.0.1";
-const LOOPBACK_TIMEOUT_MS = 10000;
+const LOOPBACK_TIMEOUT_MS = 10_000;
 /**
  * Creates an OpenCode SDK client for direct loopback communication with a
  * running workspace instance.
@@ -18,7 +18,7 @@ const LOOPBACK_TIMEOUT_MS = 10000;
  * call or cache per instance as needed. Returns `null` when the instance has
  * no open port yet.
  */
-export function createInstanceClient(workspaceManager, instanceId) {
+export function createInstanceClient(workspaceManager, instanceId, options = {}) {
     const port = workspaceManager.getInstancePort(instanceId);
     if (!port)
         return null;
@@ -28,12 +28,13 @@ export function createInstanceClient(workspaceManager, instanceId) {
         headers.authorization = authorization;
     }
     const workspace = workspaceManager.get(instanceId);
+    const timeoutMs = options.timeoutMs ?? LOOPBACK_TIMEOUT_MS;
     return createOpencodeClient({
         baseUrl: `http://${INSTANCE_HOST}:${port}/`,
         headers,
         fetch: (url, init) => fetch(url, {
             ...init,
-            signal: init?.signal ?? AbortSignal.timeout(LOOPBACK_TIMEOUT_MS),
+            signal: init?.signal ?? AbortSignal.timeout(timeoutMs),
         }),
         ...(workspace?.path ? { directory: workspace.path } : {}),
     });

package/dist/workspaces/launch-cleanup.test.js

@@ -1,33 +1,29 @@
 import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
 import { describe, it } from "node:test";
-import { LAUNCH_CLEANUP_TOKEN_ENV, probeLaunchCleanupToken, signalLaunchCleanupToken, } from "./launch-cleanup";
-function result(stdout = "", status = 0, stderr = "") {
-    return { pid: 1, output: [null, stdout, stderr], stdout, stderr, status, signal: null };
-}
+import { LAUNCH_CLEANUP_TOKEN_ENV, probeLaunchCleanupToken, signalLaunchCleanupToken } from "./process-identity";
+const result = (stdout) => ({ pid: 1, output: [null, stdout, ""], stdout, stderr: "", status: 0, signal: null });
 describe("launch cleanup token adapter", () => {
-    it("passes the exact token to a bounded Linux environ probe", () => {
-        const token = "a".repeat(64);
-        let invocation;
-        const probe = probeLaunchCleanupToken(((command, args, options) => {
-            invocation = { command, args, timeout: options.timeout };
-            return result("5000|1|4242|150|boot-a|150\n");
-        }), token, 25);
+    it("passes the exact token to the bounded Linux environ probe", () => {
+        const token = "a".repeat(64), calls = [];
+        const run = ((command, args, options) => { calls.push(command, args, options); return result("CODENOMAD_PROCESS|5000|1|4242|150|boot-a|150\n"); });
+        const probe = probeLaunchCleanupToken(run, token, 25);
         assert.equal(probe.ok && probe.processes.get(5000)?.startOrder, "150");
-        assert.equal(invocation?.command, "sh");
-        assert.equal(invocation?.timeout, 25);
-        assert.ok(invocation?.args.includes(LAUNCH_CLEANUP_TOKEN_ENV));
-        assert.ok(invocation?.args.includes(token));
-        assert.match(invocation?.args[1] ?? "", /\/proc\/\$1\/environ/);
+        assert.equal(calls[0], "sh");
+        assert.deepEqual([calls[2].timeout, calls[1].includes(LAUNCH_CLEANUP_TOKEN_ENV), calls[1].includes(token)], [25, true, true]);
+        assert.match(calls[1][1], /\/proc\/\$1\/environ/);
+        assert.doesNotMatch(calls[1][1], /\bseq\b/);
     });
-    it("signals every exact-token target returned by the bounded adapter", () => {
-        const cleanup = signalLaunchCleanupToken((() => result("CODENOMAD_TARGET|4242|1|4242|100|boot-a|100\n" +
-            "CODENOMAD_TARGET|5000|1|4242|150|boot-a|150\n" +
-            "CODENOMAD_RESULT|1\n")), "b".repeat(64), "SIGKILL", 25);
-        assert.equal(cleanup.ok, true);
-        assert.deepEqual(cleanup.targets.map((target) => target.pid), [4242, 5000]);
+    it("executes a successful empty Linux token probe", { skip: process.platform !== "linux" }, () => {
+        const probe = probeLaunchCleanupToken(spawnSync, "f".repeat(64), 1_000);
+        assert.deepEqual(probe, { ok: true, processes: new Map() });
     });
-    it("rejects malformed cleanup records conservatively", () => {
-        const probe = probeLaunchCleanupToken((() => result("5000|1|4242|150|boot-a|150|truncated\n")), "c".repeat(64), 25);
-        assert.equal(probe.ok, false);
+    it("signals every exact-token target and rejects malformed records", () => {
+        const rows = "CODENOMAD_TARGET|4242|1|4242|100|boot-a|100\nCODENOMAD_TARGET|5000|1|4242|150|boot-a|150\nCODENOMAD_RESULT|1\n";
+        const run = (() => result(rows));
+        const cleanup = signalLaunchCleanupToken(run, "b".repeat(64), "SIGKILL", 25);
+        assert.deepEqual([cleanup.ok, cleanup.targets.map(({ pid }) => pid)], [true, [4242, 5000]]);
+        const malformed = (() => result("5000|1|4242|150|boot-a|150|truncated\n"));
+        assert.equal(probeLaunchCleanupToken(malformed, "c".repeat(64), 25).ok, false);
     });
 });