gsd-pi 2.54.0-dev.e1efc1a → 2.55.0-dev.9ec7cdf

package/src/resources/extensions/gsd/parallel-orchestrator.ts

@@ -21,7 +21,7 @@ import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath } from "./worktree-manager.js";
-import { autoWorktreeBranch, runWorktreePostCreateHook } from "./auto-worktree.js";
+import { autoWorktreeBranch, runWorktreePostCreateHook, syncGsdStateToWorktree } from "./auto-worktree.js";
 import { nativeBranchExists } from "./native-git-bridge.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { resolveParallelConfig } from "./preferences.js";
@@ -507,6 +507,11 @@ function createMilestoneWorktree(basePath: string, milestoneId: string): string
   // Run post-create hook if configured
   runWorktreePostCreateHook(basePath, info.path);
 
+  // Copy .gsd/ planning artifacts (milestones, CONTEXT, ROADMAP, etc.) from the
+  // project root into the worktree. Without this, workers for newly-planned
+  // milestones can't find their roadmap and exit immediately (#2184 Bug 4).
+  syncGsdStateToWorktree(basePath, info.path);
+
   return info.path;
 }
 

package/src/resources/extensions/gsd/session-lock.ts

@@ -83,10 +83,31 @@ let _lockAcquiredAt: number = 0;
 
 const LOCK_FILE = "auto.lock";
 
+/**
+ * Derive the effective lock file name for the current process.
+ * In parallel worker mode (GSD_PARALLEL_WORKER + GSD_MILESTONE_LOCK),
+ * each worker uses a per-milestone lock file (`auto-<milestoneId>.lock`)
+ * to avoid contending on the shared `.gsd/auto.lock` (#2184).
+ */
+export function effectiveLockFile(): string {
+  const mid = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_MILESTONE_LOCK : null;
+  return mid ? `auto-${mid}.lock` : LOCK_FILE;
+}
+
+/**
+ * Derive the OS-level lock target directory for the current process.
+ * In parallel worker mode, uses `.gsd/parallel/<milestoneId>/` instead of
+ * `.gsd/` so workers don't contend on the same proper-lockfile directory (#2184).
+ */
+export function effectiveLockTarget(gsdDir: string): string {
+  const mid = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_MILESTONE_LOCK : null;
+  return mid ? join(gsdDir, "parallel", mid) : gsdDir;
+}
+
 function lockPath(basePath: string): string {
   // If we have a snapshotted path from acquisition, use it for consistency
   if (_snapshotLockPath) return _snapshotLockPath;
-  return join(gsdRoot(basePath), LOCK_FILE);
+  return join(gsdRoot(basePath), effectiveLockFile());
 }
 
 // ─── Stray Lock Cleanup ─────────────────────────────────────────────────────
@@ -265,14 +286,16 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
   }
 
   const gsdDir = gsdRoot(basePath);
+  const lockTarget = effectiveLockTarget(gsdDir);
 
   try {
-    // Try to acquire an exclusive OS-level lock on the lock file.
-    // We lock the directory (gsdRoot) since proper-lockfile works best
-    // on directories, and the lock file itself may not exist yet.
-    mkdirSync(gsdDir, { recursive: true });
+    // Try to acquire an exclusive OS-level lock on the lock target.
+    // We lock a directory since proper-lockfile works best on directories,
+    // and the lock file itself may not exist yet.
+    // In parallel worker mode, lockTarget is .gsd/parallel/<MID>/ (#2184).
+    mkdirSync(lockTarget, { recursive: true });
 
-    const release = lockfile.lockSync(gsdDir, {
+    const release = lockfile.lockSync(lockTarget, {
       realpath: false,
       stale: 1_800_000, // 30 minutes — safe for laptop sleep / long event loop stalls
       update: 10_000, // Update lock mtime every 10s to prove liveness
@@ -283,7 +306,7 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
 
     // Safety net: clean up lock dir on process exit if _releaseFunction
     // wasn't called (e.g., normal exit after clean completion) (#1245).
-    ensureExitHandler(gsdDir);
+    ensureExitHandler(lockTarget);
 
     // Write the informational lock data
     atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
@@ -298,12 +321,12 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     // If no lock file or no alive process, try to clean up and re-acquire (#1245)
     if (!existingData || (existingPid && !isPidAlive(existingPid))) {
       try {
-        const lockDir = join(gsdDir + ".lock");
+        const lockDir = join(lockTarget + ".lock");
         if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
         if (existsSync(lp)) unlinkSync(lp);
 
         // Retry acquisition after cleanup
-        const release = lockfile.lockSync(gsdDir, {
+        const release = lockfile.lockSync(lockTarget, {
           realpath: false,
           stale: 1_800_000, // 30 minutes — match primary lock settings
           update: 10_000,
@@ -312,7 +335,7 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
         assignLockState(basePath, release, lp);
 
         // Safety net — uses centralized handler to avoid double-registration
-        ensureExitHandler(gsdDir);
+        ensureExitHandler(lockTarget);
 
         atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
         return { acquired: true };
@@ -483,13 +506,24 @@ export function releaseSessionLock(basePath: string): void {
     // Non-fatal
   }
 
-  // Remove the proper-lockfile directory (.gsd.lock/) for the current path
+  // Remove the proper-lockfile directory for the current lock target.
+  // In parallel worker mode, this is .gsd/parallel/<MID>.lock/ (#2184).
+  const gsdDir = gsdRoot(basePath);
+  const lockTarget = effectiveLockTarget(gsdDir);
   try {
-    const lockDir = join(gsdRoot(basePath) + ".lock");
+    const lockDir = join(lockTarget + ".lock");
     if (existsSync(lockDir)) rmSync(lockDir, { recursive: true, force: true });
   } catch {
     // Non-fatal
   }
+  // Also clean the per-milestone parallel directory itself if it exists
+  if (lockTarget !== gsdDir) {
+    try {
+      if (existsSync(lockTarget)) rmSync(lockTarget, { recursive: true, force: true });
+    } catch {
+      // Non-fatal
+    }
+  }
 
   // Clean ALL registered lock paths (#1578) — lock files accumulate across
   // main project .gsd/, worktree .gsd/, and projects registry paths.

package/src/resources/extensions/gsd/skill-health.ts

@@ -13,7 +13,7 @@
  * research identified as critical for skill quality.
  */
 
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import type { UnitMetrics, MetricsLedger } from "./metrics.js";
@@ -210,7 +210,7 @@ export function formatSkillDetail(basePath: string, skillName: string): string {
   // Check for SKILL.md existence
   const skillPath = join(homedir(), ".agents", "skills", skillName, "SKILL.md");
   if (existsSync(skillPath)) {
-    const stat = require("node:fs").statSync(skillPath);
+    const stat = statSync(skillPath);
     lines.push("");
     lines.push(`SKILL.md: ${skillPath}`);
     lines.push(`Last modified: ${stat.mtime.toISOString().slice(0, 10)}`);

package/src/resources/extensions/gsd/tests/auto-model-selection.test.ts

@@ -0,0 +1,139 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { resolvePreferredModelConfig } from "../auto-model-selection.js";
+
+function makeTempDir(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+test("resolvePreferredModelConfig synthesizes heavy routing ceiling when models section is absent", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: claude-haiku-4-5",
+        "    standard: claude-sonnet-4-6",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig("plan-slice", {
+      provider: "anthropic",
+      id: "claude-sonnet-4-6",
+    });
+
+    assert.deepEqual(config, {
+      primary: "claude-opus-4-6",
+      fallbacks: [],
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
+test("resolvePreferredModelConfig falls back to auto start model when heavy tier is absent", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    light: claude-haiku-4-5",
+        "    standard: claude-sonnet-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig("execute-task", {
+      provider: "openai",
+      id: "gpt-5.4",
+    });
+
+    assert.deepEqual(config, {
+      primary: "openai/gpt-5.4",
+      fallbacks: [],
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});
+
+test("resolvePreferredModelConfig keeps explicit phase models as the ceiling", () => {
+  const originalCwd = process.cwd();
+  const originalGsdHome = process.env.GSD_HOME;
+  const tempProject = makeTempDir("gsd-routing-project-");
+  const tempGsdHome = makeTempDir("gsd-routing-home-");
+
+  try {
+    mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(tempProject, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "models:",
+        "  planning: claude-sonnet-4-6",
+        "dynamic_routing:",
+        "  enabled: true",
+        "  tier_models:",
+        "    heavy: claude-opus-4-6",
+        "---",
+      ].join("\n"),
+      "utf-8",
+    );
+    process.env.GSD_HOME = tempGsdHome;
+    process.chdir(tempProject);
+
+    const config = resolvePreferredModelConfig("plan-slice", {
+      provider: "anthropic",
+      id: "claude-opus-4-6",
+    });
+
+    assert.deepEqual(config, {
+      primary: "claude-sonnet-4-6",
+      fallbacks: [],
+    });
+  } finally {
+    process.chdir(originalCwd);
+    if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = originalGsdHome;
+    rmSync(tempProject, { recursive: true, force: true });
+    rmSync(tempGsdHome, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/auto-start-model-capture.test.ts

@@ -0,0 +1,28 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const sourcePath = join(import.meta.dirname, "..", "auto-start.ts");
+const source = readFileSync(sourcePath, "utf-8");
+
+test("bootstrapAutoSession snapshots ctx.model before guided-flow entry (#2829)", () => {
+  const snapshotIdx = source.indexOf("const startModelSnapshot = ctx.model");
+  assert.ok(snapshotIdx > -1, "auto-start.ts should snapshot ctx.model at bootstrap start");
+
+  const firstDiscussIdx = source.indexOf('await showSmartEntry(ctx, pi, base, { step: requestedStepMode });');
+  assert.ok(firstDiscussIdx > -1, "auto-start.ts should route through showSmartEntry during guided flow");
+
+  assert.ok(
+    snapshotIdx < firstDiscussIdx,
+    "auto-start.ts must capture the start model before guided-flow can mutate ctx.model",
+  );
+});
+
+test("bootstrapAutoSession restores autoModeStartModel from the early snapshot (#2829)", () => {
+  const assignmentIdx = source.indexOf("s.autoModeStartModel = {");
+  assert.ok(assignmentIdx > -1, "auto-start.ts should assign autoModeStartModel");
+
+  const snapshotRefIdx = source.indexOf("provider: startModelSnapshot.provider", assignmentIdx);
+  assert.ok(snapshotRefIdx > -1, "autoModeStartModel should be restored from startModelSnapshot");
+});

package/src/resources/extensions/gsd/tests/{all-milestones-complete-merge.test.ts → integration/all-milestones-complete-merge.test.ts}

@@ -31,7 +31,7 @@ import {
   isInAutoWorktree,
   getAutoWorktreeOriginalBase,
   mergeMilestoneToMain,
-} from "../auto-worktree.ts";
+} from "../../auto-worktree.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -78,9 +78,9 @@ function createMilestoneArtifacts(dir: string, mid: string): void {
 // ─── Source-level: verify the merge code exists in the "all complete" path ────
 
 test("auto-loop 'all milestones complete' path merges before stopping (#962)", () => {
-  const loopSrc = readFileSync(join(__dirname, "..", "auto", "phases.ts"), "utf-8");
+  const loopSrc = readFileSync(join(__dirname, "../..", "auto", "phases.ts"), "utf-8");
   const resolverSrc = readFileSync(
-    join(__dirname, "..", "worktree-resolver.ts"),
+    join(__dirname, "../..", "worktree-resolver.ts"),
     "utf-8",
   );
 

package/src/resources/extensions/gsd/tests/{atomic-task-closeout.test.ts → integration/atomic-task-closeout.test.ts}

@@ -9,7 +9,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
-import { runGSDDoctor } from "../doctor.ts";
+import { runGSDDoctor } from "../../doctor.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `atomic-closeout-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);

package/src/resources/extensions/gsd/tests/{auto-preflight.test.ts → integration/auto-preflight.test.ts}

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { runGSDDoctor, selectDoctorScope, filterDoctorIssues } from "../doctor.js";
+import { runGSDDoctor, selectDoctorScope, filterDoctorIssues } from "../../doctor.js";
 
 test("auto-preflight scopes to active milestone, ignoring historical", async (t) => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-auto-preflight-test-"));

package/src/resources/extensions/gsd/tests/{auto-recovery.test.ts → integration/auto-recovery.test.ts}

@@ -11,19 +11,19 @@ import {
   diagnoseExpectedArtifact,
   buildLoopRemediationSteps,
   hasImplementationArtifacts,
-} from "../auto-recovery.ts";
-import { parseRoadmap, parsePlan } from "../parsers-legacy.ts";
-import { parseTaskPlanFile, clearParseCache } from "../files.ts";
-import { invalidateAllCaches } from "../cache.ts";
-import { deriveState, invalidateStateCache } from "../state.ts";
+} from "../../auto-recovery.ts";
+import { parseRoadmap, parsePlan } from "../../parsers-legacy.ts";
+import { parseTaskPlanFile, clearParseCache } from "../../files.ts";
+import { invalidateAllCaches } from "../../cache.ts";
+import { deriveState, invalidateStateCache } from "../../state.ts";
 import {
   openDatabase,
   closeDatabase,
   insertMilestone,
   insertSlice,
   insertTask,
-} from "../gsd-db.ts";
-import { renderPlanFromDb } from "../markdown-renderer.ts";
+} from "../../gsd-db.ts";
+import { renderPlanFromDb } from "../../markdown-renderer.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-test-${randomUUID()}`);

package/src/resources/extensions/gsd/tests/{auto-secrets-gate.test.ts → integration/auto-secrets-gate.test.ts}

@@ -16,8 +16,8 @@ import assert from 'node:assert/strict';
 import { mkdirSync, writeFileSync, readFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { getManifestStatus } from '../files.ts';
-import { collectSecretsFromManifest } from '../../get-secrets-from-user.ts';
+import { getManifestStatus } from '../../files.ts';
+import { collectSecretsFromManifest } from '../../../get-secrets-from-user.ts';
 
 function makeTempDir(prefix: string): string {
   const dir = join(tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);

package/src/resources/extensions/gsd/tests/{auto-stash-merge.test.ts → integration/auto-stash-merge.test.ts}

@@ -12,8 +12,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { createAutoWorktree, mergeMilestoneToMain } from "../auto-worktree.ts";
-import { nativeMergeSquash } from "../native-git-bridge.ts";
+import { createAutoWorktree, mergeMilestoneToMain } from "../../auto-worktree.ts";
+import { nativeMergeSquash } from "../../native-git-bridge.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -88,7 +88,7 @@ test("#2151 bug 1: auto-stash unblocks merge when unrelated files are dirty", ()
 });
 
 test("#2151 bug 2: nativeMergeSquash returns dirty filenames", async () => {
-  const { nativeMergeSquash } = await import("../native-git-bridge.ts");
+  const { nativeMergeSquash } = await import("../../native-git-bridge.ts");
   const repo = createTempRepo();
   try {
     run("git checkout -b milestone/M210", repo);

package/src/resources/extensions/gsd/tests/{auto-worktree-milestone-merge.test.ts → integration/auto-worktree-milestone-merge.test.ts}

@@ -21,9 +21,9 @@ import {
   createAutoWorktree,
   mergeMilestoneToMain,
   getAutoWorktreeOriginalBase,
-} from "../auto-worktree.ts";
-import { getSliceBranchName } from "../worktree.ts";
-import { nativeMergeSquash } from "../native-git-bridge.ts";
+} from "../../auto-worktree.ts";
+import { getSliceBranchName } from "../../worktree.ts";
+import { nativeMergeSquash } from "../../native-git-bridge.ts";
 
 function run(cmd: string, cwd: string): string {
   // Safe: all inputs are hardcoded test strings, not user input
@@ -329,7 +329,7 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
   });
 
   test("#1738 bug 1: nativeMergeSquash detects dirty working tree", async () => {
-    const { nativeMergeSquash } = await import("../native-git-bridge.ts");
+    const { nativeMergeSquash } = await import("../../native-git-bridge.ts");
     const repo = freshRepo();
 
     run("git checkout -b milestone/M070", repo);

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

@@ -20,7 +20,7 @@ import {
   enterAutoWorktree,
   getAutoWorktreeOriginalBase,
   getActiveAutoWorktreeContext,
-} from "../auto-worktree.ts";
+} from "../../auto-worktree.ts";
 
 // Note: execSync is used intentionally in tests for git operations with
 // controlled, hardcoded inputs (no user input). This is safe and matches
@@ -150,7 +150,7 @@ describe("auto-worktree lifecycle", () => {
     run("git commit -m \"add milestone\"", tempDir);
 
     // Import createWorktree directly for manual worktree
-    const { createWorktree } = await import("../worktree-manager.ts");
+    const { createWorktree } = await import("../../worktree-manager.ts");
 
     // Create manual worktree (uses worktree/<name> branch)
     const manualWt = createWorktree(tempDir, "feature-x");
@@ -164,7 +164,7 @@ describe("auto-worktree lifecycle", () => {
 
     // Cleanup both
     teardownAutoWorktree(tempDir, "M003");
-    const { removeWorktree } = await import("../worktree-manager.ts");
+    const { removeWorktree } = await import("../../worktree-manager.ts");
     removeWorktree(tempDir, "feature-x");
   });
 
@@ -190,7 +190,7 @@ describe("auto-worktree lifecycle", () => {
     run("git add .", tempDir);
     run("git commit -m \"add milestone\"", tempDir);
 
-    const { GitServiceImpl } = await import("../git-service.ts");
+    const { GitServiceImpl } = await import("../../git-service.ts");
 
     // Create worktree
     const wtPath = createAutoWorktree(tempDir, "M005");
@@ -215,7 +215,7 @@ describe("auto-worktree lifecycle", () => {
     run("git commit -m \"add milestone\"", tempDir);
 
     // Simulate a crash leaving a stale directory with no .git file.
-    const { worktreePath } = await import("../worktree-manager.ts");
+    const { worktreePath } = await import("../../worktree-manager.ts");
     const staleDir = worktreePath(tempDir, "M010");
     mkdirSync(staleDir, { recursive: true });
     writeFileSync(join(staleDir, "orphan.txt"), "stale leftover\n");

package/src/resources/extensions/gsd/tests/{continue-here.test.ts → integration/continue-here.test.ts}

@@ -12,7 +12,7 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 
-import { computeBudgets } from "../context-budget.js";
+import { computeBudgets } from "../../context-budget.js";
 
 // ─── Pure threshold / pipeline tests ──────────────────────────────────────────
 // These test the budget engine outputs that the continue-here monitor relies on.
@@ -164,7 +164,7 @@ describe("continue-here", () => {
   describe("continueHereFired runtime record field", () => {
     it("AutoUnitRuntimeRecord includes continueHereFired with default false", async (t) => {
       // Import writeUnitRuntimeRecord to verify the field is present and defaults
-      const { writeUnitRuntimeRecord, readUnitRuntimeRecord, clearUnitRuntimeRecord } = await import("../unit-runtime.js");
+      const { writeUnitRuntimeRecord, readUnitRuntimeRecord, clearUnitRuntimeRecord } = await import("../../unit-runtime.js");
       const fs = await import("node:fs");
       const path = await import("node:path");
       const os = await import("node:os");
@@ -202,7 +202,7 @@ describe("continue-here", () => {
 
   describe("context-pressure monitor integration", () => {
     it("should fire wrap-up when context >= threshold and mark continueHereFired", async (t) => {
-      const { writeUnitRuntimeRecord, readUnitRuntimeRecord, clearUnitRuntimeRecord } = await import("../unit-runtime.js");
+      const { writeUnitRuntimeRecord, readUnitRuntimeRecord, clearUnitRuntimeRecord } = await import("../../unit-runtime.js");
       const fs = await import("node:fs");
       const path = await import("node:path");
       const os = await import("node:os");

package/src/resources/extensions/gsd/tests/{doctor-completion-deferral.test.ts → integration/doctor-completion-deferral.test.ts}

@@ -10,7 +10,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
-import { runGSDDoctor } from "../doctor.ts";
+import { runGSDDoctor } from "../../doctor.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `doctor-deferral-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);

package/src/resources/extensions/gsd/tests/{doctor-delimiter-fix.test.ts → integration/doctor-delimiter-fix.test.ts}

@@ -10,7 +10,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { runGSDDoctor } from "../doctor.js";
+import { runGSDDoctor } from "../../doctor.js";
 
 test("doctor fix=true sanitizes em-dash in milestone title", async (t) => {
   const tmpBase = mkdtempSync(join(tmpdir(), "gsd-doctor-delim-"));

package/src/resources/extensions/gsd/tests/{doctor-enhancements.test.ts → integration/doctor-enhancements.test.ts}

@@ -4,8 +4,8 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { runGSDDoctor } from "../doctor.js";
-import { formatDoctorReportJson } from "../doctor-format.js";
+import { runGSDDoctor } from "../../doctor.js";
+import { formatDoctorReportJson } from "../../doctor-format.js";
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
 function makeBase(): { base: string; gsd: string; mDir: string } {
@@ -230,7 +230,7 @@ describe('doctor-enhancements', async () => {
     const historyPath = join(gsd, "doctor-history.jsonl");
     assert.ok(existsSync(historyPath), "doctor-history.jsonl is created after run");
 
-    const { readDoctorHistory } = await import("../doctor.js");
+    const { readDoctorHistory } = await import("../../doctor.js");
     const history = await readDoctorHistory(base);
     assert.ok(history.length >= 1, "history has at least one entry");
     assert.ok(typeof history[0]?.ts === "string", "history entry has ts field");

package/src/resources/extensions/gsd/tests/{doctor-environment-worktree.test.ts → integration/doctor-environment-worktree.test.ts}

@@ -20,7 +20,7 @@ import {
   runEnvironmentChecks,
   environmentResultsToDoctorIssues,
   checkEnvironmentHealth,
-} from "../doctor-environment.ts";
+} from "../../doctor-environment.ts";
 /** Create a directory tree with files. */
 function createDir(files: Record<string, string> = {}): string {
   const dir = mkdtempSync(join(tmpdir(), "gsd-wt-env-"));

package/src/resources/extensions/gsd/tests/{doctor-environment.test.ts → integration/doctor-environment.test.ts}

@@ -26,7 +26,7 @@ import {
   formatEnvironmentReport,
   checkEnvironmentHealth,
   type EnvironmentCheckResult,
-} from "../doctor-environment.ts";
+} from "../../doctor-environment.ts";
 function createProjectDir(files: Record<string, string> = {}): string {
   const dir = mkdtempSync(join(tmpdir(), "gsd-env-test-"));
   for (const [name, content] of Object.entries(files)) {

package/src/resources/extensions/gsd/tests/{doctor-fixlevel.test.ts → integration/doctor-fixlevel.test.ts}

@@ -14,8 +14,8 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
-import { runGSDDoctor } from "../doctor.ts";
-import { closeDatabase } from "../gsd-db.ts";
+import { runGSDDoctor } from "../../doctor.ts";
+import { closeDatabase } from "../../gsd-db.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `doctor-fixlevel-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);

package/src/resources/extensions/gsd/tests/{doctor-git.test.ts → integration/doctor-git.test.ts}

@@ -15,7 +15,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { runGSDDoctor } from "../doctor.ts";
+import { runGSDDoctor } from "../../doctor.ts";
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }

package/src/resources/extensions/gsd/tests/{doctor-proactive.test.ts → integration/doctor-proactive.test.ts}

@@ -23,7 +23,7 @@ import {
   checkHealEscalation,
   resetProactiveHealing,
   formatHealthSummary,
-} from "../doctor-proactive.ts";
+} from "../../doctor-proactive.ts";
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }

package/src/resources/extensions/gsd/tests/{doctor-roadmap-summary-atomicity.test.ts → integration/doctor-roadmap-summary-atomicity.test.ts}

@@ -12,7 +12,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import test from "node:test";
 import assert from "node:assert/strict";
-import { runGSDDoctor } from "../doctor.ts";
+import { runGSDDoctor } from "../../doctor.ts";
 
 function makeTmp(name: string): string {
   const dir = join(tmpdir(), `doctor-roadmap-summary-${name}-${Date.now()}-${Math.random().toString(36).slice(2)}`);

package/src/resources/extensions/gsd/tests/{doctor-runtime.test.ts → integration/doctor-runtime.test.ts}

@@ -14,7 +14,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
-import { runGSDDoctor } from "../doctor.ts";
+import { runGSDDoctor } from "../../doctor.ts";
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }

package/src/resources/extensions/gsd/tests/{doctor.test.ts → integration/doctor.test.ts}

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { formatDoctorReport, runGSDDoctor, summarizeDoctorIssues, filterDoctorIssues, selectDoctorScope, validateTitle } from "../doctor.js";
+import { formatDoctorReport, runGSDDoctor, summarizeDoctorIssues, filterDoctorIssues, selectDoctorScope, validateTitle } from "../../doctor.js";
 const tmpBase = mkdtempSync(join(tmpdir(), "gsd-doctor-test-"));
 const gsd = join(tmpBase, ".gsd");
 const mDir = join(gsd, "milestones", "M001");