gsd-pi 2.78.1-dev.e9d88a536 → 2.78.1-dev.eccf86e27

package/src/resources/extensions/gsd/worktree-resolver.ts

@@ -1,3 +1,4 @@
+// GSD-2 — WorktreeResolver: encapsulates worktree path state and merge/exit lifecycle.
 /**
  * WorktreeResolver — encapsulates worktree path state and merge/exit lifecycle.
  *
@@ -23,7 +24,21 @@ import { emitJournalEvent } from "./journal.js";
 import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
 import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "./worktree-root.js";
+import { claimMilestoneLease, releaseMilestoneLease } from "./db/milestone-leases.js";
+
+// ─── Path Comparison Helper ────────────────────────────────────────────────
+/**
+ * Compare two paths for physical identity, tolerating trailing slashes,
+ * symlink differences, and case variations on case-insensitive volumes.
+ *
+ * Used in place of string `===` / `!==` wherever one operand may be
+ * realpath-normalised (e.g. from the workspace registry) and the other
+ * may not be (e.g. a raw caller-supplied basePath).
+ */
+function isSamePath(a: string, b: string): boolean {
+  return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
+}
 
 // ─── Dependency Interface ──────────────────────────────────────────────────
 
@@ -185,6 +200,67 @@ export class WorktreeResolver {
       return;
     }
 
+    // Phase B: claim a milestone lease before any worktree mutation. Two
+    // workers cannot enter the same milestone concurrently. Best-effort:
+    // skip if no worker registered (single-worker fallback) or DB
+    // unavailable; reuse existing lease if we already hold it on this
+    // milestone (re-entry within the same session).
+    if (this.s.workerId) {
+      if (this.s.currentMilestoneId === milestoneId && this.s.milestoneLeaseToken !== null) {
+        // Already held — no-op, the heartbeat in loop.ts refreshes TTL.
+      } else {
+        // If we held a different milestone, release it first so other
+        // workers don't have to wait for TTL.
+        if (this.s.currentMilestoneId && this.s.currentMilestoneId !== milestoneId && this.s.milestoneLeaseToken !== null) {
+          try {
+            releaseMilestoneLease(this.s.workerId, this.s.currentMilestoneId, this.s.milestoneLeaseToken);
+          } catch (err) {
+            debugLog("WorktreeResolver", {
+              action: "enterMilestone",
+              milestoneId,
+              releasePriorLeaseError: err instanceof Error ? err.message : String(err),
+            });
+          }
+          this.s.milestoneLeaseToken = null;
+        }
+
+        try {
+          const claim = claimMilestoneLease(this.s.workerId, milestoneId);
+          if (claim.ok) {
+            this.s.milestoneLeaseToken = claim.token;
+            debugLog("WorktreeResolver", {
+              action: "enterMilestone",
+              milestoneId,
+              leaseAcquired: true,
+              fencingToken: claim.token,
+              expiresAt: claim.expiresAt,
+            });
+          } else {
+            // Lease held by another worker — fail loud so the user can
+            // see the conflict instead of silently double-running.
+            const msg = `Milestone ${milestoneId} is held by worker ${claim.byWorker} until ${claim.expiresAt}.`;
+            debugLog("WorktreeResolver", {
+              action: "enterMilestone",
+              milestoneId,
+              leaseHeldByOther: claim.byWorker,
+              expiresAt: claim.expiresAt,
+            });
+            ctx.notify(`${msg} Another auto-mode worker is active. Stop it before entering ${milestoneId}.`, "error");
+            return;
+          }
+        } catch (err) {
+          // DB unavailable or other error — log and fall through to the
+          // pre-Phase-B single-worker behavior so a fresh project before
+          // DB init still works.
+          debugLog("WorktreeResolver", {
+            action: "enterMilestone",
+            milestoneId,
+            leaseError: err instanceof Error ? err.message : String(err),
+          });
+        }
+      }
+    }
+
     // Resolve the project root for worktree operations via shared helper.
     // Handles the case where originalBasePath is falsy and basePath is itself
     // a worktree path — prevents double-nested worktree paths (#3729).
@@ -589,7 +665,7 @@ export class WorktreeResolver {
         milestoneId,
         "ROADMAP",
       );
-      if (!roadmapPath && this.s.basePath !== originalBase) {
+      if (!roadmapPath && !isSamePath(this.s.basePath, originalBase)) {
         roadmapPath = this.deps.resolveMilestoneFile(
           this.s.basePath,
           milestoneId,

package/src/resources/extensions/gsd/write-intercept.ts

@@ -91,9 +91,9 @@ function matchesBlockedPattern(path: string): boolean {
  * Directs the agent to use engine tool calls instead.
  */
 export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
-- To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
-- To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
-- To save a decision: call gsd_save_decision(scope, decision, choice, rationale)
+- To complete a task: call gsd_task_complete(milestone_id, slice_id, task_id, summary)
+- To complete a slice: call gsd_slice_complete(milestone_id, slice_id, summary, uat_result)
+- To save a decision: call gsd_decision_save(scope, decision, choice, rationale)
 - To start a task: call gsd_start_task(milestone_id, slice_id, task_id)
 - To record verification: call gsd_record_verification(milestone_id, slice_id, task_id, evidence)
 - To report a blocker: call gsd_report_blocker(milestone_id, slice_id, task_id, description)`;

package/src/resources/extensions/gsd/tests/auto-lock-creation.test.ts

@@ -1,213 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, writeFileSync, existsSync, readFileSync, rmSync } from "node:fs";
-import { createRequire } from "node:module";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { writeLock, readCrashLock, clearLock, isLockProcessAlive } from "../crash-recovery.ts";
-import { acquireSessionLock, releaseSessionLock } from "../session-lock.ts";
-
-const require = createRequire(import.meta.url);
-
-function hasProperLockfile(): boolean {
-  try {
-    require("proper-lockfile");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-const properLockfileAvailable = hasProperLockfile();
-
-// ─── writeLock creates auto.lock in .gsd/ ────────────────────────────────
-
-test("writeLock creates auto.lock with correct structure", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  writeLock(dir, "starting", "M001");
-
-  const lockPath = join(dir, ".gsd", "auto.lock");
-  assert.ok(existsSync(lockPath), "auto.lock should exist after writeLock");
-
-  const data = JSON.parse(readFileSync(lockPath, "utf-8"));
-  assert.equal(data.pid, process.pid, "lock should contain current PID");
-  assert.equal(data.unitType, "starting", "lock should contain unit type");
-  assert.equal(data.unitId, "M001", "lock should contain unit ID");
-  assert.ok(data.startedAt, "lock should have startedAt timestamp");
-
-  rmSync(dir, { recursive: true, force: true });
-});
-
-test("writeLock updates existing lock with new unit info", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  writeLock(dir, "starting", "M001");
-  writeLock(dir, "execute-task", "M001/S01/T01", "/tmp/session.jsonl");
-
-  const data = JSON.parse(readFileSync(join(dir, ".gsd", "auto.lock"), "utf-8"));
-  assert.equal(data.unitType, "execute-task", "lock should be updated to new unit type");
-  assert.equal(data.unitId, "M001/S01/T01", "lock should be updated to new unit ID");
-  assert.equal(data.sessionFile, "/tmp/session.jsonl", "session file should be recorded");
-
-  rmSync(dir, { recursive: true, force: true });
-});
-
-// ─── readCrashLock reads auto.lock data ──────────────────────────────────
-
-test("readCrashLock returns null when no lock file exists", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  const lock = readCrashLock(dir);
-  assert.equal(lock, null, "should return null when no lock file");
-
-  rmSync(dir, { recursive: true, force: true });
-});
-
-test("readCrashLock returns lock data when file exists", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  writeLock(dir, "plan-milestone", "M002");
-  const lock = readCrashLock(dir);
-
-  assert.ok(lock, "should return lock data");
-  assert.equal(lock!.unitType, "plan-milestone");
-  assert.equal(lock!.unitId, "M002");
-
-  rmSync(dir, { recursive: true, force: true });
-});
-
-// ─── clearLock removes auto.lock ─────────────────────────────────────────
-
-test("clearLock removes the lock file", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  writeLock(dir, "starting", "M001");
-  assert.ok(existsSync(join(dir, ".gsd", "auto.lock")), "lock should exist before clear");
-
-  clearLock(dir);
-  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "lock should be removed after clear");
-
-  rmSync(dir, { recursive: true, force: true });
-});
-
-test("clearLock is safe when no lock file exists", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  // Should not throw
-  clearLock(dir);
-
-  rmSync(dir, { recursive: true, force: true });
-});
-
-test("bootstrap cleanup releases session lock artifacts", (t) => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  t.after(() => rmSync(dir, { recursive: true, force: true }));
-
-  const result = acquireSessionLock(dir);
-  assert.equal(result.acquired, true, "session lock should be acquired");
-  assert.ok(existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should exist while lock is held");
-  if (properLockfileAvailable) {
-    assert.ok(existsSync(join(dir, ".gsd.lock")), ".gsd.lock should exist while lock is held");
-  }
-
-  releaseSessionLock(dir);
-  clearLock(dir);
-
-  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "auto.lock should be removed by bootstrap cleanup");
-  assert.ok(!existsSync(join(dir, ".gsd.lock")), ".gsd.lock should be removed by bootstrap cleanup");
-});
-
-// ─── isLockProcessAlive detects live vs dead PIDs ────────────────────────
-
-test("isLockProcessAlive returns false for dead PID", () => {
-  const lock = {
-    pid: 9999999,
-    startedAt: new Date().toISOString(),
-    unitType: "execute-task",
-    unitId: "M001/S01/T01",
-    unitStartedAt: new Date().toISOString(),
-  };
-  assert.equal(isLockProcessAlive(lock), false, "dead PID should return false");
-});
-
-test("#2470: isLockProcessAlive returns true for own PID (we hold the lock)", () => {
-  const lock = {
-    pid: process.pid,
-    startedAt: new Date().toISOString(),
-    unitType: "execute-task",
-    unitId: "M001/S01/T01",
-    unitStartedAt: new Date().toISOString(),
-  };
-  assert.equal(isLockProcessAlive(lock), true, "own PID means we are alive — not stale (#2470)");
-});
-
-test("isLockProcessAlive returns false for invalid PID", () => {
-  const lock = {
-    pid: -1,
-    startedAt: new Date().toISOString(),
-    unitType: "execute-task",
-    unitId: "M001/S01/T01",
-    unitStartedAt: new Date().toISOString(),
-  };
-  assert.equal(isLockProcessAlive(lock), false, "negative PID should return false");
-});
-
-// ─── Cross-process detection via lock file ───────────────────────────────
-
-test("lock file enables cross-process auto-mode detection", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  // Use the parent process PID — guaranteed alive on all platforms (Unix and Windows).
-  // PID 1 (init) only works on Unix; on Windows it doesn't exist.
-  const alivePid = process.ppid;
-  const lockData = {
-    pid: alivePid,
-    startedAt: new Date().toISOString(),
-    unitType: "execute-task",
-    unitId: "M001/S01/T02",
-    unitStartedAt: new Date().toISOString(),
-  };
-  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
-
-  const lock = readCrashLock(dir);
-  assert.ok(lock, "should read the lock");
-  assert.equal(lock!.pid, alivePid);
-
-  // Parent PID is always alive — isLockProcessAlive should detect it
-  const alive = isLockProcessAlive(lock!);
-  assert.equal(alive, true, "parent PID should be detected as alive");
-
-  rmSync(dir, { recursive: true, force: true });
-});
-
-test("stale lock from dead process is detected as not alive", () => {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-
-  // Simulate a stale lock from a process that no longer exists
-  const lockData = {
-    pid: 9999999,
-    startedAt: "2026-03-01T00:00:00Z",
-    unitType: "plan-slice",
-    unitId: "M001/S02",
-    unitStartedAt: "2026-03-01T00:05:00Z",
-  };
-  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
-
-  const lock = readCrashLock(dir);
-  assert.ok(lock, "should read the stale lock");
-  assert.equal(isLockProcessAlive(lock!), false, "dead process should not be alive");
-
-  rmSync(dir, { recursive: true, force: true });
-});

package/src/resources/extensions/gsd/tests/auto-stale-lock-self-kill.test.ts

@@ -1,87 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, writeFileSync, existsSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
-import { checkRemoteAutoSession, stopAutoRemote } from "../auto.ts";
-
-function makeTmpProject(): string {
-  const dir = mkdtempSync(join(tmpdir(), "gsd-stale-lock-test-"));
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-  return dir;
-}
-
-// ─── checkRemoteAutoSession: own-PID filtering (#2730) ───────────────────
-
-test("#2730: checkRemoteAutoSession returns { running: false } when lock PID matches current process", (t) => {
-  const dir = makeTmpProject();
-  t.after(() => rmSync(dir, { recursive: true, force: true }));
-
-  // Write a lock with the current process PID — simulates a stale lock
-  // left behind after step-mode exit without full cleanup.
-  writeLock(dir, "execute-task", "M001/S01/T01");
-
-  const lock = readCrashLock(dir);
-  assert.ok(lock, "lock file should exist");
-  assert.equal(lock!.pid, process.pid, "lock should have our PID");
-
-  const result = checkRemoteAutoSession(dir);
-  assert.equal(result.running, false, "own PID must not be treated as a remote session");
-});
-
-test("#2730: checkRemoteAutoSession still detects a genuine remote session (different PID)", (t) => {
-  const dir = makeTmpProject();
-  t.after(() => rmSync(dir, { recursive: true, force: true }));
-
-  // Use parent PID — guaranteed alive, guaranteed not our PID.
-  const remotePid = process.ppid;
-  const lockData = {
-    pid: remotePid,
-    startedAt: new Date().toISOString(),
-    unitType: "execute-task",
-    unitId: "M001/S01/T02",
-    unitStartedAt: new Date().toISOString(),
-  };
-  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
-
-  const result = checkRemoteAutoSession(dir);
-  assert.equal(result.running, true, "different live PID should be detected as running");
-  assert.equal(result.pid, remotePid);
-});
-
-// ─── stopAutoRemote: self-kill prevention (#2730) ────────────────────────
-
-test("#2730: stopAutoRemote does not send SIGTERM when lock PID matches current process", (t) => {
-  const dir = makeTmpProject();
-  t.after(() => rmSync(dir, { recursive: true, force: true }));
-
-  // Write a lock with our own PID
-  writeLock(dir, "execute-task", "M001/S01/T01");
-
-  const result = stopAutoRemote(dir);
-  assert.equal(result.found, false, "own PID must not be signalled");
-
-  // The lock should be cleared as part of the self-detection cleanup
-  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale self-lock should be cleared");
-});
-
-test("#2730: stopAutoRemote clears stale lock from dead remote process without error", (t) => {
-  const dir = makeTmpProject();
-  t.after(() => rmSync(dir, { recursive: true, force: true }));
-
-  // Simulate a stale lock from a process that no longer exists
-  const lockData = {
-    pid: 9999999,
-    startedAt: "2026-03-01T00:00:00Z",
-    unitType: "plan-slice",
-    unitId: "M001/S02",
-    unitStartedAt: "2026-03-01T00:05:00Z",
-  };
-  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
-
-  const result = stopAutoRemote(dir);
-  assert.equal(result.found, false, "dead remote PID should not be reported as found");
-  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale lock should be cleaned up");
-});

package/src/resources/extensions/gsd/tests/stop-auto-remote.test.ts

@@ -1,159 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { randomUUID } from "node:crypto";
-import { spawn, type ChildProcess } from "node:child_process";
-
-import { writeFileSync } from "node:fs";
-import {
-  writeLock,
-  readCrashLock,
-  clearLock,
-  isLockProcessAlive,
-} from "../crash-recovery.ts";
-import { stopAutoRemote } from "../auto.ts";
-
-function makeTmpBase(): string {
-  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
-  mkdirSync(join(base, ".gsd"), { recursive: true });
-  return base;
-}
-
-function cleanup(base: string): void {
-  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
-}
-
-function waitForChildExit(child: ChildProcess, timeoutMs = 10000): Promise<number | null> {
-  return new Promise((resolve) => {
-    if (child.exitCode !== null) {
-      resolve(child.exitCode);
-      return;
-    }
-
-    const timeout = setTimeout(() => {
-      child.off("exit", onExit);
-      resolve(child.exitCode);
-    }, timeoutMs);
-
-    const onExit = (code: number | null) => {
-      clearTimeout(timeout);
-      resolve(code);
-    };
-
-    child.once("exit", onExit);
-  });
-}
-
-// ─── stopAutoRemote ──────────────────────────────────────────────────────
-
-test("stopAutoRemote returns found:false when no lock file exists", () => {
-  const base = makeTmpBase();
-  try {
-    const result = stopAutoRemote(base);
-    assert.equal(result.found, false);
-    assert.equal(result.pid, undefined);
-    assert.equal(result.error, undefined);
-  } finally {
-    cleanup(base);
-  }
-});
-
-test("stopAutoRemote cleans up stale lock (dead PID) and returns found:false", () => {
-  const base = makeTmpBase();
-  try {
-    // Write a lock with a PID that doesn't exist
-    writeLock(base, "execute-task", "M001/S01/T01");
-    // Overwrite PID to a dead one
-    const lock = readCrashLock(base)!;
-    const staleData = { ...lock, pid: 999999999 };
-    writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify(staleData, null, 2), "utf-8");
-
-    const result = stopAutoRemote(base);
-    assert.equal(result.found, false, "stale lock should not be found as running");
-
-    // Lock should be cleaned up
-    assert.equal(readCrashLock(base), null, "stale lock should be removed");
-  } finally {
-    cleanup(base);
-  }
-});
-
-// KNOWN FLAKE: This test is timing-sensitive — it spawns a child, writes a lock file,
-// sends SIGTERM, and asserts the child exited. Under heavy CI load the child may
-// not be ready when SIGTERM is sent. Mitigations: 500ms startup delay, 10s exit timeout.
-test("stopAutoRemote sends SIGTERM to a live process and returns found:true", { timeout: 15000 }, async () => {
-  const base = makeTmpBase();
-
-  // Spawn a child process that prints "ready" then sleeps, acting as a fake auto-mode session
-  const child = spawn(
-    process.execPath,
-    ["-e", "process.on('SIGTERM', () => process.exit(0)); process.stdout.write('ready'); setTimeout(() => process.exit(1), 30000);"],
-    { stdio: ["ignore", "pipe", "ignore"], detached: false },
-  );
-
-  if (!child.pid) {
-    throw new Error("failed to spawn child process for stopAutoRemote test");
-  }
-
-  try {
-    // Wait for child to signal readiness via stdout
-    await new Promise<void>((resolve) => {
-      child.stdout!.once("data", () => resolve());
-      setTimeout(resolve, 2000); // fallback timeout
-    });
-
-    // Write lock with child's PID
-    const lockData = {
-      pid: child.pid,
-      startedAt: new Date().toISOString(),
-      unitType: "execute-task",
-      unitId: "M001/S01/T01",
-      unitStartedAt: new Date().toISOString(),
-    };
-    writeFileSync(join(base, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2), "utf-8");
-
-    const exitPromise = waitForChildExit(child);
-    const result = stopAutoRemote(base);
-    assert.equal(result.found, true, "should find running auto-mode");
-    assert.equal(result.pid, child.pid, "should return the PID");
-
-    // Wait for child to exit (it should receive SIGTERM)
-    const exitCode = await exitPromise;
-    // On Windows, SIGTERM is not interceptable — the process exits with code 1
-    // rather than running the handler. Accept either clean exit (0) or forced (1).
-    assert.ok(exitCode !== null, "child should have exited after SIGTERM");
-    if (process.platform !== "win32") {
-      assert.equal(exitCode, 0, "child should have exited cleanly via SIGTERM");
-    }
-  } finally {
-    try { child.kill("SIGKILL"); } catch { /* already dead */ }
-    cleanup(base);
-  }
-});
-
-// ─── Lock path: original project root vs worktree ────────────────────────
-
-test("lock file should be discoverable from project root and worktree path", () => {
-  const projectRoot = makeTmpBase();
-  const worktreePath = join(projectRoot, ".gsd", "worktrees", "M001");
-  mkdirSync(join(worktreePath, ".gsd"), { recursive: true });
-
-  try {
-    // Simulate: auto-mode writes lock to project root (the fix)
-    writeLock(projectRoot, "execute-task", "M001/S01/T01");
-
-    // Second terminal checks project root — should find the lock
-    const lock = readCrashLock(projectRoot);
-    assert.ok(lock, "lock should be found at project root");
-    assert.equal(lock!.unitType, "execute-task");
-
-    // Worktree path resolves to the same canonical project .gsd lock.
-    const worktreeLock = readCrashLock(worktreePath);
-    assert.ok(worktreeLock, "lock should be discoverable via worktree path");
-    assert.equal(worktreeLock!.unitType, "execute-task");
-  } finally {
-    cleanup(projectRoot);
-  }
-});