gsd-pi 2.37.1 → 2.38.0-dev.4d4d14a

package/src/resources/extensions/gsd/templates/task-plan.md

@@ -42,11 +42,19 @@ estimated_files: {{estimatedFiles}}
 
 ## Inputs
 
+<!-- Every input MUST be a backtick-wrapped file path. These paths are machine-parsed to
+     derive task dependencies — vague descriptions without paths break dependency detection.
+     For the first task in a slice with no prior task outputs, list the existing source files
+     this task reads or modifies. -->
+
 - `{{filePath}}` — {{whatThisTaskNeedsFromPriorWork}}
-- {{priorTaskSummaryInsight}}
 
 ## Expected Output
 
-<!-- This task should produce a real increment toward making the slice goal/demo true. A full slice plan should not be able to mark every task complete while the claimed slice behavior still does not work at the stated proof level. -->
+<!-- Every output MUST be a backtick-wrapped file path — the specific files this task creates
+     or modifies. These paths are machine-parsed to derive task dependencies.
+     This task should produce a real increment toward making the slice goal/demo true. A full
+     slice plan should not be able to mark every task complete while the claimed slice behavior
+     still does not work at the stated proof level. -->
 
-- `{{filePath}}` — {{whatThisTaskShouldProduceOrModify}}
+- `{{filePath}}` — {{whatThisTaskCreatesOrModifies}}

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -1,9 +1,9 @@
 /**
- * agent-end-retry.test.ts — Regression checks for the post-#1419 agent_end model.
+ * agent-end-retry.test.ts — Regression checks for the agent_end model.
  *
- * The old recursive handleAgentEnd retry path is gone. The loop now keeps
- * pendingResolve + pendingAgentEndQueue on AutoSession, and handleAgentEnd is
- * only a thin compatibility wrapper around resolveAgentEnd().
+ * The per-unit one-shot resolve function lives at module level in auto-loop.ts
+ * (_currentResolve). handleAgentEnd is a thin compatibility wrapper around
+ * resolveAgentEnd().
  */
 
 import test from "node:test";
@@ -14,40 +14,43 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
+const AUTO_LOOP_TS_PATH = join(__dirname, "..", "auto-loop.ts");
 const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
 
 function getAutoTsSource(): string {
   return readFileSync(AUTO_TS_PATH, "utf-8");
 }
 
+function getAutoLoopTsSource(): string {
+  return readFileSync(AUTO_LOOP_TS_PATH, "utf-8");
+}
+
 function getSessionTsSource(): string {
   return readFileSync(SESSION_TS_PATH, "utf-8");
 }
 
-test("AutoSession declares pending agent_end queue state", () => {
-  const source = getSessionTsSource();
+test("auto-loop.ts declares _currentResolve for per-unit one-shot promises", () => {
+  const source = getAutoLoopTsSource();
   assert.ok(
-    source.includes("pendingResolve"),
-    "AutoSession must declare pendingResolve for the in-flight unit promise",
+    source.includes("_currentResolve"),
+    "auto-loop.ts must declare _currentResolve for the per-unit resolve function",
   );
   assert.ok(
-    source.includes("pendingAgentEndQueue"),
-    "AutoSession must declare pendingAgentEndQueue for between-iteration agent_end events",
+    source.includes("_sessionSwitchInFlight"),
+    "auto-loop.ts must declare _sessionSwitchInFlight guard",
   );
 });
 
-test("AutoSession reset clears pending agent_end queue state", () => {
+test("AutoSession no longer holds promise state (moved to auto-loop.ts module scope)", () => {
   const source = getSessionTsSource();
-  const resetIdx = source.indexOf("reset(): void");
-  assert.ok(resetIdx > -1, "AutoSession must have a reset() method");
-  const resetBlock = source.slice(resetIdx, resetIdx + 4000);
+  // Properties should NOT exist as class fields
   assert.ok(
-    resetBlock.includes("this.pendingResolve = null"),
-    "reset() must clear pendingResolve",
+    !source.includes("pendingResolve:"),
+    "AutoSession must not declare pendingResolve (moved to auto-loop.ts)",
   );
   assert.ok(
-    resetBlock.includes("this.pendingAgentEndQueue = []"),
-    "reset() must clear pendingAgentEndQueue",
+    !source.includes("pendingAgentEndQueue:"),
+    "AutoSession must not declare pendingAgentEndQueue (removed — events are dropped)",
   );
 });
 

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

@@ -37,9 +37,6 @@ function makeMockSession(opts?: {
   const session = {
     active: true,
     verbose: false,
-    sessionSwitchInFlight: false,
-    pendingResolve: null,
-    pendingAgentEndQueue: [],
     cmdCtx: {
       newSession: () => {
         opts?.onNewSessionStart?.(session);
@@ -96,7 +93,6 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession();
-  _setActiveSession(s);
   const event = makeEvent();
 
   // Start runUnit — it will create the promise and send a message,
@@ -108,7 +104,6 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
     "task",
     "T01",
     "do stuff",
-    undefined,
   );
 
   // Give the microtask queue a tick so runUnit reaches the await
@@ -122,44 +117,35 @@ test("resolveAgentEnd resolves a pending runUnit promise", async () => {
   assert.deepEqual(result.event, event);
 });
 
-test("resolveAgentEnd queues event when no promise is pending", () => {
+test("resolveAgentEnd drops event when no promise is pending", () => {
   _resetPendingResolve();
-  const s = makeMockSession();
-  _setActiveSession(s);
 
-  // Should not throw — queues the event for the next runUnit
+  // Should not throw — event is dropped (logged as warning)
   assert.doesNotThrow(() => {
     resolveAgentEnd(makeEvent());
   });
-  assert.equal(s.pendingAgentEndQueue.length, 1, "event should be queued");
 });
 
-test("double resolveAgentEnd only resolves once (second is queued)", async () => {
+test("double resolveAgentEnd only resolves once (second is dropped)", async () => {
   _resetPendingResolve();
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession();
-  _setActiveSession(s);
   const event1 = makeEvent([{ id: 1 }]);
   const event2 = makeEvent([{ id: 2 }]);
 
-  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   await new Promise((r) => setTimeout(r, 10));
 
   // First resolve — should work
   resolveAgentEnd(event1);
 
-  // Second resolve — should be queued (no pending promise)
+  // Second resolve — should be dropped (no pending resolver)
   assert.doesNotThrow(() => {
     resolveAgentEnd(event2);
   });
-  assert.equal(
-    s.pendingAgentEndQueue.length,
-    1,
-    "second event should be queued",
-  );
 
   const result = await resultPromise;
   assert.equal(result.status, "completed");
@@ -174,7 +160,7 @@ test("runUnit returns cancelled when session creation fails", async () => {
   const pi = makeMockPi();
   const s = makeMockSession({ newSessionThrows: "connection refused" });
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(result.event, undefined);
@@ -190,7 +176,7 @@ test("runUnit returns cancelled when session creation times out", async () => {
   // Session returns cancelled: true (simulates the timeout race outcome)
   const s = makeMockSession({ newSessionResult: { cancelled: true } });
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(result.event, undefined);
@@ -205,35 +191,31 @@ test("runUnit returns cancelled when s.active is false before sendMessage", asyn
   const s = makeMockSession();
   s.active = false;
 
-  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const result = await runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   assert.equal(result.status, "cancelled");
   assert.equal(pi.calls.length, 0);
 });
 
-test("runUnit only arms pendingResolve after newSession completes", async () => {
+test("runUnit only arms resolve after newSession completes", async () => {
   _resetPendingResolve();
 
   let sawSwitchFlag = false;
-  let sawPendingResolve: unknown = "unset";
 
   const ctx = makeMockCtx();
   const pi = makeMockPi();
   const s = makeMockSession({
     newSessionDelayMs: 20,
-    onNewSessionStart: (session) => {
-      sawSwitchFlag = session.sessionSwitchInFlight;
-      sawPendingResolve = session.pendingResolve;
+    onNewSessionStart: () => {
+      sawSwitchFlag = isSessionSwitchInFlight();
     },
   });
-  _setActiveSession(s);
 
-  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt", undefined);
+  const resultPromise = runUnit(ctx, pi, s, "task", "T01", "prompt");
 
   await new Promise((r) => setTimeout(r, 30));
 
   assert.equal(sawSwitchFlag, true, "session switch guard should be active during newSession");
-  assert.equal(sawPendingResolve, null, "pendingResolve should not be armed before newSession completes");
   assert.equal(isSessionSwitchInFlight(), false, "session switch guard should clear after newSession settles");
 
   resolveAgentEnd(makeEvent());
@@ -275,24 +257,23 @@ test("auto-loop.ts contains a while keyword", () => {
   );
 });
 
-test("auto-loop.ts one-shot pattern: pendingResolve is nulled before calling resolver", () => {
+test("auto-loop.ts one-shot pattern: _currentResolve is nulled before calling resolver", () => {
   const src = readFileSync(
     resolve(import.meta.dirname, "..", "auto-loop.ts"),
     "utf-8",
   );
   // The one-shot pattern requires: save ref, null the variable, then call
-  // Look for the pattern: s.pendingResolve = null appearing before r(
   const resolveBlock = src.slice(
     src.indexOf("export function resolveAgentEnd"),
     src.indexOf("export function resolveAgentEnd") + 600,
   );
-  const nullIdx = resolveBlock.indexOf("pendingResolve = null");
+  const nullIdx = resolveBlock.indexOf("_currentResolve = null");
   const callIdx = resolveBlock.indexOf("r({");
-  assert.ok(nullIdx > 0, "should null pendingResolve in resolveAgentEnd");
+  assert.ok(nullIdx > 0, "should null _currentResolve in resolveAgentEnd");
   assert.ok(callIdx > 0, "should call resolver in resolveAgentEnd");
   assert.ok(
     nullIdx < callIdx,
-    "pendingResolve should be nulled before calling the resolver (one-shot)",
+    "_currentResolve should be nulled before calling the resolver (one-shot)",
   );
 });
 
@@ -462,8 +443,6 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     pendingQuickTasks: [],
     sidecarQueue: [],
     autoModeStartModel: null,
-    pendingResolve: null,
-    pendingAgentEndQueue: [],
     unitDispatchCount: new Map<string, number>(),
     unitLifetimeDispatches: new Map<string, number>(),
     unitRecoveryCount: new Map<string, number>(),

package/src/resources/extensions/gsd/tests/cmux.test.ts

@@ -100,6 +100,99 @@ test("buildCmuxStatusLabel and progress prefer deepest active unit", () => {
   assert.deepEqual(buildCmuxProgress(state), { value: 0.4, label: "2/5 tasks" });
 });
 
+describe("createGridLayout", () => {
+  // Create a mock CmuxClient that tracks createSplitFrom calls
+  function makeMockClient() {
+    let nextId = 1;
+    const calls: Array<{ source: string | undefined; direction: string }> = [];
+
+    const client = {
+      calls,
+      async createGridLayout(count: number) {
+        // Simulate the grid layout logic with a fake client
+        if (count <= 0) return [];
+        const surfaces: string[] = [];
+
+        const createSplitFrom = async (source: string | undefined, direction: string) => {
+          calls.push({ source, direction });
+          return `surface-${nextId++}`;
+        };
+
+        const rightCol = await createSplitFrom("gsd-surface", "right");
+        surfaces.push(rightCol);
+        if (count === 1) return surfaces;
+
+        const bottomRight = await createSplitFrom(rightCol, "down");
+        surfaces.push(bottomRight);
+        if (count === 2) return surfaces;
+
+        const bottomLeft = await createSplitFrom("gsd-surface", "down");
+        surfaces.push(bottomLeft);
+        if (count === 3) return surfaces;
+
+        let lastSurface = bottomRight;
+        for (let i = 3; i < count; i++) {
+          const next = await createSplitFrom(lastSurface, "down");
+          surfaces.push(next);
+          lastSurface = next;
+        }
+
+        return surfaces;
+      },
+    };
+    return client;
+  }
+
+  test("1 agent creates single right split", async () => {
+    const mock = makeMockClient();
+    const surfaces = await mock.createGridLayout(1);
+    assert.equal(surfaces.length, 1);
+    assert.deepEqual(mock.calls, [
+      { source: "gsd-surface", direction: "right" },
+    ]);
+  });
+
+  test("2 agents creates right column then splits it down", async () => {
+    const mock = makeMockClient();
+    const surfaces = await mock.createGridLayout(2);
+    assert.equal(surfaces.length, 2);
+    assert.deepEqual(mock.calls, [
+      { source: "gsd-surface", direction: "right" },
+      { source: "surface-1", direction: "down" },
+    ]);
+  });
+
+  test("3 agents creates 2x2 grid (gsd + 3 agent surfaces)", async () => {
+    const mock = makeMockClient();
+    const surfaces = await mock.createGridLayout(3);
+    assert.equal(surfaces.length, 3);
+    assert.deepEqual(mock.calls, [
+      { source: "gsd-surface", direction: "right" },
+      { source: "surface-1", direction: "down" },
+      { source: "gsd-surface", direction: "down" },
+    ]);
+  });
+
+  test("4 agents creates 2x2 grid with extra split", async () => {
+    const mock = makeMockClient();
+    const surfaces = await mock.createGridLayout(4);
+    assert.equal(surfaces.length, 4);
+    assert.deepEqual(mock.calls, [
+      { source: "gsd-surface", direction: "right" },
+      { source: "surface-1", direction: "down" },
+      { source: "gsd-surface", direction: "down" },
+      { source: "surface-2", direction: "down" },
+    ]);
+  });
+
+  test("0 agents returns empty", async () => {
+    const mock = makeMockClient();
+    const surfaces = await mock.createGridLayout(0);
+    assert.equal(surfaces.length, 0);
+    assert.equal(mock.calls.length, 0);
+  });
+});
+
 describe("cmux extension discovery opt-out", () => {
   test("cmux directory has package.json with pi manifest to prevent auto-discovery as extension", () => {
     const cmuxDir = path.resolve(

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

@@ -0,0 +1,266 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { runGSDDoctor } from "../doctor.js";
+import { formatDoctorReportJson } from "../doctor-format.js";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function makeBase(): { base: string; gsd: string; mDir: string } {
+  const base = mkdtempSync(join(tmpdir(), "gsd-doctor-enh-"));
+  const gsd = join(base, ".gsd");
+  const mDir = join(gsd, "milestones", "M001");
+  mkdirSync(join(mDir, "slices"), { recursive: true });
+  return { base, gsd, mDir };
+}
+
+function writeRoadmap(mDir: string, content: string): void {
+  writeFileSync(join(mDir, "M001-ROADMAP.md"), content);
+}
+
+function writeSlice(mDir: string, sliceId: string, planContent: string): string {
+  const sDir = join(mDir, "slices", sliceId);
+  const tDir = join(sDir, "tasks");
+  mkdirSync(tDir, { recursive: true });
+  writeFileSync(join(sDir, `${sliceId}-PLAN.md`), planContent);
+  return sDir;
+}
+
+async function main(): Promise<void> {
+  // ── 1. Circular dependency detection ──────────────────────────────────────
+  console.log("\n=== circular dependency detection ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Circular Test\n\n## Slices\n- [ ] **S01: Slice A** \`risk:low\` \`depends:[S02]\`\n  > After this: done\n- [ ] **S02: Slice B** \`risk:low\` \`depends:[S01]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice A\n\n**Goal:** A\n**Demo:** A\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    writeSlice(mDir, "S02", "# S02: Slice B\n\n**Goal:** B\n**Demo:** B\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "circular_slice_dependency"),
+      "detects circular dependency S01 → S02 → S01",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 2. Duplicate task IDs ──────────────────────────────────────────────────
+  console.log("\n=== duplicate task IDs ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Dup Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: First** `est:10m`\n  Task one.\n- [ ] **T01: Duplicate** `est:10m`\n  Task dup.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "duplicate_task_id"),
+      "detects duplicate task ID T01",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 3. Orphaned slice directory ──────────────────────────────────────────
+  console.log("\n=== orphaned slice directory ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Orphan Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    // Create an extra slice directory not in roadmap
+    mkdirSync(join(mDir, "slices", "S99"), { recursive: true });
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "orphaned_slice_directory" && i.message.includes("S99")),
+      "detects orphaned slice directory S99",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 4. Task file not in plan ───────────────────────────────────────────────
+  console.log("\n=== task file not in plan ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Extra Task Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    // T01 summary (matches plan)
+    writeFileSync(join(sDir, "tasks", "T01-SUMMARY.md"), "---\nstatus: done\n---\n# T01\nDone.\n");
+    // T99 summary (NOT in plan)
+    writeFileSync(join(sDir, "tasks", "T99-SUMMARY.md"), "---\nstatus: done\n---\n# T99\nExtra.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "task_file_not_in_plan" && i.message.includes("T99")),
+      "detects task summary T99 not in plan",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 5. Stale REPLAN file ────────────────────────────────────────────────────
+  console.log("\n=== stale REPLAN detection ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Replan Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    writeFileSync(join(sDir, "tasks", "T01-SUMMARY.md"), "---\nstatus: done\ncompleted_at: 2026-01-01T00:00:00Z\n---\n# T01\nDone.\n");
+    // Add a REPLAN file even though all tasks are done
+    writeFileSync(join(sDir, "S01-REPLAN.md"), "# S01 REPLAN\nSomething changed.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "stale_replan_file"),
+      "detects stale REPLAN when all tasks are done",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 6. Metrics ledger corrupt ───────────────────────────────────────────────
+  console.log("\n=== metrics ledger corrupt ===");
+  {
+    const { base, gsd, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Metrics Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    // Write invalid metrics.json
+    writeFileSync(join(gsd, "metrics.json"), '{"version":2,"data":[]}');
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "metrics_ledger_corrupt"),
+      "detects corrupt metrics ledger (version != 1)",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 7. Large planning file ──────────────────────────────────────────────────
+  console.log("\n=== large planning file ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Large File Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+    // Write a 101KB .md file
+    const bigContent = "# Big File\n" + "x".repeat(101 * 1024);
+    writeFileSync(join(sDir, "BIGFILE.md"), bigContent);
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "large_planning_file"),
+      "detects large planning file over 100KB",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 8. Future timestamp ─────────────────────────────────────────────────────
+  console.log("\n=== future timestamp ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Timestamp Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+    // completed_at is 2 days in the future
+    const futureDate = new Date(Date.now() + 2 * 24 * 60 * 60 * 1000).toISOString();
+    writeFileSync(
+      join(sDir, "tasks", "T01-SUMMARY.md"),
+      `---\nstatus: done\ncompleted_at: ${futureDate}\n---\n# T01\nDone.\n`,
+    );
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(
+      result.issues.some(i => i.code === "future_timestamp"),
+      "detects future completed_at timestamp",
+    );
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 9. JSON output format ───────────────────────────────────────────────────
+  console.log("\n=== JSON output format ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: JSON Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    const json = formatDoctorReportJson(result);
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      parsed = null;
+    }
+
+    assertTrue(parsed !== null, "formatDoctorReportJson produces valid JSON");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.ok === "boolean", "JSON has ok field");
+    assertTrue(Array.isArray((parsed as Record<string, unknown>)?.issues), "JSON has issues array");
+    assertTrue(Array.isArray((parsed as Record<string, unknown>)?.fixesApplied), "JSON has fixesApplied array");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.generatedAt === "string", "JSON has generatedAt field");
+    assertTrue(typeof (parsed as Record<string, unknown>)?.summary === "object", "JSON has summary object");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 10. Dry-run mode ────────────────────────────────────────────────────────
+  console.log("\n=== dry-run mode ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Dry Run Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    const sDir = writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [x] **T01: Task** `est:10m`\n  Done.\n");
+
+    const result = await runGSDDoctor(base, { fix: true, dryRun: true });
+    // In dry-run mode, no actual files should be created
+    assertTrue(!existsSync(join(sDir, "S01-SUMMARY.md")), "dry-run does not create slice summary");
+    assertTrue(
+      result.fixesApplied.some(f => f.startsWith("[dry-run]")),
+      "dry-run mode reports would-fix entries",
+    );
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 11. Per-check timing ─────────────────────────────────────────────────────
+  console.log("\n=== per-check timing ===");
+  {
+    const { base, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: Timing Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    const result = await runGSDDoctor(base, { fix: false });
+    assertTrue(result.timing !== undefined, "report includes timing");
+    assertTrue(typeof result.timing?.git === "number", "timing.git is a number");
+    assertTrue(typeof result.timing?.runtime === "number", "timing.runtime is a number");
+    assertTrue(typeof result.timing?.environment === "number", "timing.environment is a number");
+    assertTrue(typeof result.timing?.gsdState === "number", "timing.gsdState is a number");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  // ── 12. Doctor history ───────────────────────────────────────────────────────
+  console.log("\n=== doctor history ===");
+  {
+    const { base, gsd, mDir } = makeBase();
+    writeRoadmap(mDir, `# M001: History Test\n\n## Slices\n- [ ] **S01: Slice** \`risk:low\` \`depends:[]\`\n  > After this: done\n`);
+    writeSlice(mDir, "S01", "# S01: Slice\n\n**Goal:** G\n**Demo:** D\n\n## Tasks\n- [ ] **T01: Task** `est:10m`\n  Pending.\n");
+
+    await runGSDDoctor(base, { fix: false });
+
+    const historyPath = join(gsd, "doctor-history.jsonl");
+    assertTrue(existsSync(historyPath), "doctor-history.jsonl is created after run");
+
+    const { readDoctorHistory } = await import("../doctor.js");
+    const history = await readDoctorHistory(base);
+    assertTrue(history.length >= 1, "history has at least one entry");
+    assertTrue(typeof history[0]?.ts === "string", "history entry has ts field");
+    assertTrue(typeof history[0]?.ok === "boolean", "history entry has ok field");
+    assertTrue(typeof history[0]?.errors === "number", "history entry has errors count");
+    assertTrue(Array.isArray(history[0]?.codes), "history entry has codes array");
+
+    rmSync(base, { recursive: true, force: true });
+  }
+
+  report();
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});