gsd-pi 2.28.0 → 2.29.0-dev.7612840

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

@@ -0,0 +1,398 @@
+/**
+ * Unit tests for GSD Detection — project state and ecosystem detection.
+ *
+ * Exercises the pure detection functions in detection.ts:
+ * - detectProjectState() with various folder layouts
+ * - detectV1Planning() with real and fake .planning/ dirs
+ * - detectProjectSignals() with different project types
+ * - isFirstEverLaunch() / hasGlobalSetup()
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  detectProjectState,
+  detectV1Planning,
+  detectProjectSignals,
+} from "../detection.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-detection-test-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function cleanup(dir: string): void {
+  try {
+    rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // best-effort
+  }
+}
+
+// ─── detectProjectState ─────────────────────────────────────────────────────────
+
+test("detectProjectState: empty directory returns state=none", () => {
+  const dir = makeTempDir("empty");
+  try {
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "none");
+    assert.equal(result.v1, undefined);
+    assert.equal(result.v2, undefined);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectState: directory with .gsd/milestones/M001 returns v2-gsd", () => {
+  const dir = makeTempDir("v2-gsd");
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v2-gsd");
+    assert.ok(result.v2);
+    assert.equal(result.v2!.milestoneCount, 1);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectState: directory with empty .gsd/milestones returns v2-gsd-empty", () => {
+  const dir = makeTempDir("v2-empty");
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v2-gsd-empty");
+    assert.ok(result.v2);
+    assert.equal(result.v2!.milestoneCount, 0);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectState: directory with .planning/ returns v1-planning", () => {
+  const dir = makeTempDir("v1-planning");
+  try {
+    mkdirSync(join(dir, ".planning", "phases", "01-setup"), { recursive: true });
+    writeFileSync(join(dir, ".planning", "ROADMAP.md"), "# Roadmap\n", "utf-8");
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v1-planning");
+    assert.ok(result.v1);
+    assert.equal(result.v1!.hasRoadmap, true);
+    assert.equal(result.v1!.hasPhasesDir, true);
+    assert.equal(result.v1!.phaseCount, 1);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectState: v2 takes priority over v1 when both exist", () => {
+  const dir = makeTempDir("both");
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    mkdirSync(join(dir, ".planning"), { recursive: true });
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v2-gsd");
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectState: detects preferences in .gsd/", () => {
+  const dir = makeTempDir("prefs");
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "preferences.md"), "---\nversion: 1\n---\n", "utf-8");
+    const result = detectProjectState(dir);
+    assert.ok(result.v2);
+    assert.equal(result.v2!.hasPreferences, true);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+// ─── detectV1Planning ───────────────────────────────────────────────────────────
+
+test("detectV1Planning: returns null for missing .planning/", () => {
+  const dir = makeTempDir("no-v1");
+  try {
+    assert.equal(detectV1Planning(dir), null);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectV1Planning: returns null when .planning is a file", () => {
+  const dir = makeTempDir("v1-file");
+  try {
+    writeFileSync(join(dir, ".planning"), "not a directory", "utf-8");
+    assert.equal(detectV1Planning(dir), null);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectV1Planning: detects phases directory with multiple phases", () => {
+  const dir = makeTempDir("v1-phases");
+  try {
+    mkdirSync(join(dir, ".planning", "phases", "01-setup"), { recursive: true });
+    mkdirSync(join(dir, ".planning", "phases", "02-core"), { recursive: true });
+    mkdirSync(join(dir, ".planning", "phases", "03-deploy"), { recursive: true });
+    const result = detectV1Planning(dir);
+    assert.ok(result);
+    assert.equal(result!.phaseCount, 3);
+    assert.equal(result!.hasPhasesDir, true);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectV1Planning: detects ROADMAP.md", () => {
+  const dir = makeTempDir("v1-roadmap");
+  try {
+    mkdirSync(join(dir, ".planning"), { recursive: true });
+    writeFileSync(join(dir, ".planning", "ROADMAP.md"), "# Roadmap", "utf-8");
+    const result = detectV1Planning(dir);
+    assert.ok(result);
+    assert.equal(result!.hasRoadmap, true);
+    assert.equal(result!.hasPhasesDir, false);
+    assert.equal(result!.phaseCount, 0);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+// ─── detectProjectSignals ───────────────────────────────────────────────────────
+
+test("detectProjectSignals: empty directory", () => {
+  const dir = makeTempDir("signals-empty");
+  try {
+    const signals = detectProjectSignals(dir);
+    assert.deepEqual(signals.detectedFiles, []);
+    assert.equal(signals.isGitRepo, false);
+    assert.equal(signals.isMonorepo, false);
+    assert.equal(signals.primaryLanguage, undefined);
+    assert.equal(signals.hasCI, false);
+    assert.equal(signals.hasTests, false);
+    assert.deepEqual(signals.verificationCommands, []);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: Node.js project", () => {
+  const dir = makeTempDir("signals-node");
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "test-project",
+        scripts: {
+          test: "jest",
+          build: "tsc",
+          lint: "eslint .",
+        },
+      }),
+      "utf-8",
+    );
+    writeFileSync(join(dir, "package-lock.json"), "{}", "utf-8");
+    mkdirSync(join(dir, ".git"), { recursive: true });
+
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("package.json"));
+    assert.equal(signals.primaryLanguage, "javascript/typescript");
+    assert.equal(signals.isGitRepo, true);
+    assert.equal(signals.packageManager, "npm");
+    assert.ok(signals.verificationCommands.includes("npm test"));
+    assert.ok(signals.verificationCommands.some(c => c.includes("build")));
+    assert.ok(signals.verificationCommands.some(c => c.includes("lint")));
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: Rust project", () => {
+  const dir = makeTempDir("signals-rust");
+  try {
+    writeFileSync(join(dir, "Cargo.toml"), '[package]\nname = "test"\n', "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("Cargo.toml"));
+    assert.equal(signals.primaryLanguage, "rust");
+    assert.ok(signals.verificationCommands.includes("cargo test"));
+    assert.ok(signals.verificationCommands.includes("cargo clippy"));
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: Go project", () => {
+  const dir = makeTempDir("signals-go");
+  try {
+    writeFileSync(join(dir, "go.mod"), "module example.com/test\n", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("go.mod"));
+    assert.equal(signals.primaryLanguage, "go");
+    assert.ok(signals.verificationCommands.includes("go test ./..."));
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: Python project", () => {
+  const dir = makeTempDir("signals-python");
+  try {
+    writeFileSync(join(dir, "pyproject.toml"), "[tool.poetry]\n", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("pyproject.toml"));
+    assert.equal(signals.primaryLanguage, "python");
+    assert.ok(signals.verificationCommands.includes("pytest"));
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: monorepo detection via workspaces", () => {
+  const dir = makeTempDir("signals-monorepo");
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({ name: "mono", workspaces: ["packages/*"] }),
+      "utf-8",
+    );
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.isMonorepo, true);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: monorepo detection via turbo.json", () => {
+  const dir = makeTempDir("signals-turbo");
+  try {
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "test" }), "utf-8");
+    writeFileSync(join(dir, "turbo.json"), "{}", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.isMonorepo, true);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: CI detection", () => {
+  const dir = makeTempDir("signals-ci");
+  try {
+    mkdirSync(join(dir, ".github", "workflows"), { recursive: true });
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.hasCI, true);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: test detection via jest config", () => {
+  const dir = makeTempDir("signals-tests");
+  try {
+    writeFileSync(join(dir, "jest.config.ts"), "export default {}", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.hasTests, true);
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: package manager detection", () => {
+  const dir1 = makeTempDir("pm-pnpm");
+  const dir2 = makeTempDir("pm-yarn");
+  const dir3 = makeTempDir("pm-bun");
+  try {
+    writeFileSync(join(dir1, "pnpm-lock.yaml"), "", "utf-8");
+    writeFileSync(join(dir1, "package.json"), "{}", "utf-8");
+    assert.equal(detectProjectSignals(dir1).packageManager, "pnpm");
+
+    writeFileSync(join(dir2, "yarn.lock"), "", "utf-8");
+    writeFileSync(join(dir2, "package.json"), "{}", "utf-8");
+    assert.equal(detectProjectSignals(dir2).packageManager, "yarn");
+
+    writeFileSync(join(dir3, "bun.lockb"), "", "utf-8");
+    writeFileSync(join(dir3, "package.json"), "{}", "utf-8");
+    assert.equal(detectProjectSignals(dir3).packageManager, "bun");
+  } finally {
+    cleanup(dir1);
+    cleanup(dir2);
+    cleanup(dir3);
+  }
+});
+
+test("detectProjectSignals: skips default npm test script", () => {
+  const dir = makeTempDir("signals-default-test");
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "test",
+        scripts: { test: 'echo "Error: no test specified" && exit 1' },
+      }),
+      "utf-8",
+    );
+    const signals = detectProjectSignals(dir);
+    // Should NOT include the default npm test script
+    assert.equal(
+      signals.verificationCommands.some(c => c.includes("test")),
+      false,
+    );
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: pnpm uses pnpm commands", () => {
+  const dir = makeTempDir("signals-pnpm-cmds");
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "test",
+        scripts: { test: "vitest", build: "tsc" },
+      }),
+      "utf-8",
+    );
+    writeFileSync(join(dir, "pnpm-lock.yaml"), "", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.verificationCommands.includes("pnpm test"));
+    assert.ok(signals.verificationCommands.includes("pnpm run build"));
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: Ruby project with rspec", () => {
+  const dir = makeTempDir("signals-ruby");
+  try {
+    writeFileSync(join(dir, "Gemfile"), 'source "https://rubygems.org"\n', "utf-8");
+    mkdirSync(join(dir, "spec"), { recursive: true });
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("Gemfile"));
+    assert.equal(signals.primaryLanguage, "ruby");
+    assert.ok(signals.verificationCommands.includes("bundle exec rspec"));
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("detectProjectSignals: Makefile with test target", () => {
+  const dir = makeTempDir("signals-make");
+  try {
+    writeFileSync(join(dir, "Makefile"), "test:\n\tgo test ./...\n\nbuild:\n\tgo build\n", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("Makefile"));
+    assert.ok(signals.verificationCommands.includes("make test"));
+  } finally {
+    cleanup(dir);
+  }
+});

package/src/resources/extensions/gsd/tests/discuss-prompt.test.ts

@@ -1,27 +1,15 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { createTestContext } from './test-helpers.ts';
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 
-const { assertTrue, report } = createTestContext();
-const promptPath = join(process.cwd(), 'src/resources/extensions/gsd/prompts/discuss.md');
-const discussPrompt = readFileSync(promptPath, 'utf-8');
+const promptPath = join(process.cwd(), "src/resources/extensions/gsd/prompts/discuss.md");
+const discussPrompt = readFileSync(promptPath, "utf-8");
 
-console.log('\n=== discuss prompt: resilient vision framing ===');
-{
+test("discuss prompt: resilient vision framing", () => {
   const hardenedPattern = /Say exactly:\s*"What's the vision\?"/;
-  assertTrue(!hardenedPattern.test(discussPrompt), 'prompt no longer uses exact-verbosity lock');
-  assertTrue(
-    discussPrompt.includes('Ask: "What\'s the vision?" once'),
-    'prompt asks for vision exactly once',
-  );
-  assertTrue(
-    discussPrompt.includes('Special handling'),
-    'prompt documents special handling for non-vision user messages',
-  );
-  assertTrue(
-    discussPrompt.includes('instead of repeating "What\'s the vision?"'),
-    'prompt forbids repeating the vision question',
-  );
-}
-
-report();
+  assert.ok(!hardenedPattern.test(discussPrompt), "prompt no longer uses exact-verbosity lock");
+  assert.ok(discussPrompt.includes('Ask: "What\'s the vision?" once'), "prompt asks for vision exactly once");
+  assert.ok(discussPrompt.includes("Special handling"), "prompt documents special handling");
+  assert.ok(discussPrompt.includes('instead of repeating "What\'s the vision?"'), "prompt forbids repeating");
+});

package/src/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 });
+  }
+});