gsd-pi 2.82.0 → 3.0.0-dev.8b8d129d7

package/src/resources/extensions/gsd/tests/decisions-stop-table-writes.test.ts

@@ -0,0 +1,348 @@
+// ADR-013 Phase 6 cutover (Stage 3) — destructive lock-in.
+//
+// After this stage, new decisions written via gsd_save_decision land ONLY in
+// the memories table. The decisions table receives no new rows; its existing
+// rows remain for backwards-compat reads until #5756 drops the table.
+//
+// Tests cover five properties:
+//   1. New saveDecisionToDb call does NOT insert into the decisions table
+//   2. The new decision DOES appear as a memory row with sourceDecisionId
+//   3. The rendered DECISIONS.md projection includes the new decision
+//   4. Pre-existing decisions-table rows are untouched
+//   5. Decision IDs are monotonic across both surfaces (max of either + 1)
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  _getAdapter,
+  closeDatabase,
+  insertDecision,
+  openDatabase,
+} from "../gsd-db.ts";
+import { saveDecisionToDb } from "../db-writer.ts";
+import {
+  getAllDecisionsFromMemories,
+  queryDecisions,
+} from "../context-store.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-decisions-stage3-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+function countDecisionRows(): number {
+  const adapter = _getAdapter();
+  if (!adapter) return 0;
+  const row = adapter
+    .prepare("SELECT COUNT(*) as n FROM decisions")
+    .get() as { n: number };
+  return row.n;
+}
+
+function seedLegacyDecision(args: {
+  id: string;
+  when_context: string;
+  scope: string;
+  decision: string;
+  choice: string;
+  rationale: string;
+  superseded_by?: string | null;
+}): void {
+  insertDecision({
+    id: args.id,
+    when_context: args.when_context,
+    scope: args.scope,
+    decision: args.decision,
+    choice: args.choice,
+    rationale: args.rationale,
+    revisable: "Yes",
+    made_by: "agent",
+    superseded_by: args.superseded_by ?? null,
+  });
+}
+
+// ─── Core invariants ────────────────────────────────────────────────────────
+
+test("saveDecisionToDb no longer writes to the decisions table", async () => {
+  const base = makeTmpBase();
+  try {
+    const before = countDecisionRows();
+    assert.equal(before, 0);
+
+    await saveDecisionToDb(
+      {
+        when_context: "M001 discuss",
+        scope: "M001",
+        decision: "Stage 3 destructive: memories-only writes",
+        choice: "Drop the upsertDecision call",
+        rationale: "Cutover step required by ADR-013 Phase 6",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    const after = countDecisionRows();
+    assert.equal(after, 0, "decisions table must remain empty after Stage 3 save");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("saveDecisionToDb writes the new decision into memories with sourceDecisionId", async () => {
+  const base = makeTmpBase();
+  try {
+    const { id } = await saveDecisionToDb(
+      {
+        when_context: "M001 discuss",
+        scope: "M001",
+        decision: "Use atomic file writes",
+        choice: "atomicWriteSync",
+        rationale: "crash-safe markdown projections",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    const fromMemories = getAllDecisionsFromMemories();
+    assert.equal(fromMemories.length, 1);
+    assert.equal(fromMemories[0]?.id, id);
+    assert.equal(fromMemories[0]?.decision, "Use atomic file writes");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("DECISIONS.md projection includes the memory-only decision", async () => {
+  const base = makeTmpBase();
+  try {
+    await saveDecisionToDb(
+      {
+        when_context: "M001 discuss",
+        scope: "M001",
+        decision: "Adopt SQLite",
+        choice: "better-sqlite3",
+        rationale: "synchronous + native",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    const md = readFileSync(join(base, ".gsd", "DECISIONS.md"), "utf-8");
+    assert.match(md, /\| D001 \|/);
+    assert.match(md, /Adopt SQLite/);
+    assert.match(md, /# Decisions Register/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Existing decisions table is preserved ──────────────────────────────────
+
+test("pre-existing decisions-table rows are untouched by Stage 3 saves", async () => {
+  const base = makeTmpBase();
+  try {
+    // Seed two legacy decisions directly into the table — simulates a
+    // pre-cutover project.
+    seedLegacyDecision({
+      id: "D001",
+      when_context: "M001 historical",
+      scope: "M001",
+      decision: "Legacy decision one",
+      choice: "A",
+      rationale: "r1",
+    });
+    seedLegacyDecision({
+      id: "D002",
+      when_context: "M001 historical",
+      scope: "M001",
+      decision: "Legacy decision two",
+      choice: "B",
+      rationale: "r2",
+    });
+    assert.equal(countDecisionRows(), 2);
+
+    // New save via the cutover path.
+    await saveDecisionToDb(
+      {
+        when_context: "M001 today",
+        scope: "M001",
+        decision: "Post-cutover decision",
+        choice: "C",
+        rationale: "r3",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+
+    // Decisions table unchanged.
+    assert.equal(countDecisionRows(), 2);
+
+    // Legacy reads still see the pre-existing rows.
+    const fromLegacy = queryDecisions();
+    assert.equal(fromLegacy.length, 2);
+    assert.deepEqual(
+      fromLegacy.map((d) => d.id).sort(),
+      ["D001", "D002"],
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Cross-surface ID monotonicity ─────────────────────────────────────────
+
+test("decision IDs are monotonic across legacy table + memory surfaces", async () => {
+  const base = makeTmpBase();
+  try {
+    // Pre-cutover project with D001..D005 in the legacy table (no memory
+    // backfill yet — simulates an upgrade that hasn't run backfill).
+    for (let i = 1; i <= 5; i++) {
+      seedLegacyDecision({
+        id: `D${String(i).padStart(3, "0")}`,
+        when_context: "historical",
+        scope: "M001",
+        decision: `Decision ${i}`,
+        choice: "x",
+        rationale: "y",
+      });
+    }
+    assert.equal(countDecisionRows(), 5);
+
+    // First Stage 3 save: must pick the next-after-table ID.
+    const a = await saveDecisionToDb(
+      {
+        when_context: "M001 today",
+        scope: "M001",
+        decision: "First post-cutover",
+        choice: "A",
+        rationale: "r",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+    assert.equal(a.id, "D006", "first cutover save must follow the legacy table max (D005 -> D006)");
+
+    // Second save: must pick the next-after-memory ID.
+    const b = await saveDecisionToDb(
+      {
+        when_context: "M001 today",
+        scope: "M001",
+        decision: "Second post-cutover",
+        choice: "B",
+        rationale: "r",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+    assert.equal(b.id, "D007", "second cutover save must follow memory max (D006 -> D007)");
+
+    // Decisions table still has only the original five.
+    assert.equal(countDecisionRows(), 5);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("next-ID falls back to D001 when both surfaces are empty", async () => {
+  const base = makeTmpBase();
+  try {
+    const { id } = await saveDecisionToDb(
+      {
+        when_context: "M001",
+        scope: "M001",
+        decision: "First ever",
+        choice: "A",
+        rationale: "r",
+        revisable: "Yes",
+        made_by: "agent",
+      },
+      base,
+    );
+    assert.equal(id, "D001");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("next-ID skips beyond memory-only entries when the legacy table is empty", async () => {
+  const base = makeTmpBase();
+  try {
+    // Three memory-only saves on a fresh project.
+    const a = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "A", choice: "1", rationale: "r", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+    const b = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "B", choice: "2", rationale: "r", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+    const c = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "C", choice: "3", rationale: "r", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+
+    assert.deepEqual([a.id, b.id, c.id], ["D001", "D002", "D003"]);
+    assert.equal(countDecisionRows(), 0, "no decisions-table writes despite three saves");
+  } finally {
+    cleanup(base);
+  }
+});
+
+// ─── Defensive: malformed structured_fields don't break next-ID ────────────
+
+test("malformed structuredFields in memories are silently skipped during next-ID computation", async () => {
+  const base = makeTmpBase();
+  try {
+    // Insert a memory with broken JSON in structured_fields. The next-ID
+    // logic must not throw.
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    adapter
+      .prepare(
+        "INSERT INTO memories (id, category, content, confidence, created_at, updated_at, structured_fields) VALUES ('mem-broken', 'architecture', 'oops', 0.5, datetime('now'), datetime('now'), '{\"sourceDecisionId\":\"D999\"')",
+      )
+      .run();
+
+    const { id } = await saveDecisionToDb(
+      { when_context: "M001", scope: "M001", decision: "Survivor", choice: "x", rationale: "y", revisable: "Yes", made_by: "agent" },
+      base,
+    );
+
+    // Broken JSON for D999 doesn't parse, so the surfaced max stays at 0.
+    // The new save must still produce a valid sequential ID.
+    assert.equal(id, "D001");
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -10,7 +10,7 @@ import { runDispatch, runPreDispatch } from "../auto/phases.ts";
 import { AutoSession } from "../auto/session.ts";
 import { resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 import { bootstrapAutoSession } from "../auto-start.ts";
-import { postUnitPreVerification } from "../auto-post-unit.ts";
+import { postUnitPostVerification, postUnitPreVerification } from "../auto-post-unit.ts";
 import { resolveDispatch, setResearchProjectPromptBuilderForTest } from "../auto-dispatch.ts";
 import { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { finalizeProjectResearchTimeout } from "../project-research-policy.ts";
@@ -272,6 +272,7 @@ test("deep project setup: bootstrap can start auto-mode without an active milest
       {
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
         lockBase: () => base,
         buildLifecycle: () => ({
           adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
@@ -386,6 +387,7 @@ test("deep project setup: bootstrap continues queued M002 without milestone cont
       {
         shouldUseWorktreeIsolation: () => false,
         registerSigtermHandler: () => {},
+        registerAutoWorkerForSession: () => {},
         lockBase: () => base,
         buildLifecycle: () => ({
           adoptSessionRoot: (sessionBase: string, originalBase?: string) => {
@@ -1587,6 +1589,63 @@ test("deep project setup: discuss-milestone question failure pauses instead of a
   }
 });
 
+test("verified task git closeout failure retries and continues auto-mode", async () => {
+  const base = makeBase();
+  try {
+    execFileSync("git", ["init"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Test User"], { cwd: base, stdio: "ignore" });
+    const hookPath = join(base, ".git", "hooks", "pre-commit");
+    writeFileSync(
+      hookPath,
+      [
+        "#!/bin/sh",
+        "count_file=.git/pre-commit-count",
+        "count=0",
+        "if [ -f \"$count_file\" ]; then count=$(cat \"$count_file\"); fi",
+        "count=$((count + 1))",
+        "printf \"%s\" \"$count\" > \"$count_file\"",
+        "echo blocked by test hook >&2",
+        "exit 1",
+      ].join("\n"),
+    );
+    chmodSync(hookPath, 0o755);
+    writeFileSync(join(base, "work.txt"), "changed\n");
+
+    const s = new AutoSession();
+    s.active = true;
+    s.basePath = base;
+    s.originalBasePath = base;
+    s.currentUnit = { type: "execute-task", id: "M001/S01/T01", startedAt: Date.now() };
+
+    let pauseCalled = false;
+    const notifications: Array<{ message: string; severity?: string }> = [];
+    const result = await postUnitPostVerification({
+      s,
+      ctx: { ui: { notify: (message: string, severity?: string) => notifications.push({ message, severity }) } } as any,
+      pi: {} as any,
+      buildSnapshotOpts: () => ({}) as any,
+      lockBase: () => base,
+      stopAuto: async () => {},
+      pauseAuto: async () => { pauseCalled = true; },
+      updateProgressWidget: () => {},
+    });
+
+    assert.equal(result, "continue");
+    assert.equal(pauseCalled, false);
+    assert.equal(s.lastGitActionStatus, "failed");
+    const preCommitCount = Number(readFileSync(join(base, ".git", "pre-commit-count"), "utf-8"));
+    assert.equal(Number.isFinite(preCommitCount), true);
+    assert.ok(preCommitCount >= 3, "git closeout should retry the failing commit path");
+    assert.ok(
+      notifications.some((entry) => entry.severity === "warning" && entry.message.includes("Git commit failed")),
+      "verified task git closeout failure should warn instead of stopping auto-mode",
+    );
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("deep project setup: approval wait wins over deterministic write-gate placeholder", async () => {
   const base = makeBase();
   try {

package/src/resources/extensions/gsd/tests/dispatch-complete-milestone-guard.test.ts

@@ -10,6 +10,7 @@ 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 { execFileSync } from "node:child_process";
 
 import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
 import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
@@ -23,6 +24,14 @@ function makeBase(): string {
   return base;
 }
 
+function initGitRepo(base: string): void {
+  execFileSync("git", ["init"], { 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" });
+  execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "initial"], { cwd: base, stdio: "ignore" });
+}
+
 function buildDispatchCtx(basePath: string): DispatchContext {
   return {
     basePath,
@@ -76,6 +85,24 @@ describe("completing-milestone dispatch guard (#4324)", () => {
     assert.equal(result?.unitType, "complete-milestone");
     assert.equal(result?.unitId, "M001");
   });
+
+  test("dispatches complete-milestone when only .gsd/ files exist in git history (#5097)", async () => {
+    base = makeBase();
+    rmSync(join(base, "implementation.txt"), { force: true });
+    initGitRepo(base);
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-SUMMARY.md"), "# Milestone Summary\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "chore: planning artifacts only"], { cwd: base, stdio: "ignore" });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+
+    const result = await rule.match(buildDispatchCtx(base));
+
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    assert.equal(result?.unitId, "M001");
+  });
 });
 
 describe("complete phase dispatch guard (#5683)", () => {
@@ -118,3 +145,42 @@ describe("complete phase dispatch guard (#5683)", () => {
     assert.equal(result?.reason, "All milestones complete.");
   });
 });
+
+describe("complete milestone context recovery guard (#5831)", () => {
+  let base = "";
+  const executionEntryRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "execution-entry phase (no context) → discuss-milestone",
+  );
+  const prePlanningRule = DISPATCH_RULES.find(
+    (candidate) => candidate.name === "pre-planning (no context) → discuss-milestone",
+  );
+  assert.ok(executionEntryRule, "execution-entry missing-context rule should exist");
+  assert.ok(prePlanningRule, "pre-planning missing-context rule should exist");
+
+  afterEach(() => {
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
+  });
+
+  test("does not discuss a complete execution-entry milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "completing-milestone";
+
+    const result = await executionEntryRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+
+  test("does not discuss a complete pre-planning milestone with no CONTEXT file", async () => {
+    base = makeBase();
+    const ctx = buildDispatchCtx(base);
+    ctx.state.registry = [{ id: "M001", title: "Milestone One", status: "complete" }];
+    ctx.state.phase = "pre-planning";
+
+    const result = await prePlanningRule.match(ctx);
+
+    assert.equal(result, null);
+  });
+});

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

@@ -3,7 +3,7 @@ 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 { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { getConsecutiveDispatchBlocker, getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
 
 /** Helper: create temp dir and open an in-dir DB for dispatch-guard tests */
@@ -47,6 +47,33 @@ test("dispatch guard blocks when prior milestone has incomplete slices", (t) =>
   );
 });
 
+test("dispatch guard skips prior DB parked or deferred milestones without marker files", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+  insertMilestone({ id: "M001", title: "Parked", status: "parked" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Incomplete", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M002", title: "Deferred", status: "deferred" });
+  insertSlice({ id: "S01", milestoneId: "M002", title: "Incomplete", status: "pending", depends: [], sequence: 1 });
+
+  insertMilestone({ id: "M003", title: "Current", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "pending", depends: [], sequence: 1 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
+
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
+    null,
+  );
+});
+
 test("dispatch guard blocks later slice in same milestone when earlier incomplete", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));
@@ -254,6 +281,46 @@ test("dispatch guard does not skip prior milestone from SUMMARY projection when
   );
 });
 
+test("consecutive dispatch guard blocks complete-milestone after repeat cap", () => {
+  // REPEAT_CAP = 2: two same-unit dispatches are allowed; the third is blocked.
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009"), null);
+  assert.match(
+    getConsecutiveDispatchBlocker(state, "completing-milestone", "complete-milestone", "M009") ?? "",
+    /same-unit repeat cap reached/,
+  );
+});
+
+test("consecutive dispatch guard resets when unit changes", () => {
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "research-slice", "M001/parallel-research"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+});
+
+test("consecutive dispatch guard resets when phase changes", () => {
+  const state = {
+    consecutiveDispatchCount: new Map<string, number>(),
+    lastDispatchedKey: null as string | null,
+    lastDispatchPhase: null as string | null,
+  };
+
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "validating-milestone", "validate-milestone", "M001"), null);
+  assert.equal(getConsecutiveDispatchBlocker(state, "completing-milestone", "validate-milestone", "M001"), null);
+});
+
 test("dispatch guard does not skip failed milestone SUMMARY without blocker prose", (t) => {
   const repo = setupRepo();
   t.after(() => teardownRepo(repo));

package/src/resources/extensions/gsd/tests/doctor-empty-worktree.test.ts

@@ -0,0 +1,65 @@
+// Project/App: GSD-2
+// File Purpose: Regression tests for doctor repair of empty milestone worktrees.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runGSDDoctor } from "../doctor.ts";
+import { createWorktree, worktreePath } from "../worktree-manager.ts";
+
+function runGit(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function makeRepo(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-empty-worktree-"));
+  runGit(["init", "-b", "main"], base);
+  runGit(["config", "user.name", "Test User"], base);
+  runGit(["config", "user.email", "test@example.com"], base);
+  writeFileSync(join(base, "package.json"), "{\"scripts\":{}}\n", "utf-8");
+  runGit(["add", "."], base);
+  runGit(["commit", "-m", "chore: init"], base);
+  return base;
+}
+
+test("doctor fix recreates an empty registered milestone worktree", async (t) => {
+  const base = makeRepo();
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  createWorktree(base, "M001", { branch: "milestone/M001" });
+  const wtPath = worktreePath(base, "M001");
+  writeFileSync(join(wtPath, "milestone-note.txt"), "worktree branch content\n", "utf-8");
+  runGit(["add", "milestone-note.txt"], wtPath);
+  runGit(["commit", "-m", "test: add milestone content"], wtPath);
+  for (const entry of readdirSync(wtPath)) {
+    if (entry === ".git") continue;
+    rmSync(join(wtPath, entry), { recursive: true, force: true });
+  }
+  assert.ok(existsSync(join(wtPath, ".git")), "test setup keeps registered worktree marker");
+  assert.equal(existsSync(join(wtPath, "package.json")), false, "test setup removes project content");
+
+  const report = await runGSDDoctor(base, {
+    fix: true,
+    fixLevel: "all",
+    isolationMode: "worktree",
+  });
+
+  assert.ok(
+    report.issues.some((issue) => issue.code === "worktree_empty_with_project_content"),
+    "doctor reports the empty worktree",
+  );
+  assert.ok(
+    report.fixesApplied.some((fix) => fix.includes("recreated empty worktree")),
+    "doctor applies the repair",
+  );
+  assert.ok(existsSync(join(wtPath, "package.json")), "worktree content is restored");
+  assert.ok(existsSync(join(wtPath, "milestone-note.txt")), "branch content is restored");
+});