gsd-pi 2.54.0 → 2.56.0-dev.603f970

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-loop.test.ts

@@ -79,11 +79,17 @@ function makeMockCtx() {
  */
 function makeMockPi() {
   const calls: unknown[] = [];
+  const setModelCalls: unknown[] = [];
   return {
     sendMessage: (...args: unknown[]) => {
       calls.push(args);
     },
+    setModel: async (...args: unknown[]) => {
+      setModelCalls.push(args);
+      return true;
+    },
     calls,
+    setModelCalls,
   } as any;
 }
 
@@ -227,6 +233,38 @@ test("runUnit only arms resolve after newSession completes", async () => {
   assert.equal(pi.calls.length, 1);
 });
 
+test("runUnit re-applies the selected unit model after newSession before dispatch", async () => {
+  _resetPendingResolve();
+
+  const callOrder: string[] = [];
+  const ctx = makeMockCtx();
+  const pi = makeMockPi();
+  pi.setModel = async (...args: unknown[]) => {
+    callOrder.push("setModel");
+    pi.setModelCalls.push(args);
+    return true;
+  };
+  pi.sendMessage = (...args: unknown[]) => {
+    callOrder.push("sendMessage");
+    pi.calls.push(args);
+  };
+
+  const s = makeMockSession();
+  s.currentUnitModel = { provider: "anthropic", id: "claude-opus-4-6" };
+
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
+
+  await new Promise((r) => setTimeout(r, 10));
+  resolveAgentEnd(makeEvent());
+
+  const result = await resultPromise;
+  assert.equal(result.status, "completed");
+  assert.deepEqual(callOrder, ["setModel", "sendMessage"]);
+  assert.equal(pi.setModelCalls.length, 1);
+  assert.deepEqual(pi.setModelCalls[0][0], s.currentUnitModel);
+  assert.equal(pi.calls.length, 1);
+});
+
 // ─── Structural assertions ───────────────────────────────────────────────────
 
 test("auto-loop.ts exports autoLoop, runUnit, resolveAgentEnd", async () => {
@@ -372,7 +410,7 @@ function makeMockDeps(
     captureAvailableSkills: () => {},
     ensurePreconditions: () => {},
     updateSliceProgressCache: () => {},
-    selectAndApplyModel: async () => ({ routing: null }),
+    selectAndApplyModel: async () => ({ routing: null, appliedModel: null }),
     startUnitSupervision: () => {},
     getDeepDiagnostic: () => null,
     isDbAvailable: () => false,

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-cold-db-bootstrap.test.ts

@@ -0,0 +1,37 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const srcPath = join(import.meta.dirname, "..", "auto-start.ts");
+const src = readFileSync(srcPath, "utf-8");
+
+console.log("\n=== #2841: cold DB opened before initial deriveState ===");
+
+const helperIdx = src.indexOf("async function openProjectDbIfPresent");
+assertTrue(helperIdx >= 0, "auto-start.ts defines a helper for pre-derive DB open (#2841)");
+
+const helperRegion = helperIdx >= 0 ? src.slice(helperIdx, helperIdx + 500) : "";
+assertTrue(
+  helperRegion.includes("resolveProjectRootDbPath(basePath)"),
+  "pre-derive DB helper resolves the project-root DB path (#2841)",
+);
+assertTrue(
+  helperRegion.includes("openDatabase(gsdDbPath)"),
+  "pre-derive DB helper opens the resolved DB path (#2841)",
+);
+
+const firstDeriveIdx = src.indexOf("let state = await deriveState(base);");
+assertTrue(firstDeriveIdx > 0, "auto-start.ts has the initial deriveState(base) call");
+
+const preDeriveRegion = firstDeriveIdx > 0 ? src.slice(0, firstDeriveIdx) : "";
+const preDeriveOpenIdx = preDeriveRegion.lastIndexOf("await openProjectDbIfPresent(base);");
+
+assertTrue(
+  preDeriveOpenIdx > 0,
+  "bootstrapAutoSession opens the DB before the first deriveState(base) call (#2841)",
+);
+
+report();

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/custom-engine-loop-integration.test.ts

@@ -200,7 +200,7 @@ function makeMockDeps(overrides?: Partial<LoopDeps>): LoopDeps & { callLog: stri
     captureAvailableSkills: () => {},
     ensurePreconditions: () => {},
     updateSliceProgressCache: () => {},
-    selectAndApplyModel: async () => ({ routing: null }),
+    selectAndApplyModel: async () => ({ routing: null, appliedModel: null }),
     resolveModelId: () => undefined,
     startUnitSupervision: () => {},
     getDeepDiagnostic: () => null,

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");

package/src/resources/extensions/gsd/tests/{e2e-workflow-pipeline-integration.test.ts → integration/e2e-workflow-pipeline-integration.test.ts}

@@ -34,11 +34,11 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { stringify, parse } from "yaml";
 
-import { CustomWorkflowEngine } from "../custom-workflow-engine.ts";
-import { CustomExecutionPolicy } from "../custom-execution-policy.ts";
-import { createRun, listRuns } from "../run-manager.ts";
-import { readGraph, writeGraph } from "../graph.ts";
-import { validateDefinition } from "../definition-loader.ts";
+import { CustomWorkflowEngine } from "../../custom-workflow-engine.ts";
+import { CustomExecutionPolicy } from "../../custom-execution-policy.ts";
+import { createRun, listRuns } from "../../run-manager.ts";
+import { readGraph, writeGraph } from "../../graph.ts";
+import { validateDefinition } from "../../definition-loader.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────