@opengsd/gsd-pi 1.2.0-dev.fb12b103 → 1.2.0-dev.fbdca60b

package/src/resources/extensions/gsd/tests/guided-dispatch-root.test.ts

@@ -11,6 +11,7 @@ import {
   _dispatchWorkflowForTest,
   resolveGuidedDispatchProjectRoot,
 } from "../guided-flow.ts";
+import { getRequiredWorkflowToolsForUnit } from "../unit-tool-contracts.ts";
 
 test("guided dispatch falls back to cwd only when no project root is supplied", () => {
   const cwd = process.cwd();
@@ -77,12 +78,8 @@ test("guided dispatch passes the explicit project root through model and compati
             seen.modelRoot = projectRoot;
             return { routing: null, appliedModel: null };
           },
-          getTransportSupportError: (
-            _provider: string | undefined,
-            _requiredTools: string[],
-            options?: { projectRoot?: string },
-          ) => {
-            seen.compatibilityRoot = options?.projectRoot ?? "";
+          getDispatchReadinessError: (input: { projectRoot?: string }) => {
+            seen.compatibilityRoot = input.projectRoot ?? "";
             return null;
           },
         },
@@ -119,6 +116,7 @@ test("guided dispatch accepts workflow MCP tools absent from parent active tool
       getProviderAuthMode: () => "externalCli",
     },
     ui: {
+      setStatus: () => {},
       notify: (message: string) => {
         notifications.push(message);
       },
@@ -134,8 +132,22 @@ test("guided dispatch accepts workflow MCP tools absent from parent active tool
     "write",
   ];
 
+  // The workflow MCP server registers its tools out of band, so the unit's
+  // required workflow tools show up in the registered tool snapshot
+  // (getAllTools) under the MCP server prefix without ever entering the parent
+  // session's active tool surface (getActiveTools). This is exactly the shape
+  // the readiness gate must accept. Derive the surface from the unit contract
+  // so this test stays correct if discuss-milestone's required tools change.
+  const registeredTools = [
+    ...activeTools,
+    ...getRequiredWorkflowToolsForUnit("discuss-milestone").map(
+      (tool) => `mcp__gsd-workflow__${tool}`,
+    ),
+  ];
+
   const pi = {
     getActiveTools: () => [...activeTools],
+    getAllTools: () => registeredTools.map((name) => ({ name })),
     setActiveTools: (tools: string[]) => {
       activeTools = [...tools];
     },

package/src/resources/extensions/gsd/tests/integration/auto-worktree.test.ts

@@ -134,6 +134,21 @@ describe("auto-worktree lifecycle", () => {
     teardownAutoWorktree(tempDir, "M003");
   });
 
+  test("isInAutoWorktree returns false when ambient cwd was deleted", (t) => {
+    const cwd = t.mock.method(process, "cwd", () => {
+      const err = new Error("process.cwd failed") as NodeJS.ErrnoException;
+      err.code = "ENOENT";
+      err.syscall = "uv_cwd";
+      throw err;
+    });
+
+    try {
+      assert.equal(isInAutoWorktree("/repo"), false);
+    } finally {
+      cwd.mock.restore();
+    }
+  });
+
   test("symlink-resolved auto worktree is detected after module state reset", () => {
     tempDir = createTempRepo();
     const savedGsdHome = process.env.GSD_HOME;

package/src/resources/extensions/gsd/tests/integration/doctor-environment-async.test.ts

@@ -0,0 +1,104 @@
+// Project/App: gsd-pi
+// File Purpose: Verify the non-blocking runEnvironmentChecksAsync is behaviourally
+// identical to the synchronous runEnvironmentChecks (the health-widget render
+// path was moved onto the async variant for performance), and that the single-
+// scan checkPortConflicts still detects a real in-use port.
+
+import test, { type TestContext } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { createServer } from "node:net";
+
+import {
+  runEnvironmentChecks,
+  runEnvironmentChecksAsync,
+  type EnvironmentCheckResult,
+} from "../../doctor-environment.ts";
+
+function makeProject(t: TestContext, files: Record<string, string>): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-env-async-"));
+  t.after(() => {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {
+      /* ignore */
+    }
+  });
+  for (const [name, content] of Object.entries(files)) {
+    const filePath = join(dir, name);
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, content);
+  }
+  return dir;
+}
+
+// Stable, order-independent signature of a check-result set for comparison.
+function normalize(results: EnvironmentCheckResult[]): string[] {
+  return results.map((r) => `${r.name}|${r.status}|${r.message}|${r.detail ?? ""}`).sort();
+}
+
+test("runEnvironmentChecksAsync returns the same results as runEnvironmentChecks", async (t) => {
+  const dir = makeProject(t, {
+    "package.json": JSON.stringify({
+      name: "fixture",
+      engines: { node: ">=18" },
+      scripts: { dev: "vite --port 4321", build: "tsc" },
+      devDependencies: { typescript: "^5.0.0" },
+    }),
+    ".env.example": "API_KEY=\n",
+    Dockerfile: "FROM node:20\n",
+  });
+  mkdirSync(join(dir, "node_modules"), { recursive: true });
+
+  const sync = runEnvironmentChecks(dir);
+  const asyncResults = await runEnvironmentChecksAsync(dir);
+
+  assert.deepEqual(
+    normalize(asyncResults),
+    normalize(sync),
+    "async checks must produce the identical result set as the sync checks",
+  );
+  // Sanity: the fixture is rich enough that the suite actually produced checks.
+  assert.ok(sync.length > 0, "expected the fixture to yield environment checks");
+});
+
+test("runEnvironmentChecksAsync matches sync on a bare directory (no package.json)", async (t) => {
+  const dir = makeProject(t, {});
+  const sync = runEnvironmentChecks(dir);
+  const asyncResults = await runEnvironmentChecksAsync(dir);
+  assert.deepEqual(normalize(asyncResults), normalize(sync));
+});
+
+test(
+  "single-scan port check detects a real in-use port, identically sync and async",
+  { skip: process.platform === "win32" ? "lsof-based port check is macOS/Linux only" : false },
+  async (t) => {
+    // Bind a real listener, then reference its port from package.json scripts so
+    // collectPortsToCheck picks it up. The server stays up across both check runs.
+    const server = createServer();
+    const port = await new Promise<number>((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", () => {
+        const addr = server.address();
+        resolve(typeof addr === "object" && addr ? addr.port : 0);
+      });
+    });
+    t.after(() => new Promise<void>((resolve) => server.close(() => resolve())));
+    assert.ok(port >= 1024 && port <= 65535, "ephemeral port should be in the checked range");
+
+    const dir = makeProject(t, {
+      "package.json": JSON.stringify({ name: "fixture", scripts: { dev: `serve --port ${port}` } }),
+    });
+
+    const syncConflicts = runEnvironmentChecks(dir).filter((r) => r.name === "port_conflict");
+    const asyncConflicts = (await runEnvironmentChecksAsync(dir)).filter((r) => r.name === "port_conflict");
+
+    // Equivalence holds regardless of whether lsof is present on the runner.
+    assert.deepEqual(normalize(asyncConflicts), normalize(syncConflicts), "sync and async must agree on port conflicts");
+    // On macOS/Linux lsof is standard, so the listener must be reported and named.
+    assert.equal(syncConflicts.length, 1, "expected exactly one port conflict for the in-use port");
+    assert.match(syncConflicts[0]!.message, new RegExp(`\\b${port}\\b`), "conflict message must name the in-use port");
+  },
+);

package/src/resources/extensions/gsd/tests/integration/run-uat.test.ts

@@ -317,6 +317,24 @@ test('(k2) run-uat prompt references gsd_uat_result_save, not direct write', ()
   );
 });
 
+test('(k3) run-uat prompt warns that .gsd glob misses can be symlink traversal artifacts', async () => {
+  const base = createFixtureBase();
+  try {
+    const uatRel = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
+    const uatContent = makeUatContent('runtime-executable');
+    writeSliceFile(base, 'M001', 'S01', 'UAT', uatContent);
+
+    const prompt = await buildRunUatPrompt('M001', 'S01', uatRel, uatContent, base);
+
+    assert.match(prompt, /\.gsd\/\*\*/);
+    assert.match(prompt, /symlink-backed/i);
+    assert.match(prompt, /do not infer that the GSD harness is missing/i);
+    assert.match(prompt, /use the preloaded UAT context/i);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('(l) dispatch preconditions via resolveSliceFile', () => {
     const base = createFixtureBase();
     const uatContent = makeUatContent('artifact-driven');
@@ -731,6 +749,75 @@ test('(u) run-uat prompt promotes artifact-driven browser specs to browser-execu
     }
 });
 
+test('(w) run-uat prompt promotes browser-executable harness specs to runtime-executable (M006/S01)', async () => {
+    const base = createFixtureBase();
+    try {
+      const uatRel = '.gsd/milestones/M006/slices/S01/S01-UAT.md';
+      const uatContent = [
+        '# S01 UAT',
+        '',
+        '## UAT Type',
+        '- UAT mode: browser-executable',
+        '',
+        '## Preconditions',
+        '- Start the local app server with `npm run start`.',
+        '- Open the app at `http://127.0.0.1:4173`.',
+        '',
+        '## Evidence',
+        '- Fresh closeout verification command: `npm run test:uat`',
+      ].join('\n');
+      writeSliceFile(base, 'M006', 'S01', 'UAT', uatContent);
+
+      const prompt = await buildRunUatPrompt('M006', 'S01', uatRel, uatContent, base);
+
+      assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`runtime-executable`/);
+      assert.match(prompt, /uatType: "runtime-executable"/);
+      assert.match(prompt, /Runtime harness override/i);
+      assert.match(prompt, /Do \*\*not\*\* call `uat-service-start`/);
+      assert.doesNotMatch(prompt, /uatType: "browser-executable"/);
+    } finally {
+      cleanup(base);
+    }
+});
+
+test('(w2) run-uat prompt promotes harness from slice context when UAT only names test:server (M007/S01)', async () => {
+    const base = createFixtureBase();
+    try {
+      const uatRel = '.gsd/milestones/M007/slices/S01/S01-UAT.md';
+      const uatContent = [
+        '# S01 UAT',
+        '',
+        '## UAT Type',
+        '- UAT mode: browser-executable',
+        '',
+        '## Preconditions',
+        '- Start the dev/local verification server with `npm run test:server`.',
+        '- Open the app at the localhost URL printed by the server.',
+      ].join('\n');
+      writeSliceFile(base, 'M007', 'S01', 'UAT', uatContent);
+      writeSliceFile(
+        base,
+        'M007',
+        'S01',
+        'SUMMARY',
+        [
+          '# S01 Summary',
+          '',
+          'Verification: `npm run test:uat` passed with clean browser diagnostics.',
+        ].join('\n'),
+      );
+
+      const prompt = await buildRunUatPrompt('M007', 'S01', uatRel, uatContent, base);
+
+      assert.match(prompt, /\*\*Detected UAT mode:\*\*\s*`runtime-executable`/);
+      assert.match(prompt, /Runtime harness override/i);
+      assert.match(prompt, /npm run test:server/);
+      assert.match(prompt, /uatType: "runtime-executable"/);
+    } finally {
+      cleanup(base);
+    }
+});
+
 test('(v) run-uat prompt keeps deferred browser work artifact-driven', async () => {
     const base = createFixtureBase();
     try {
@@ -748,4 +835,134 @@ test('(v) run-uat prompt keeps deferred browser work artifact-driven', async ()
       cleanup(base);
     }
 });
+
+test('(x) checkNeedsRunUat returns runtime-executable when slice SUMMARY names a self-contained harness (M007/S01)', async () => {
+    // Regression: the dispatch gate must surface the same effective UAT mode
+    // that buildRunUatPrompt emits. When the UAT file alone declares
+    // `browser-executable` but the slice SUMMARY references `npm run test:uat`,
+    // the prompt promotes to `runtime-executable` — and so must the gate, or
+    // the auto-dispatch path requires browser tools / warms up the browser
+    // daemon (and may stop dispatch entirely) for a UAT that never touches
+    // the browser. See cursor[bot] review on PR #696.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M007');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M007-ROADMAP.md'),
+        [
+          '# M007: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: Only slice** `risk:low` `depends:[]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+      writeSliceFile(
+        base,
+        'M007',
+        'S01',
+        'UAT',
+        [
+          '# S01 UAT',
+          '',
+          '## UAT Type',
+          '- UAT mode: browser-executable',
+          '',
+          '## Preconditions',
+          '- Start the dev/local verification server with `npm run test:server`.',
+        ].join('\n'),
+      );
+      writeSliceFile(
+        base,
+        'M007',
+        'S01',
+        'SUMMARY',
+        [
+          '# S01 Summary',
+          '',
+          'Verification: `npm run test:uat` passed with clean browser diagnostics.',
+        ].join('\n'),
+      );
+
+      const state = {
+        activeMilestone: { id: 'M007', title: 'Test roadmap' },
+        activeSlice: null,
+        activeTask: null,
+        phase: 'validating-milestone',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Validate M007',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M007', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        { sliceId: 'S01', uatType: 'runtime-executable' },
+        'dispatch gate must mirror the prompt`s runtime-executable promotion so it does not require browser tools',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
+
+test('(x2) checkNeedsRunUat leaves true browser-executable UAT unpromoted when no harness is referenced', async () => {
+    // Counter-test for (x): when the slice SUMMARY does NOT name a
+    // self-contained harness, the dispatch gate must still require browser
+    // tools for a genuinely browser-executable UAT.
+    const base = createFixtureBase();
+    try {
+      const roadmapDir = join(base, '.gsd', 'milestones', 'M008');
+      mkdirSync(roadmapDir, { recursive: true });
+      writeFileSync(
+        join(roadmapDir, 'M008-ROADMAP.md'),
+        [
+          '# M008: Test roadmap',
+          '',
+          '## Slices',
+          '',
+          '- [x] **S01: Only slice** `risk:low` `depends:[]`',
+          '',
+          '## Boundary Map',
+          '',
+        ].join('\n'),
+      );
+      writeSliceFile(base, 'M008', 'S01', 'UAT', makeBrowserObservableUatContent('browser-executable'));
+      writeSliceFile(
+        base,
+        'M008',
+        'S01',
+        'SUMMARY',
+        [
+          '# S01 Summary',
+          '',
+          'Verification: clicked through the UI and confirmed the search box filters todos.',
+        ].join('\n'),
+      );
+
+      const state = {
+        activeMilestone: { id: 'M008', title: 'Test roadmap' },
+        activeSlice: null,
+        activeTask: null,
+        phase: 'validating-milestone',
+        recentDecisions: [],
+        blockers: [],
+        nextAction: 'Validate M008',
+        registry: [],
+      } as const;
+
+      const result = await checkNeedsRunUat(base, 'M008', state as any, { uat_dispatch: true } as any);
+      assert.deepStrictEqual(
+        result,
+        { sliceId: 'S01', uatType: 'browser-executable' },
+        'a true browser-executable UAT without a harness reference must keep its browser-executable mode',
+      );
+    } finally {
+      cleanup(base);
+    }
+});
 });

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -15,12 +15,27 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
+/** Create a temp project root with a git repo for phase-function tests. */
+function makeTestBase(prefix: string): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  execFileSync("git", ["init", "--initial-branch=main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "README.md"), "# test\n");
+  execFileSync("git", ["add", "README.md"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "chore: seed"], { cwd: base, stdio: "ignore" });
+  return base;
+}
+
 import type { JournalEntry } from "../journal.js";
 import type { LoopDeps } from "../auto/loop-deps.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
 import type { IterationContext, LoopState, PreDispatchData, IterationData } from "../auto/types.js";
 import type { SessionLockStatus } from "../session-lock.js";
-import { runDispatch, runUnitPhase, runPreDispatch, runFinalize } from "../auto/phases.js";
+import { runDispatch } from "../auto/dispatch.js";
+import { runUnitPhase } from "../auto/unit-phase.js";
+import { runPreDispatch } from "../auto/pre-dispatch.js";
+import { runFinalize } from "../auto/finalize.js";
 import { readUnitRuntimeRecord } from "../unit-runtime.js";
 import { ModelPolicyDispatchBlockedError } from "../auto-model-selection.js";
 import {
@@ -182,7 +197,7 @@ function makeSession() {
     verbose: false,
     stepMode: false,
     paused: false,
-    basePath: "/tmp/project",
+    basePath: makeTestBase("gsd-journal-session-"),
     originalBasePath: "",
     currentMilestoneId: "M001",
     currentUnit: null,
@@ -296,10 +311,18 @@ test("runDispatch emits dispatch-stop when dispatch returns stop action", async
   assert.equal(stopEvents[0].flowId, ic.flowId);
 });
 
-test("runDispatch checks prior-slice completion against the project root in worktree mode", async () => {
+test("runDispatch checks prior-slice completion against the project root in worktree mode", async (t) => {
   const capture = createEventCapture();
   const guardCalls: Array<{ fn: string; args: unknown[] }> = [];
+  const projectRoot = makeTestBase("gsd-wt-prior-slice-");
+  const milestoneId = "M029-xoklo9";
+  const worktreeRoot = join(projectRoot, ".gsd", "worktrees", milestoneId);
+  execFileSync("git", ["worktree", "add", "-b", `auto/${milestoneId}`, worktreeRoot], { cwd: projectRoot, stdio: "ignore" });
+  t.after(() => rmSync(projectRoot, { recursive: true, force: true }));
+
   const deps = makeMockDeps(capture, {
+    getIsolationMode: () => "worktree",
+    autoWorktreeBranch: (mid: string) => `auto/${mid}`,
     getMainBranch: (basePath: string) => {
       guardCalls.push({ fn: "getMainBranch", args: [basePath] });
       return "main";
@@ -320,19 +343,21 @@ test("runDispatch checks prior-slice completion against the project root in work
   const ic = makeIC(deps, {
     s: {
       ...makeSession(),
-      basePath: "/tmp/project/.gsd/worktrees/M029-xoklo9",
-      originalBasePath: "/tmp/project",
+      basePath: worktreeRoot,
+      originalBasePath: projectRoot,
+      canonicalProjectRoot: projectRoot,
+      currentMilestoneId: milestoneId,
     } as any,
   });
   const preData: PreDispatchData = {
     state: {
       phase: "executing",
-      activeMilestone: { id: "M029-xoklo9", title: "Test", status: "active" },
+      activeMilestone: { id: milestoneId, title: "Test", status: "active" },
       activeSlice: { id: "S01", title: "Slice 1" },
-      registry: [{ id: "M029-xoklo9", status: "active" }],
+      registry: [{ id: milestoneId, status: "active" }],
       blockers: [],
     } as any,
-    mid: "M029-xoklo9",
+    mid: milestoneId,
     midTitle: "Test Milestone",
   };
 
@@ -342,12 +367,12 @@ test("runDispatch checks prior-slice completion against the project root in work
     consecutiveFinalizeTimeouts: 0,
   });
 
-  assert.equal(result.action, "next");
+  assert.equal(result.action, "next", "dispatch must proceed under worktree isolation");
   assert.deepEqual(guardCalls, [
-    { fn: "getMainBranch", args: ["/tmp/project"] },
+    { fn: "getMainBranch", args: [projectRoot] },
     {
       fn: "getPriorSliceCompletionBlocker",
-      args: ["/tmp/project", "main", "execute-task", "M001/S01/T01"],
+      args: [projectRoot, "main", "execute-task", "M001/S01/T01"],
     },
   ]);
 });
@@ -434,6 +459,9 @@ test("runDispatch pauses when execute-task artifacts exist but DB status is stil
   const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
   const tasksDir = join(sliceDir, "tasks");
   mkdirSync(tasksDir, { recursive: true });
+  execFileSync("git", ["init", "--initial-branch=main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
@@ -517,6 +545,9 @@ test("runDispatch pauses at Level 2 when execute-task artifacts exist but DB sta
   const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
   const tasksDir = join(sliceDir, "tasks");
   mkdirSync(tasksDir, { recursive: true });
+  execFileSync("git", ["init", "--initial-branch=main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: base, stdio: "ignore" });
   openDatabase(join(base, ".gsd", "gsd.db"));
   insertMilestone({ id: "M001", title: "Test", status: "active" });
   insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "in_progress" });
@@ -888,7 +919,7 @@ test("runUnitPhase increments unitDispatchCount for repeated artifact-missing re
 
 test("runUnitPhase pre-dispatch model validation failures do not emit unit-start or dispatch runtime state", async (t) => {
   const capture = createEventCapture();
-  const base = mkdtempSync(join(tmpdir(), `gsd-pre-dispatch-block-${randomUUID()}`));
+  const base = makeTestBase(`gsd-pre-dispatch-block-${randomUUID()}`);
   t.after(() => rmSync(base, { recursive: true, force: true }));
 
   const deps = makeMockDeps(capture, {
@@ -1084,7 +1115,7 @@ test("terminal event is emitted on blocked state", async () => {
 });
 
 test("#4671: plan-v2 missing CONTEXT.md reaches dispatch recovery instead of pausing", async () => {
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-4671-predispatch-"));
+  const basePath = makeTestBase("gsd-4671-predispatch-");
   mkdirSync(join(basePath, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
   openDatabase(join(basePath, ".gsd", "gsd.db"));
   try {
@@ -1141,7 +1172,7 @@ test("#4671: plan-v2 missing CONTEXT.md reaches dispatch recovery instead of pau
 });
 
 test("plan-v2 empty graph rederives state before pausing", async () => {
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-plan-v2-empty-graph-"));
+  const basePath = makeTestBase("gsd-plan-v2-empty-graph-");
   mkdirSync(join(basePath, ".gsd", "milestones", "M001"), { recursive: true });
   writeFileSync(
     join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
@@ -1204,7 +1235,7 @@ test("plan-v2 empty graph rederives state before pausing", async () => {
 });
 
 test("plan-v2 empty graph pauses after one failed rederive", async () => {
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-plan-v2-empty-graph-pause-"));
+  const basePath = makeTestBase("gsd-plan-v2-empty-graph-pause-");
   mkdirSync(join(basePath, ".gsd", "milestones", "M001"), { recursive: true });
   writeFileSync(
     join(basePath, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
@@ -1394,7 +1425,7 @@ test("session-failed cancellations close out and emit unit-end before hard stop"
 test("runFinalize pauses and emits unit-end when pre-verification times out", async () => {
   const capture = createEventCapture();
   let pauseCalls = 0;
-  const basePath = mkdtempSync(join(tmpdir(), "gsd-finalize-timeout-"));
+  const basePath = makeTestBase("gsd-finalize-timeout-");
 
   const deps = makeMockDeps(capture, {
     pauseAuto: async () => { pauseCalls++; },