gsd-pi 2.82.0 → 3.0.0-dev.2e8b124f7

package/src/resources/extensions/gsd/tests/slice-parallel-orchestrator.test.ts

@@ -3,7 +3,7 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync, spawn } from "node:child_process";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -12,8 +12,12 @@ import { validatePreferences } from "../preferences-validation.ts";
 import {
   _buildSliceWorkerEnvForTest,
   _resolveSliceParallelMaxWorkersForTest,
+  getSliceOrchestratorState,
   restoreSliceState,
+  resetSliceOrchestrator,
   SLICE_WORKER_AUTO_ARGS,
+  startSliceParallel,
+  stopSliceParallel,
 } from "../slice-parallel-orchestrator.ts";
 
 function readLinuxProcessStartFingerprint(pid: number): string | null {
@@ -50,6 +54,23 @@ function makeTempProject(): string {
   return basePath;
 }
 
+function runGit(basePath: string, args: string[]): string {
+  return execFileSync("git", args, {
+    cwd: basePath,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function initGitProject(basePath: string): void {
+  runGit(basePath, ["init", "--initial-branch=main"]);
+  runGit(basePath, ["config", "user.email", "test@example.com"]);
+  runGit(basePath, ["config", "user.name", "Test User"]);
+  writeFileSync(join(basePath, "README.md"), "initial\n", "utf-8");
+  runGit(basePath, ["add", "README.md"]);
+  runGit(basePath, ["commit", "-m", "initial"]);
+}
+
 function writeSliceOrchestratorState(
   basePath: string,
   worker: {
@@ -111,6 +132,56 @@ describe("slice worker launch contract", () => {
   });
 });
 
+describe("slice-parallel stale worktree handling", () => {
+  it("replaces a stale slice worktree before spawning the worker", async () => {
+    const basePath = makeTempProject();
+    const oldGsdBinPath = process.env.GSD_BIN_PATH;
+    try {
+      initGitProject(basePath);
+      const workerBin = join(basePath, "fake-worker.js");
+      writeFileSync(
+        workerBin,
+        [
+          "process.on('SIGTERM', () => process.exit(0));",
+          "setInterval(() => {}, 1000);",
+        ].join("\n"),
+        "utf-8",
+      );
+      process.env.GSD_BIN_PATH = workerBin;
+
+      const staleWorktree = join(basePath, ".gsd", "worktrees", "M900-S01");
+      mkdirSync(staleWorktree, { recursive: true });
+      writeFileSync(join(staleWorktree, ".git"), "gitdir: /tmp/not-this-repo\n", "utf-8");
+      writeFileSync(join(staleWorktree, "stale-marker"), "stale\n", "utf-8");
+
+      const result = await startSliceParallel(basePath, "M900", [{ id: "S01" }], { maxWorkers: 1 });
+
+      assert.deepEqual(result, { started: ["S01"], errors: [] });
+      assert.equal(existsSync(join(staleWorktree, "stale-marker")), false);
+      assert.equal(lstatSync(join(staleWorktree, ".git")).isFile(), true);
+      assert.match(readFileSync(join(staleWorktree, ".git"), "utf-8"), /^gitdir: /);
+      assert.equal(getSliceOrchestratorState()?.active, true);
+    } finally {
+      const child = getSliceOrchestratorState()?.workers.get("S01")?.process;
+      if (child && child.exitCode === null) {
+        await new Promise<void>((resolve) => {
+          const timeout = setTimeout(resolve, 500);
+          child.once("exit", () => {
+            clearTimeout(timeout);
+            resolve();
+          });
+          child.kill("SIGTERM");
+        });
+      }
+      stopSliceParallel();
+      resetSliceOrchestrator();
+      if (oldGsdBinPath === undefined) delete process.env.GSD_BIN_PATH;
+      else process.env.GSD_BIN_PATH = oldGsdBinPath;
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+});
+
 describe("slice-parallel-orchestrator recovery identity", () => {
   it("rejects a live PID when the process start fingerprint does not match", () => {
     const basePath = makeTempProject();

package/src/resources/extensions/gsd/tests/smart-entry-routing.test.ts

@@ -0,0 +1,113 @@
+// GSD-2 — Smart entry routing behavior tests.
+// Verifies guided wizard choices resolve to the correct execution path.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  resolveActiveTaskChoiceRoute,
+  resolveGuidedExecuteLaunchMode,
+  type ActiveTaskChoice,
+  type ActiveTaskRoute,
+  type SmartEntryIsolationMode,
+} from "../smart-entry-routing.ts";
+
+test("guided execute route enters auto step bootstrap only for worktree isolation", () => {
+  const cases: Array<{
+    isolationMode: SmartEntryIsolationMode;
+    expectedRoute: ActiveTaskRoute;
+  }> = [
+    {
+      isolationMode: "worktree",
+      expectedRoute: {
+        kind: "auto-bootstrap",
+        verboseMode: false,
+        options: {
+          step: true,
+          milestoneLock: "M001",
+        },
+      },
+    },
+    {
+      isolationMode: "none",
+      expectedRoute: {
+        kind: "guided-dispatch",
+        unitType: "execute-task",
+      },
+    },
+    {
+      isolationMode: "branch",
+      expectedRoute: {
+        kind: "guided-dispatch",
+        unitType: "execute-task",
+      },
+    },
+  ];
+
+  for (const testCase of cases) {
+    assert.deepEqual(
+      resolveActiveTaskChoiceRoute({
+        choice: "execute",
+        isolationMode: testCase.isolationMode,
+        milestoneId: "M001",
+      }),
+      testCase.expectedRoute,
+    );
+  }
+});
+
+test("active task smart entry choices resolve to explicit routes", () => {
+  const cases: Array<{
+    choice: ActiveTaskChoice;
+    expectedRoute: ActiveTaskRoute;
+  }> = [
+    {
+      choice: "auto",
+      expectedRoute: {
+        kind: "auto-bootstrap",
+        verboseMode: false,
+      },
+    },
+    {
+      choice: "status",
+      expectedRoute: {
+        kind: "status",
+      },
+    },
+    {
+      choice: "milestone_actions",
+      expectedRoute: {
+        kind: "milestone-actions",
+      },
+    },
+  ];
+
+  for (const testCase of cases) {
+    assert.deepEqual(
+      resolveActiveTaskChoiceRoute({
+        choice: testCase.choice,
+        isolationMode: "worktree",
+        milestoneId: "M001",
+      }),
+      testCase.expectedRoute,
+    );
+  }
+});
+
+test("active task route rejects invalid choices from untyped callers", () => {
+  assert.throws(
+    () =>
+      resolveActiveTaskChoiceRoute({
+        choice: "not_yet" as ActiveTaskChoice,
+        isolationMode: "worktree",
+        milestoneId: "M001",
+      }),
+    /Invalid ActiveTaskChoice: not_yet/,
+  );
+});
+
+test("guided execute launch mode remains a small compatibility helper", () => {
+  assert.equal(resolveGuidedExecuteLaunchMode("worktree"), "auto-step");
+  assert.equal(resolveGuidedExecuteLaunchMode("none"), "guided-dispatch");
+  assert.equal(resolveGuidedExecuteLaunchMode("branch"), "guided-dispatch");
+});

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

@@ -4,7 +4,10 @@ import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 import { _withDetachedAutoKeepaliveForTest } from "../auto.ts";
-import { _scheduleAutoStartAfterIdleForTest } from "../guided-flow.ts";
+import {
+  _scheduleAutoStartAfterIdleForTest,
+  resolveGuidedExecuteLaunchMode,
+} from "../guided-flow.ts";
 
 const gsdDir = resolve(import.meta.dirname, "..");
 
@@ -64,6 +67,24 @@ test("bare /gsd stays in the foreground smart-entry flow (#5125 regression)", ()
   );
 });
 
+test("guided execute uses auto step bootstrap when worktree isolation is enabled", () => {
+  assert.equal(
+    resolveGuidedExecuteLaunchMode("worktree"),
+    "auto-step",
+    "guided execute must enter auto bootstrap so the milestone worktree is created before execution",
+  );
+  assert.equal(
+    resolveGuidedExecuteLaunchMode("none"),
+    "guided-dispatch",
+    "non-isolated projects can keep the foreground guided dispatch path",
+  );
+  assert.equal(
+    resolveGuidedExecuteLaunchMode("branch"),
+    "guided-dispatch",
+    "this regression fix is scoped to worktree isolation",
+  );
+});
+
 test("auto bootstrap validates blocked directories before touching .gsd migration state", () => {
   const autoSrc = readGsdFile("auto.ts");
   const autoStartSrc = readGsdFile("auto-start.ts");
@@ -99,19 +120,49 @@ test("auto bootstrap validates blocked directories before touching .gsd migratio
 
 test("fresh start registers the auto worker before bootstrap enters worktree flow (#5405)", () => {
   const autoSrc = readGsdFile("auto.ts");
+  const autoStartSrc = readGsdFile("auto-start.ts");
   const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
   const startAutoBody = autoSrc.slice(startAutoIdx);
+  const bootstrapIdx = autoStartSrc.indexOf("export async function bootstrapAutoSession(");
+  const bootstrapBody = autoStartSrc.slice(bootstrapIdx);
 
-  const preBootstrapRegisterIdx = startAutoBody.indexOf("registerAutoWorkerForSession(s, base);");
   const bootstrapCallIdx = startAutoBody.indexOf("const ready = await bootstrapAutoSession(");
+  const preBootstrapBody = startAutoBody.slice(0, bootstrapCallIdx);
+  const preBootstrapRegisterIdx = preBootstrapBody.lastIndexOf("registerAutoWorkerForSession(s, base);");
+  const resumeSectionIdx = startAutoBody.indexOf("if (s.paused) {");
+  const freshStartSectionIdx = startAutoBody.indexOf("// ── Fresh start path — delegated to auto-start.ts ──");
+  const resumeBody = startAutoBody.slice(resumeSectionIdx, freshStartSectionIdx);
+  const resumeDbOpenIdx = resumeBody.indexOf("await openProjectDbIfPresent(base);");
+  const resumeRegisterIdx = resumeBody.indexOf("registerAutoWorkerForSession(s, base);");
+  const resumeEnterMilestoneIdx = resumeBody.indexOf("buildLifecycle().enterMilestone");
+  const dbOpenIdx = bootstrapBody.indexOf("await openProjectDbIfPresent(base);");
+  const bootstrapRegisterIdx = bootstrapBody.indexOf("registerAutoWorkerForSession(base);");
+  const enterMilestoneIdx = bootstrapBody.indexOf("buildLifecycle().enterMilestone");
 
   assert.ok(startAutoIdx > -1, "startAuto should exist");
   assert.ok(preBootstrapRegisterIdx > -1, "startAuto should register worker before bootstrap");
   assert.ok(bootstrapCallIdx > -1, "startAuto should call bootstrapAutoSession");
+  assert.ok(resumeSectionIdx > -1, "startAuto should have resume milestone entry flow");
+  assert.ok(freshStartSectionIdx > resumeSectionIdx, "resume assertions should be scoped before fresh start");
+  assert.ok(resumeDbOpenIdx > -1, "resume should open DB before milestone entry");
+  assert.ok(resumeRegisterIdx > -1, "resume should register worker before milestone entry");
+  assert.ok(resumeEnterMilestoneIdx > -1, "resume should enter milestones through lifecycle");
+  assert.ok(bootstrapIdx > -1, "bootstrapAutoSession should exist");
+  assert.ok(dbOpenIdx > -1, "bootstrap should open the project DB");
+  assert.ok(bootstrapRegisterIdx > -1, "bootstrap should register worker after DB open");
+  assert.ok(enterMilestoneIdx > -1, "bootstrap should enter milestones through lifecycle");
   assert.ok(
     preBootstrapRegisterIdx < bootstrapCallIdx,
     "worker registration must happen before bootstrap so enterMilestone can claim milestone leases on first entry",
   );
+  assert.ok(
+    dbOpenIdx < bootstrapRegisterIdx && bootstrapRegisterIdx < enterMilestoneIdx,
+    "bootstrap must open DB and register worker before first enterMilestone",
+  );
+  assert.ok(
+    resumeDbOpenIdx < resumeRegisterIdx && resumeRegisterIdx < resumeEnterMilestoneIdx,
+    "resume must open DB and register worker before first enterMilestone",
+  );
 });
 
 test("startAutoDetached reports failures asynchronously (#3733)", () => {
@@ -240,3 +291,36 @@ test("discussion auto-start waits for the current command context to become idle
   assert.equal(launches[0][2], "/tmp/gsd-auto-start-idle-test");
   assert.deepEqual(launches[0][4], { step: true });
 });
+
+test("resume path only hard-exits on blocked stop, not blocked pause (#6154)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const startAutoIdx = autoSrc.indexOf("export async function startAuto(");
+  const startAutoBody = autoSrc.slice(startAutoIdx);
+  const resumeSectionIdx = startAutoBody.indexOf("if (s.paused) {");
+  const freshStartSectionIdx = startAutoBody.indexOf("// ── Fresh start path — delegated to auto-start.ts ──");
+  const resumeBody = startAutoBody.slice(resumeSectionIdx, freshStartSectionIdx);
+
+  assert.ok(startAutoIdx > -1, "startAuto should exist");
+  assert.ok(resumeSectionIdx > -1, "resume path should exist");
+  assert.ok(freshStartSectionIdx > resumeSectionIdx, "resume assertions should be scoped before fresh start");
+  assert.ok(
+    resumeBody.includes('if (resumeResult?.kind === "blocked" && resumeResult.action === "stop")'),
+    "resume path should only hard-stop blocked resume when action is stop",
+  );
+  assert.ok(
+    resumeBody.includes('if (resumeResult?.kind === "blocked")'),
+    "resume path should still notify blocked resume results",
+  );
+});
+
+test("prepareForUnit skips worktree safety when isolation is not worktree (#6154)", () => {
+  const autoSrc = readGsdFile("auto.ts");
+  const prepareForUnitIdx = autoSrc.indexOf("async prepareForUnit(unitType, unitId) {");
+  const prepareForUnitBody = autoSrc.slice(prepareForUnitIdx, autoSrc.indexOf("async syncAfterUnit() {}", prepareForUnitIdx));
+
+  assert.ok(prepareForUnitIdx > -1, "prepareForUnit should exist");
+  assert.ok(
+    prepareForUnitBody.includes('if (getIsolationMode(runtimeBasePath) !== "worktree")'),
+    "prepareForUnit should bypass worktree safety validation outside worktree isolation mode",
+  );
+});

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -271,6 +271,11 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
     // a real git fixture and verify the worktree directory is removed
     // from disk after the merge.
     const tmpBase = realpathSync(mkdtempSync(join(tmpdir(), "gsd-2945-bug3-")));
+    // ADR-016 phase 3 (#5693): Lifecycle.restoreToProjectRoot now chdirs to
+    // s.originalBasePath. Save cwd before the test so we can restore it
+    // before rmSync removes tmpBase — otherwise the next test in this file
+    // inherits a deleted cwd and process.cwd() throws ENOENT (uv_cwd).
+    const prevCwd = process.cwd();
     try {
       const git = (args: string[]): void => {
         execFileSync("git", args, { cwd: tmpBase, stdio: "pipe" });
@@ -325,6 +330,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
         `teardownAutoWorktree must be called after successful merge — worktree directory at ${wt} should be removed`,
       );
     } finally {
+      try { process.chdir(prevCwd); } catch { /* noop */ }
       try { rmSync(tmpBase, { recursive: true, force: true }); } catch { /* noop */ }
     }
   });

package/src/resources/extensions/gsd/tests/state-reconciliation-drift.test.ts

@@ -544,7 +544,7 @@ test("ADR-017 (#5703): live worker lock is not cleared", async (t) => {
 
 // ─── #5704: unregistered-milestone drift ────────────────────────────────────
 
-test("ADR-017 (#5704): unregistered-milestone drift detected and DB row inserted", async (t) => {
+test("ADR-017 (#5704): unregistered-milestone drift fails closed without importing markdown", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-projmd-"));
   const milestoneDir = join(base, ".gsd", "milestones", "M042");
   mkdirSync(milestoneDir, { recursive: true });
@@ -571,20 +571,22 @@ test("ADR-017 (#5704): unregistered-milestone drift detected and DB row inserted
   // Pre-condition: filesystem has the milestone, DB does NOT.
   assert.equal(getMilestone("M042"), null, "pre: DB has no row for M042");
 
-  const result = await reconcileBeforeDispatch(base, {
-    invalidateStateCache: () => {},
-    deriveState: async () => makeState(),
-  });
-
-  assert.equal(result.ok, true);
-  assert.ok(getMilestone("M042"), "post: DB row inserted for M042");
-  const milestoneRepaired = result.repaired.find(
-    (d) => d.kind === "unregistered-milestone",
+  await assert.rejects(
+    reconcileBeforeDispatch(base, {
+      invalidateStateCache: () => {},
+      deriveState: async () => makeState(),
+    }),
+    (err: unknown) => {
+      assert.ok(err instanceof ReconciliationFailedError);
+      assert.match(String(err.message), /unregistered-milestone/);
+      assert.equal(err.failures[0]?.drift.kind, "unregistered-milestone");
+      assert.match(String(err.failures[0]?.cause), /M042/);
+      assert.match(String(err.failures[0]?.cause), /markdown projection/);
+      assert.match(String(err.failures[0]?.cause), /recovery\/migration/);
+      return true;
+    },
   );
-  assert.ok(milestoneRepaired, "repaired list should include the unregistered-milestone drift");
-  if (milestoneRepaired?.kind === "unregistered-milestone") {
-    assert.equal(milestoneRepaired.milestoneId, "M042");
-  }
+  assert.equal(getMilestone("M042"), null, "post: DB still has no row for M042");
 });
 
 test("ADR-017 (#5704): registered milestone (DB row present) → no drift", async (t) => {
@@ -627,13 +629,14 @@ test("ADR-017 (#5704): registered milestone (DB row present) → no drift", asyn
 
 // ─── #5705: roadmap-divergence drift ─────────────────────────────────────────
 
-test("ADR-017 (#5705): roadmap-divergence drift detected and DB depends synced", async (t) => {
+test("ADR-017 (#5705): roadmap-divergence re-renders projection without syncing depends into DB", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-"));
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
   mkdirSync(milestoneDir, { recursive: true });
   // ROADMAP.md declares S02 depends on [S01]
   writeFileSync(
-    join(milestoneDir, "M001-ROADMAP.md"),
+    roadmapPath,
     [
       "# M001: Test",
       "",
@@ -665,7 +668,12 @@ test("ADR-017 (#5705): roadmap-divergence drift detected and DB depends synced",
   });
 
   assert.equal(result.ok, true);
-  assert.deepEqual(getSlice("M001", "S02")?.depends, ["S01"], "post: DB depends matches ROADMAP.md");
+  assert.deepEqual(getSlice("M001", "S02")?.depends, [], "post: DB depends remains authoritative");
+  assert.match(
+    readFileSync(roadmapPath, "utf-8"),
+    /- \[ \] \*\*S02: Feature\*\* `risk:medium` `depends:\[\]`/,
+    "post: ROADMAP projection is regenerated from DB depends",
+  );
   const roadmapRepaired = result.repaired.find((d) => d.kind === "roadmap-divergence");
   assert.ok(roadmapRepaired, "repaired list should include the roadmap-divergence drift");
   if (roadmapRepaired?.kind === "roadmap-divergence") {
@@ -673,13 +681,14 @@ test("ADR-017 (#5705): roadmap-divergence drift detected and DB depends synced",
   }
 });
 
-test("ADR-017 (#5705): ROADMAP declares slice missing from DB → slice inserted and drift reported", async (t) => {
+test("ADR-017 (#5705): ROADMAP-only slice is removed from projection and not inserted into DB", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-newslice-"));
   const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
   mkdirSync(milestoneDir, { recursive: true });
   // ROADMAP.md declares S01 and S02; DB will only have S01.
   writeFileSync(
-    join(milestoneDir, "M001-ROADMAP.md"),
+    roadmapPath,
     [
       "# M001: Test",
       "",
@@ -710,10 +719,10 @@ test("ADR-017 (#5705): ROADMAP declares slice missing from DB → slice inserted
   });
 
   assert.equal(result.ok, true);
-  const s02 = getSlice("M001", "S02");
-  assert.ok(s02, "post: S02 inserted into DB after repair");
-  assert.equal(s02?.sequence, 2, "post: S02 sequence matches ROADMAP order");
-  assert.deepEqual(s02?.depends, ["S01"], "post: S02 depends matches ROADMAP");
+  assert.equal(getSlice("M001", "S02"), null, "post: S02 still has no DB row");
+  const rendered = readFileSync(roadmapPath, "utf-8");
+  assert.match(rendered, /- \[ \] \*\*S01: Foundation\*\*/);
+  assert.doesNotMatch(rendered, /S02: Feature/, "post: ROADMAP-only S02 removed from projection");
   const roadmapRepaired = result.repaired.find((d) => d.kind === "roadmap-divergence");
   assert.ok(roadmapRepaired, "repaired list should include the roadmap-divergence drift");
   if (roadmapRepaired?.kind === "roadmap-divergence") {
@@ -721,6 +730,93 @@ test("ADR-017 (#5705): ROADMAP declares slice missing from DB → slice inserted
   }
 });
 
+test("ADR-017 (#5705): ROADMAP sequence drift re-renders from DB order without mutating DB", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-sequence-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    roadmapPath,
+    [
+      "# M001: Test",
+      "",
+      "**Vision:** Verify sequence drift",
+      "",
+      "## Slices",
+      "",
+      "- [ ] **S02: Feature** `risk:medium` `depends:[]`",
+      "- [ ] **S01: Foundation** `risk:medium` `depends:[]`",
+      "",
+    ].join("\n"),
+  );
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Feature", status: "pending", risk: "medium", depends: [], demo: "", sequence: 2 });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(getSlice("M001", "S01")?.sequence, 1, "post: S01 DB sequence remains authoritative");
+  assert.equal(getSlice("M001", "S02")?.sequence, 2, "post: S02 DB sequence remains authoritative");
+  const rendered = readFileSync(roadmapPath, "utf-8");
+  assert.ok(
+    rendered.indexOf("S01: Foundation") < rendered.indexOf("S02: Feature"),
+    "post: ROADMAP projection follows DB sequence",
+  );
+  assert.ok(result.repaired.some((d) => d.kind === "roadmap-divergence"));
+});
+
+test("ADR-017 (#5705): ROADMAP checkbox drift re-renders from DB status without mutating DB", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-checkbox-"));
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  const roadmapPath = join(milestoneDir, "M001-ROADMAP.md");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    roadmapPath,
+    [
+      "# M001: Test",
+      "",
+      "**Vision:** Verify checkbox drift",
+      "",
+      "## Slices",
+      "",
+      "- [x] **S01: Foundation** `risk:medium` `depends:[]`",
+      "",
+    ].join("\n"),
+  );
+  t.after(() => {
+    try { closeDatabase(); } catch { /* noop */ }
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Foundation", status: "pending", risk: "medium", depends: [], demo: "", sequence: 1 });
+
+  const result = await reconcileBeforeDispatch(base, {
+    invalidateStateCache: () => {},
+    deriveState: async () => makeState(),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(getSlice("M001", "S01")?.status, "pending", "post: DB status remains authoritative");
+  assert.match(
+    readFileSync(roadmapPath, "utf-8"),
+    /- \[ \] \*\*S01: Foundation\*\*/,
+    "post: ROADMAP checkbox reflects DB status",
+  );
+  assert.ok(result.repaired.some((d) => d.kind === "roadmap-divergence"));
+});
+
 test("ADR-017 (#5705): in-sync ROADMAP and DB → no roadmap-divergence drift", async (t) => {
   const base = mkdtempSync(join(tmpdir(), "gsd-adr017-roadmap-clean-"));
   const milestoneDir = join(base, ".gsd", "milestones", "M001");

package/src/resources/extensions/gsd/tests/status-guards.test.ts

@@ -3,7 +3,7 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { isClosedStatus } from '../status-guards.ts';
+import { isClosedStatus, isFutureMilestoneStatus } from '../status-guards.ts';
 
 test('isClosedStatus: "complete" returns true', () => {
   assert.equal(isClosedStatus('complete'), true);
@@ -17,6 +17,10 @@ test('isClosedStatus: "skipped" returns true', () => {
   assert.equal(isClosedStatus('skipped'), true);
 });
 
+test('isClosedStatus: "closed" returns true', () => {
+  assert.equal(isClosedStatus('closed'), true);
+});
+
 test('isClosedStatus: "pending" returns false', () => {
   assert.equal(isClosedStatus('pending'), false);
 });
@@ -32,3 +36,15 @@ test('isClosedStatus: "active" returns false', () => {
 test('isClosedStatus: "" (empty string) returns false', () => {
   assert.equal(isClosedStatus(''), false);
 });
+
+test('isFutureMilestoneStatus includes future milestone aliases', () => {
+  assert.equal(isFutureMilestoneStatus('pending'), true);
+  assert.equal(isFutureMilestoneStatus('queued'), true);
+  assert.equal(isFutureMilestoneStatus('planned'), true);
+});
+
+test('isFutureMilestoneStatus excludes active and closed milestones', () => {
+  assert.equal(isFutureMilestoneStatus('active'), false);
+  assert.equal(isFutureMilestoneStatus('complete'), false);
+  assert.equal(isFutureMilestoneStatus('parked'), false);
+});