gsd-pi 2.26.1-next.1 → 2.28.0-dev.346ee62

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

@@ -1,104 +1,128 @@
-// GSD Dispatch Guard Tests
-
+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 { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
-import { createTestContext } from './test-helpers.ts';
-
-const { assertEq, assertTrue, report } = createTestContext();
-
-const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-try {
-  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
-  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
-
-  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), [
-    "# M002: Previous",
-    "",
-    "## Slices",
-    "- [x] **S01: Done** `risk:low` `depends:[]`",
-    "- [ ] **S02: Pending** `risk:low` `depends:[S01]`",
-    "",
-  ].join("\n"));
-
-  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), [
-    "# M003: Current",
-    "",
-    "## Slices",
-    "- [ ] **S01: First** `risk:low` `depends:[]`",
-    "- [ ] **S02: Second** `risk:low` `depends:[S01]`",
-    "",
-  ].join("\n"));
-
-  // dispatch-guard now reads from disk, not git — no need for git init/commit
-  assertEq(
-    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
-    "Cannot dispatch plan-slice M003/S01: earlier slice M002/S02 is not complete.",
-    "blocks first slice of next milestone when prior milestone is incomplete",
-  );
-
-  // Complete M002 on disk
-  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), [
-    "# M002: Previous",
-    "",
-    "## Slices",
-    "- [x] **S01: Done** `risk:low` `depends:[]`",
-    "- [x] **S02: Done** `risk:low` `depends:[S01]`",
-    "",
-  ].join("\n"));
-
-  assertEq(
-    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
-    "Cannot dispatch execute-task M003/S02/T01: earlier slice M003/S01 is not complete.",
-    "blocks later slice in same milestone when an earlier slice is incomplete",
-  );
-
-  // Complete M003/S01 on disk
-  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), [
-    "# M003: Current",
-    "",
-    "## Slices",
-    "- [x] **S01: First** `risk:low` `depends:[]`",
-    "- [ ] **S02: Second** `risk:low` `depends:[S01]`",
-    "",
-  ].join("\n"));
-
-  assertEq(
-    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
-    null,
-    "allows dispatch when all earlier slices are complete on disk",
-  );
-
-  assertEq(
-    getPriorSliceCompletionBlocker(repo, "main", "plan-milestone", "M003"),
-    null,
-    "does not affect non-slice dispatch types",
-  );
-
-  // Verify disk-based reads work without any git repo (#530)
-  const noGitRepo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-nogit-"));
+
+test("dispatch guard blocks when prior milestone has incomplete slices", () => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  try {
+    mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
+      "# M002: Previous\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [ ] **S02: Pending** `risk:low` `depends:[S01]`\n");
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
+      "# M003: Current\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
+
+    assert.equal(
+      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
+      "Cannot dispatch plan-slice M003/S01: earlier slice M002/S02 is not complete.",
+    );
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("dispatch guard blocks later slice in same milestone when earlier incomplete", () => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
   try {
-    mkdirSync(join(noGitRepo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(noGitRepo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), [
-      "# M001: Test",
-      "",
-      "## Slices",
-      "- [x] **S01: Done** `risk:low` `depends:[]`",
-      "- [ ] **S02: Pending** `risk:low` `depends:[S01]`",
-      "",
-    ].join("\n"));
-
-    assertEq(
-      getPriorSliceCompletionBlocker(noGitRepo, "main", "plan-slice", "M001/S02"),
+    mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
+      "# M002: Previous\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [x] **S02: Done** `risk:low` `depends:[S01]`\n");
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
+      "# M003: Current\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
+
+    assert.equal(
+      getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
+      "Cannot dispatch execute-task M003/S02/T01: earlier slice M003/S01 is not complete.",
+    );
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("dispatch guard allows dispatch when all earlier slices complete", () => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+  try {
+    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
+      "# M003: Current\n\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
+
+    assert.equal(getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"), null);
+    assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-milestone", "M003"), null);
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("dispatch guard works without git repo", () => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-nogit-"));
+  try {
+    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# M001: Test\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [ ] **S02: Pending** `risk:low` `depends:[S01]`\n");
+
+    assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"), null);
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});
+
+test("dispatch guard skips parked milestones — they do not block later milestones", () => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-parked-"));
+  try {
+    // M004 is parked with incomplete slices
+    mkdirSync(join(repo, ".gsd", "milestones", "M004"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M004", "M004-ROADMAP.md"),
+      "# M004: Parked Milestone\n\n## Slices\n- [ ] **S01: Unfinished** `risk:high` `depends:[]`\n");
+    writeFileSync(join(repo, ".gsd", "milestones", "M004", "M004-PARKED.md"),
+      "---\nparked_at: 2026-03-18T09:00:00.000Z\nreason: \"Parked via /gsd park\"\n---\n\n# M004 — Parked\n");
+
+    // M010 is the target milestone
+    mkdirSync(join(repo, ".gsd", "milestones", "M010"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M010", "M010-ROADMAP.md"),
+      "# M010: Active Milestone\n\n## Slices\n- [ ] **S01: First** `risk:high` `depends:[]`\n");
+
+    // M004's incomplete S01 should NOT block M010/S01 because M004 is parked
+    assert.equal(
+      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M010/S01"),
       null,
-      "allows dispatch for S02 when S01 is complete (no git repo needed)",
     );
   } finally {
-    rmSync(noGitRepo, { recursive: true, force: true });
+    rmSync(repo, { recursive: true, force: true });
   }
-} finally {
-  rmSync(repo, { recursive: true, force: true });
-}
+});
+
+test("dispatch guard still blocks on non-parked incomplete milestones", () => {
+  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-mixed-"));
+  try {
+    // M003 is parked — should be skipped
+    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
+      "# M003: Parked\n\n## Slices\n- [ ] **S01: Unfinished** `risk:high` `depends:[]`\n");
+    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-PARKED.md"),
+      "---\nparked_at: 2026-03-18T09:00:00.000Z\nreason: \"Parked\"\n---\n");
+
+    // M005 is NOT parked and has incomplete slices — should block
+    mkdirSync(join(repo, ".gsd", "milestones", "M005"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M005", "M005-ROADMAP.md"),
+      "# M005: Active Incomplete\n\n## Slices\n- [ ] **S01: Pending** `risk:low` `depends:[]`\n");
 
-report();
+    // M010 is the target
+    mkdirSync(join(repo, ".gsd", "milestones", "M010"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "milestones", "M010", "M010-ROADMAP.md"),
+      "# M010: Target\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n");
+
+    // M005/S01 should block M010/S01 (M003 is parked, so skipped)
+    assert.equal(
+      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M010/S01"),
+      "Cannot dispatch plan-slice M010/S01: earlier slice M005/S01 is not complete.",
+    );
+  } finally {
+    rmSync(repo, { recursive: true, force: true });
+  }
+});

package/dist/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Regression test for issue #909.
+ *
+ * When S##-PLAN.md exists (causing deriveState → phase:'executing') but the
+ * individual task plan files (tasks/T01-PLAN.md, etc.) are absent, the dispatch
+ * table must recover by re-running plan-slice — NOT hard-stop.
+ *
+ * Prior behaviour: action:"stop" → infinite loop on restart.
+ * Fixed behaviour: action:"dispatch" unitType:"plan-slice".
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { resolveDispatch } from "../auto-dispatch.ts";
+import type { DispatchContext } from "../auto-dispatch.ts";
+import type { GSDState } from "../types.ts";
+
+function makeState(overrides: Partial<GSDState> = {}): GSDState {
+  return {
+    activeMilestone: { id: "M002", title: "Test Milestone" },
+    activeSlice: { id: "S03", title: "Third Slice" },
+    activeTask: { id: "T01", title: "First Task" },
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+    ...overrides,
+  };
+}
+
+function makeContext(basePath: string, stateOverrides?: Partial<GSDState>): DispatchContext {
+  return {
+    basePath,
+    mid: "M002",
+    midTitle: "Test Milestone",
+    state: makeState(stateOverrides),
+    prefs: undefined,
+  };
+}
+
+// ─── Scaffold helpers ──────────────────────────────────────────────────────
+
+function scaffoldSlicePlan(basePath: string, mid: string, sid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${sid}-PLAN.md`), [
+    `# ${sid}: Third Slice`,
+    "",
+    "## Tasks",
+    "- [ ] **T01: Do something** `est:1h`",
+    "- [ ] **T02: Do another thing** `est:30m`",
+    "",
+  ].join("\n"));
+}
+
+function scaffoldTaskPlan(basePath: string, mid: string, sid: string, tid: string): void {
+  const dir = join(basePath, ".gsd", "milestones", mid, "slices", sid, "tasks");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, `${tid}-PLAN.md`), [
+    `# ${tid}: Do something`,
+    "",
+    "## Steps",
+    "- [ ] Step 1",
+    "",
+  ].join("\n"));
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-909-"));
+  try {
+    // Slice plan exists with tasks, but tasks/ directory is empty
+    scaffoldSlicePlan(tmp, "M002", "S03");
+
+    const ctx = makeContext(tmp);
+    const result = await resolveDispatch(ctx);
+
+    assert.equal(result.action, "dispatch", "should dispatch, not stop");
+    assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
+      `unitType should be plan-slice, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+    assert.ok(result.action === "dispatch" && result.unitId === "M002/S03",
+      `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("dispatch: present task plan proceeds to execute-task normally", async () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-909-ok-"));
+  try {
+    scaffoldSlicePlan(tmp, "M002", "S03");
+    scaffoldTaskPlan(tmp, "M002", "S03", "T01");
+
+    const ctx = makeContext(tmp);
+    const result = await resolveDispatch(ctx);
+
+    assert.equal(result.action, "dispatch");
+    assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+      `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+    assert.ok(result.action === "dispatch" && result.unitId === "M002/S03/T01",
+      `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async () => {
+  // Simulate: plan-slice ran but T01-PLAN.md is still missing (e.g. agent crashed mid-write).
+  // Dispatch should still re-dispatch plan-slice, not hard-stop.
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-909-loop-"));
+  try {
+    scaffoldSlicePlan(tmp, "M002", "S03");
+
+    const ctx = makeContext(tmp);
+    const r1 = await resolveDispatch(ctx);
+    assert.equal(r1.action, "dispatch");
+    assert.ok(r1.action === "dispatch" && r1.unitType === "plan-slice");
+
+    // Still no task plan written — dispatch again
+    const r2 = await resolveDispatch(ctx);
+    assert.equal(r2.action, "dispatch");
+    assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
+      "should keep dispatching plan-slice until task plans appear");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,126 @@
+/**
+ * dispatch-stall-guard.test.ts — Verifies defensive guards against dispatch stalls (#1073).
+ *
+ * After a slice completes, dispatchNextUnit must reliably dispatch the next unit.
+ * These tests verify:
+ * 1. newSession() has timeout protection (prevents permanent hang if session creation stalls)
+ * 2. handleAgentEnd has a dispatch hang guard (catches dispatchNextUnit itself hanging)
+ * 3. Session timeout constants are exported for configurability
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const AUTO_TS_PATH = join(__dirname, "..", "auto.ts");
+const SESSION_TS_PATH = join(__dirname, "..", "auto", "session.ts");
+
+function getAutoTsSource(): string {
+  return readFileSync(AUTO_TS_PATH, "utf-8");
+}
+
+function getSessionTsSource(): string {
+  return readFileSync(SESSION_TS_PATH, "utf-8");
+}
+
+// ── Session timeout constants ───────────────────────────────────────────────
+
+test("AutoSession exports NEW_SESSION_TIMEOUT_MS constant", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    source.includes("NEW_SESSION_TIMEOUT_MS"),
+    "auto/session.ts must export NEW_SESSION_TIMEOUT_MS for newSession() timeout",
+  );
+});
+
+test("AutoSession exports DISPATCH_HANG_TIMEOUT_MS constant", () => {
+  const source = getSessionTsSource();
+  assert.ok(
+    source.includes("DISPATCH_HANG_TIMEOUT_MS"),
+    "auto/session.ts must export DISPATCH_HANG_TIMEOUT_MS for dispatch hang detection",
+  );
+});
+
+test("NEW_SESSION_TIMEOUT_MS is a reasonable value (15-120 seconds)", () => {
+  const source = getSessionTsSource();
+  const match = source.match(/NEW_SESSION_TIMEOUT_MS\s*=\s*(\d[\d_]*)/);
+  assert.ok(match, "NEW_SESSION_TIMEOUT_MS must have a numeric value");
+  const value = parseInt(match![1]!.replace(/_/g, ""), 10);
+  assert.ok(value >= 15_000 && value <= 120_000,
+    `NEW_SESSION_TIMEOUT_MS must be 15-120s, got ${value}ms`,
+  );
+});
+
+test("DISPATCH_HANG_TIMEOUT_MS is greater than NEW_SESSION_TIMEOUT_MS", () => {
+  const source = getSessionTsSource();
+  const sessionMatch = source.match(/NEW_SESSION_TIMEOUT_MS\s*=\s*(\d[\d_]*)/);
+  const dispatchMatch = source.match(/DISPATCH_HANG_TIMEOUT_MS\s*=\s*(\d[\d_]*)/);
+  assert.ok(sessionMatch && dispatchMatch, "Both timeout constants must exist");
+  const sessionTimeout = parseInt(sessionMatch![1]!.replace(/_/g, ""), 10);
+  const dispatchTimeout = parseInt(dispatchMatch![1]!.replace(/_/g, ""), 10);
+  assert.ok(dispatchTimeout > sessionTimeout,
+    `DISPATCH_HANG_TIMEOUT_MS (${dispatchTimeout}) must be > NEW_SESSION_TIMEOUT_MS (${sessionTimeout})`,
+  );
+});
+
+// ── newSession() timeout in dispatchNextUnit ─────────────────────────────────
+
+test("dispatchNextUnit wraps newSession() with Promise.race timeout", () => {
+  const source = getAutoTsSource();
+  // Search the full file — dispatchNextUnit is very large
+  assert.ok(
+    source.includes("Promise.race") && source.includes("NEW_SESSION_TIMEOUT_MS"),
+    "dispatchNextUnit must use Promise.race with NEW_SESSION_TIMEOUT_MS to timeout newSession() (#1073)",
+  );
+});
+
+test("dispatchNextUnit handles newSession() timeout gracefully", () => {
+  const source = getAutoTsSource();
+  // Must notify user when session times out
+  assert.ok(
+    source.includes("Session creation timed out") || source.includes("Session creation failed"),
+    "dispatchNextUnit must notify user when newSession() times out or fails (#1073)",
+  );
+});
+
+// ── Dispatch hang guard in handleAgentEnd ────────────────────────────────────
+
+test("handleAgentEnd has a dispatch hang guard before dispatchNextUnit", () => {
+  const source = getAutoTsSource();
+  const fnIdx = source.indexOf("export async function handleAgentEnd");
+  assert.ok(fnIdx > -1, "handleAgentEnd must exist");
+
+  // Find the section between step mode check and dispatchNextUnit call
+  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── Step Mode", fnIdx + 100));
+  assert.ok(
+    fnBlock.includes("DISPATCH_HANG_TIMEOUT_MS") || fnBlock.includes("dispatchHangGuard"),
+    "handleAgentEnd must have a dispatch hang guard before calling dispatchNextUnit (#1073)",
+  );
+});
+
+test("dispatch hang guard is cleared in finally block", () => {
+  const source = getAutoTsSource();
+  const fnIdx = source.indexOf("export async function handleAgentEnd");
+  const fnBlock = source.slice(fnIdx, source.indexOf("\n// ─── Step Mode", fnIdx + 100));
+  assert.ok(
+    fnBlock.includes("clearTimeout(dispatchHangGuard)"),
+    "dispatch hang guard must be cleared in finally block to prevent false alarms (#1073)",
+  );
+});
+
+// ── Constants are imported in auto.ts ────────────────────────────────────────
+
+test("auto.ts imports NEW_SESSION_TIMEOUT_MS and DISPATCH_HANG_TIMEOUT_MS", () => {
+  const source = getAutoTsSource();
+  assert.ok(
+    source.includes("NEW_SESSION_TIMEOUT_MS"),
+    "auto.ts must import NEW_SESSION_TIMEOUT_MS from session.ts",
+  );
+  assert.ok(
+    source.includes("DISPATCH_HANG_TIMEOUT_MS"),
+    "auto.ts must import DISPATCH_HANG_TIMEOUT_MS from session.ts",
+  );
+});

package/dist/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -10,11 +10,15 @@ export function resolve(specifier, context, nextResolve) {
     specifier = new URL("packages/pi-ai/dist/index.js", ROOT).href;
   } else if (specifier === "@gsd/pi-agent-core") {
     specifier = new URL("packages/pi-agent-core/dist/index.js", ROOT).href;
-  } 
-  // 2. Mapping .js to .ts for local imports when running tests from src/
+  }
+  // 2. Redirect packages/*/dist/ → packages/*/src/ with .js→.ts for strip-types
   else if (specifier.endsWith('.js') && (specifier.startsWith('./') || specifier.startsWith('../'))) {
     if (context.parentURL && context.parentURL.includes('/src/')) {
-      specifier = specifier.replace(/\.js$/, '.ts');
+      if (specifier.includes('/dist/')) {
+        specifier = specifier.replace('/dist/', '/src/').replace(/\.js$/, '.ts');
+      } else {
+        specifier = specifier.replace(/\.js$/, '.ts');
+      }
     }
   }
 

package/dist/resources/extensions/gsd/tests/doctor-fixlevel.test.ts

@@ -115,6 +115,81 @@ test("fixLevel:all (default) — detects AND fixes completion issues", async ()
   }
 });
 
+test("fixLevel:all — marks indented roadmap checkboxes done (#1063)", async () => {
+  const tmp = makeTmp("indented-roadmap");
+  try {
+    buildScaffold(tmp);
+
+    // Overwrite roadmap with indented checkbox (LLM formatting drift)
+    writeFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+  - [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+    > Demo text
+`);
+
+    const report = await runGSDDoctor(tmp, { fix: true });
+
+    const roadmapContent = readFileSync(join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "utf8");
+    // Should mark [x] while preserving the leading whitespace
+    assert.ok(roadmapContent.includes("  - [x] **S01"), "indented roadmap checkbox should be marked done");
+    // Verify indentation is preserved: line should start with "  -", not just "-"
+    const checkedLine = roadmapContent.split("\n").find(l => l.includes("[x] **S01"));
+    assert.ok(checkedLine?.startsWith("  -"), `should preserve leading whitespace, got: "${checkedLine}"`);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test("fixLevel:all — marks indented task checkboxes done (#1063)", async () => {
+  const tmp = makeTmp("indented-task");
+  try {
+    const gsd = join(tmp, ".gsd");
+    const m = join(gsd, "milestones", "M001");
+    const s = join(m, "slices", "S01", "tasks");
+    mkdirSync(s, { recursive: true });
+
+    writeFileSync(join(m, "M001-ROADMAP.md"), `# M001: Test
+
+## Slices
+
+- [ ] **S01: Test Slice** \`risk:low\` \`depends:[]\`
+`);
+
+    // Plan with indented checkbox
+    writeFileSync(join(m, "slices", "S01", "S01-PLAN.md"), `# S01: Test Slice
+
+**Goal:** test
+
+## Tasks
+
+  - [ ] **T01: Do stuff** \`est:5m\`
+`);
+
+    writeFileSync(join(s, "T01-SUMMARY.md"), `---
+id: T01
+parent: S01
+milestone: M001
+duration: 5m
+verification_result: passed
+completed_at: 2026-01-01
+---
+
+# T01: Do stuff
+
+Done.
+`);
+
+    const report = await runGSDDoctor(tmp, { fix: true, fixLevel: "task" });
+
+    const planContent = readFileSync(join(m, "slices", "S01", "S01-PLAN.md"), "utf8");
+    assert.ok(planContent.includes("  - [x] **T01"), "indented task checkbox should be marked done");
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
 test("fixLevel:task — still fixes task-level bookkeeping (checkbox marking)", async () => {
   const tmp = makeTmp("task-checkbox");
   try {