fix: make workspace registry lock process-bound

backend/test/workspace-registry.test.ts

@@ -6,6 +6,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
 import { afterEach, expect, test } from "vitest";
+import { WorkspaceRepositoryLock } from "../src/workspaces/git-repository.js";
 import { WorkspaceRegistry } from "../src/workspaces/registry.js";
 import type { WorkspaceRegistryConfig } from "../src/workspaces/types.js";
 
@@ -113,14 +114,25 @@ test("keeps the last valid snapshot when a pulled commit has invalid YAML", asyn
   });
 });
 
-test("does not bypass an existing advisory repository lock", async () => {
+test("does not bypass an existing live advisory repository lock", async () => {
   const remote = await fixture();
   const root = join(remote.root, "registry");
   const registry = new WorkspaceRegistry(config(root, remote.remote));
-  mkdirSync(join(root, "locks"), { recursive: true });
-  writeFileSync(join(root, "locks", "repository.lock"), "held");
+  const lock = new WorkspaceRepositoryLock(join(root, "locks"));
+  let release!: () => void;
+  let started!: () => void;
+  const held = lock.run(async () => {
+    started();
+    await new Promise<void>((resolve) => { release = resolve; });
+  });
+  await new Promise<void>((resolve) => { started = resolve; });
 
-  await expect(registry.bootstrap()).rejects.toMatchObject({ code: "workspace_stale" });
+  try {
+    await expect(registry.bootstrap()).rejects.toMatchObject({ code: "workspace_stale" });
+  } finally {
+    release();
+    await held;
+  }
 });
 
 test("rejects a symbolic-link registry root before creating a lock below it", async () => {

backend/test/workspaces-git-repository.test.ts

@@ -137,3 +137,44 @@ test("maps lock filesystem failures to a stable redacted error", async () => {
   });
   expect((error as Error).message).not.toContain(file);
 });
+
+test("releases its queue after a malformed lock failure so a later attempt can acquire", async () => {
+  const root = mkdtempSync(join(tmpdir(), "thoth-workspace-git-queue-"));
+  temporaryRoots.push(root);
+  const locks = join(root, "locks");
+  mkdirSync(join(locks, "repository.lock"), { recursive: true });
+  const lock = new WorkspaceRepositoryLock(locks);
+
+  await expect(lock.run(async () => "unreachable")).rejects.toMatchObject({ code: "git_unavailable" });
+  rmSync(join(locks, "repository.lock"), { recursive: true, force: true });
+
+  const result = await Promise.race([
+    lock.run(async () => "recovered"),
+    new Promise<string>((resolve) => setTimeout(() => resolve("timed out"), 250)),
+  ]);
+  expect(result).toBe("recovered");
+});
+
+test("parallel contenders recover a stale lock file without overlapping critical sections", async () => {
+  const root = mkdtempSync(join(tmpdir(), "thoth-workspace-git-contenders-"));
+  temporaryRoots.push(root);
+  const locks = join(root, "locks");
+  mkdirSync(locks);
+  writeFileSync(join(locks, "repository.lock"), JSON.stringify({ pid: 999_999_999 }));
+  const first = new WorkspaceRepositoryLock(locks);
+  const second = new WorkspaceRepositoryLock(locks);
+  let active = 0;
+  let maximum = 0;
+  const critical = async () => {
+    active += 1;
+    maximum = Math.max(maximum, active);
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    active -= 1;
+  };
+
+  const results = await Promise.allSettled([first.run(critical), second.run(critical)]);
+
+  expect(results.filter((result) => result.status === "fulfilled")).toHaveLength(1);
+  expect(results.filter((result) => result.status === "rejected")).toHaveLength(1);
+  expect(maximum).toBe(1);
+});