gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

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

@@ -1,398 +0,0 @@
-/**
- * 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/dist/resources/extensions/gsd/tests/diff-context.test.ts

@@ -1,136 +0,0 @@
-/**
- * Unit tests for diff-context.ts — diff-aware context module.
- * Tests git-based file discovery and relevance ranking.
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { tmpdir } from "node:os";
-import { mkdtempSync } from "node:fs";
-import { join } from "node:path";
-
-import {
-  getRecentlyChangedFiles,
-  getChangedFilesWithContext,
-  rankFilesByRelevance,
-} from "../diff-context.js";
-
-// ─── getRecentlyChangedFiles ────────────────────────────────────────────────
-
-describe("diff-context: getRecentlyChangedFiles", () => {
-  it("returns an array of file paths in the current git repo", async () => {
-    // Use the project root — guaranteed to be a git repo
-    const cwd = process.cwd();
-    const files = await getRecentlyChangedFiles(cwd);
-
-    assert.ok(Array.isArray(files), "should return an array");
-    // The result may be empty if the repo is totally clean with no recent
-    // commits, but the function should not throw.
-  });
-
-  it("respects maxFiles option", async () => {
-    const cwd = process.cwd();
-    const files = await getRecentlyChangedFiles(cwd, { maxFiles: 3 });
-
-    assert.ok(files.length <= 3, "should not exceed maxFiles");
-  });
-
-  it("returns empty array for non-git directory", async () => {
-    const tmp = mkdtempSync(join(tmpdir(), "diff-ctx-test-"));
-    const files = await getRecentlyChangedFiles(tmp);
-
-    assert.deepStrictEqual(files, [], "should return empty array for non-git dir");
-  });
-
-  it("returns deduplicated paths", async () => {
-    const cwd = process.cwd();
-    const files = await getRecentlyChangedFiles(cwd, { maxFiles: 100 });
-    const unique = new Set(files);
-
-    assert.equal(files.length, unique.size, "should have no duplicates");
-  });
-});
-
-// ─── getChangedFilesWithContext ─────────────────────────────────────────────
-
-describe("diff-context: getChangedFilesWithContext", () => {
-  it("returns array of ChangedFileInfo objects", async () => {
-    const cwd = process.cwd();
-    const infos = await getChangedFilesWithContext(cwd);
-
-    assert.ok(Array.isArray(infos), "should return an array");
-
-    for (const info of infos) {
-      assert.ok(typeof info.path === "string", "path should be a string");
-      assert.ok(
-        ["modified", "added", "deleted", "staged"].includes(info.changeType),
-        `changeType should be valid, got: ${info.changeType}`,
-      );
-      if (info.linesChanged !== undefined) {
-        assert.ok(typeof info.linesChanged === "number", "linesChanged should be a number");
-      }
-    }
-  });
-
-  it("returns empty array for non-git directory", async () => {
-    const tmp = mkdtempSync(join(tmpdir(), "diff-ctx-test2-"));
-    const infos = await getChangedFilesWithContext(tmp);
-
-    assert.deepStrictEqual(infos, [], "should return empty array for non-git dir");
-  });
-});
-
-// ─── rankFilesByRelevance ───────────────────────────────────────────────────
-
-describe("diff-context: rankFilesByRelevance", () => {
-  it("places changed files before unchanged files", () => {
-    const allFiles = ["a.ts", "b.ts", "c.ts", "d.ts"];
-    const changed = ["c.ts", "a.ts"];
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    // Changed files come first, sorted by changedFiles priority (c before a)
-    assert.equal(ranked[0], "c.ts");
-    assert.equal(ranked[1], "a.ts");
-    // Unchanged files follow in original order
-    assert.equal(ranked[2], "b.ts");
-    assert.equal(ranked[3], "d.ts");
-  });
-
-  it("preserves order of changed files based on changedFiles priority", () => {
-    const allFiles = ["x.ts", "y.ts", "z.ts", "w.ts"];
-    const changed = ["z.ts", "x.ts"]; // z has higher priority (index 0)
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    assert.equal(ranked[0], "z.ts", "z.ts should be first (higher priority in changedFiles)");
-    assert.equal(ranked[1], "x.ts", "x.ts should be second");
-  });
-
-  it("returns unchanged files in original order when no changed files match", () => {
-    const allFiles = ["a.ts", "b.ts", "c.ts"];
-    const changed = ["x.ts", "y.ts"]; // none match
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    assert.deepStrictEqual(ranked, ["a.ts", "b.ts", "c.ts"]);
-  });
-
-  it("handles empty inputs gracefully", () => {
-    assert.deepStrictEqual(rankFilesByRelevance([], []), []);
-    assert.deepStrictEqual(rankFilesByRelevance(["a.ts"], []), ["a.ts"]);
-    assert.deepStrictEqual(rankFilesByRelevance([], ["a.ts"]), []);
-  });
-
-  it("handles all files being changed", () => {
-    const allFiles = ["a.ts", "b.ts"];
-    const changed = ["b.ts", "a.ts"];
-
-    const ranked = rankFilesByRelevance(allFiles, changed);
-
-    // Both are changed, so sorted by changedFiles order: b first, then a
-    assert.equal(ranked[0], "b.ts");
-    assert.equal(ranked[1], "a.ts");
-    assert.equal(ranked.length, 2);
-  });
-});

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

@@ -1,15 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const promptPath = join(process.cwd(), "src/resources/extensions/gsd/prompts/discuss.md");
-const discussPrompt = readFileSync(promptPath, "utf-8");
-
-test("discuss prompt: resilient vision framing", () => {
-  const hardenedPattern = /Say exactly:\s*"What's the vision\?"/;
-  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/dist/resources/extensions/gsd/tests/dispatch-guard.test.ts

@@ -1,128 +0,0 @@
-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";
-
-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(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,
-    );
-  } 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");
-
-    // 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 });
-  }
-});