gsd-pi 2.82.0-dev.ed17d078d → 3.0.0-dev.04f5ccf82

package/src/resources/extensions/gsd/tests/mcp-filter.test.ts

@@ -0,0 +1,287 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { discoverMcpServerNames, computeMcpDisallowedTools } from "../mcp-filter.ts";
+import type { ClaudeCodeMcpConfig } from "../preferences-types.ts";
+
+// ─── discoverMcpServerNames ────────────────────────────────────────────────
+
+describe("discoverMcpServerNames", () => {
+  it("reads server names from .mcp.json mcpServers keys", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({ mcpServers: { "server-a": {}, "server-b": {} } }),
+    );
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result.sort(), ["server-a", "server-b"]);
+  });
+
+  it("returns [] when .mcp.json does not exist (ENOENT)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result, []);
+  });
+
+  it("returns [] when .mcp.json has no mcpServers key", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(join(dir, ".mcp.json"), JSON.stringify({ version: 1 }));
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result, []);
+  });
+
+  it("reads from both .mcp.json and .claude/settings.json, deduplicates", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({ mcpServers: { "server-a": {}, "shared": {} } }),
+    );
+    mkdirSync(join(dir, ".claude"), { recursive: true });
+    writeFileSync(
+      join(dir, ".claude", "settings.json"),
+      JSON.stringify({ mcpServers: { "server-b": {}, "shared": {} } }),
+    );
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result.sort(), ["server-a", "server-b", "shared"]);
+  });
+
+  it("handles .claude/settings.json missing gracefully", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-test-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({ mcpServers: { "only-server": {} } }),
+    );
+    const result = discoverMcpServerNames(dir);
+    assert.deepEqual(result, ["only-server"]);
+  });
+});
+
+// ─── computeMcpDisallowedTools ─────────────────────────────────────────────
+
+describe("computeMcpDisallowedTools", () => {
+  it("returns [] when mcpConfig is undefined (no filtering)", () => {
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      undefined,
+      ["server-a", "server-b"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result, []);
+  });
+
+  it("returns [] when no model prefix matches any config key", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-opus-4-7",
+      config,
+      ["server-a", "server-b"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result, []);
+  });
+
+  it("allowlist-only: blocks all discovered servers not in allowed_servers (R002)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b", "server-c"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result.sort(), ["mcp__server-b__*", "mcp__server-c__*"]);
+  });
+
+  it("blocklist-only: blocks only servers in blocked_servers (R002)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { blocked_servers: ["server-b"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b", "server-c"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result, ["mcp__server-b__*"]);
+  });
+
+  it("both lists: allowlist applies first, then blocklist removes; blocklist wins on overlap (R002)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": {
+          allowed_servers: ["server-a", "server-b"],
+          blocked_servers: ["server-b"],
+        },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b", "server-c"],
+      "gsd-workflow",
+    );
+    // server-c blocked by allowlist, server-b blocked by blocklist (wins over allowlist)
+    assert.deepEqual(result.sort(), ["mcp__server-b__*", "mcp__server-c__*"]);
+  });
+
+  it("gsd-workflow implicitly allowed even when not in allowlist (R003)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a", "server-b"],
+      "gsd-workflow",
+    );
+    assert.ok(!result.includes("mcp__gsd-workflow__*"), "gsd-workflow must not be blocked");
+    assert.deepEqual(result, ["mcp__server-b__*"]);
+  });
+
+  it("gsd-workflow blocked when explicitly in blocked_servers (R003 override)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { blocked_servers: ["gsd-workflow"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["server-a"],
+      "gsd-workflow",
+    );
+    assert.ok(result.includes("mcp__gsd-workflow__*"), "gsd-workflow must be blocked");
+  });
+
+  it("returns mcp__<name>__* pattern format for each blocked server (R006)", () => {
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { blocked_servers: ["my-server", "other-server"] },
+      },
+    };
+    const result = computeMcpDisallowedTools(
+      "claude-haiku-4-5-20251001",
+      config,
+      ["my-server", "other-server"],
+      "gsd-workflow",
+    );
+    assert.deepEqual(result.sort(), ["mcp__my-server__*", "mcp__other-server__*"]);
+  });
+});
+
+// ─── Integration: empirical tool-count reduction ───────────────────────────
+
+describe("integration: empirical tool-count reduction", () => {
+  it("disallowedTools count equals discovered minus allowed (5 servers, 1 allowed → 4 blocked)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-integration-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: {
+          "server-alpha": {},
+          "server-beta": {},
+          "server-gamma": {},
+          "server-delta": {},
+          "server-epsilon": {},
+        },
+      }),
+    );
+
+    const discovered = discoverMcpServerNames(dir);
+    assert.equal(discovered.length, 5, "fixture must have 5 servers");
+
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "test-model": { allowed_servers: ["server-alpha"] },
+      },
+    };
+
+    const disallowedTools = computeMcpDisallowedTools(
+      "test-model",
+      config,
+      discovered,
+      "gsd-workflow",
+    );
+
+    // 5 discovered - 1 allowed = 4 blocked
+    assert.equal(disallowedTools.length, 4, "4 servers must be blocked");
+
+    // The allowed server must NOT be in disallowedTools
+    assert.ok(
+      !disallowedTools.includes("mcp__server-alpha__*"),
+      "server-alpha (allowed) must not be blocked",
+    );
+
+    // Each blocked server must produce the correct pattern
+    assert.deepEqual(disallowedTools.sort(), [
+      "mcp__server-beta__*",
+      "mcp__server-delta__*",
+      "mcp__server-epsilon__*",
+      "mcp__server-gamma__*",
+    ]);
+  });
+
+  it("negative: empty .mcp.json → disallowedTools empty", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-integration-empty-"));
+    writeFileSync(join(dir, ".mcp.json"), JSON.stringify({}));
+
+    const discovered = discoverMcpServerNames(dir);
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "test-model": { allowed_servers: ["server-alpha"] },
+      },
+    };
+
+    const disallowedTools = computeMcpDisallowedTools(
+      "test-model",
+      config,
+      discovered,
+      "gsd-workflow",
+    );
+
+    assert.deepEqual(disallowedTools, [], "no servers discovered → nothing to block");
+  });
+
+  it("negative: model ID matches no per_model key → disallowedTools empty", () => {
+    const dir = mkdtempSync(join(tmpdir(), "mcp-filter-integration-nomatch-"));
+    writeFileSync(
+      join(dir, ".mcp.json"),
+      JSON.stringify({
+        mcpServers: { "server-a": {}, "server-b": {}, "server-c": {} },
+      }),
+    );
+
+    const discovered = discoverMcpServerNames(dir);
+    assert.equal(discovered.length, 3);
+
+    const config: ClaudeCodeMcpConfig = {
+      per_model: {
+        "claude-haiku": { allowed_servers: ["server-a"] },
+      },
+    };
+
+    // "gpt-4o" doesn't match "claude-haiku" prefix → no filtering
+    const disallowedTools = computeMcpDisallowedTools(
+      "gpt-4o",
+      config,
+      discovered,
+      "gsd-workflow",
+    );
+
+    assert.deepEqual(disallowedTools, [], "unmatched model must produce no blocks");
+  });
+});

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

@@ -5,6 +5,7 @@ import {
   formatMcpInitResult,
   formatMcpStatusReport,
   formatMcpServerDetail,
+  hasHostMcpTool,
   type McpServerStatus,
 } from "../commands-mcp-status.ts";
 
@@ -116,3 +117,13 @@ describe("formatMcpInitResult", () => {
     assert.match(result, /already up to date/i);
   });
 });
+
+describe("hasHostMcpTool", () => {
+  test("detects host-provided MCP tool prefix for a server", () => {
+    assert.equal(hasHostMcpTool("tools: mcp__gsd-workflow__*", "gsd-workflow"), true);
+  });
+
+  test("does not match other servers", () => {
+    assert.equal(hasHostMcpTool("tools: mcp__other-server__*", "gsd-workflow"), false);
+  });
+});

package/src/resources/extensions/gsd/tests/merge-db-cycle.test.ts

@@ -0,0 +1,179 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  chmodSync,
+  existsSync,
+  mkdtempSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+import { mergeMilestoneToMain } from "../auto-worktree.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
+import { GIT_NO_PROMPT_ENV } from "../git-constants.js";
+import { _clearGsdRootCache } from "../paths.ts";
+import { _resetServiceCache } from "../worktree.ts";
+import { worktreePath } from "../worktree-manager.ts";
+
+function git(args: string[], cwd: string): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
+  const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
+  Object.defineProperty(process, "platform", { value: platform });
+  try {
+    return fn();
+  } finally {
+    if (descriptor) {
+      Object.defineProperty(process, "platform", descriptor);
+    }
+  }
+}
+
+function realGitPath(): string {
+  const gitExecPath = execFileSync("git", ["--exec-path"], {
+    encoding: "utf-8",
+  }).trim();
+  return join(gitExecPath, process.platform === "win32" ? "git.exe" : "git");
+}
+
+function installGitShim(bin: string, probePath: string): void {
+  const shim = join(bin, "git-proxy.cjs");
+  writeFileSync(
+    shim,
+    `
+const { appendFileSync, existsSync } = require("node:fs");
+const { join } = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+const realGit = ${JSON.stringify(realGitPath())};
+const probePath = ${JSON.stringify(probePath)};
+const args = process.argv.slice(2);
+
+if (args[0] === "merge" && args[1] === "--squash") {
+  const sidecars = [
+    join(process.cwd(), ".gsd", "gsd.db-wal"),
+    join(process.cwd(), ".gsd", "gsd.db-shm"),
+  ];
+  const locked = sidecars.find((path) => existsSync(path));
+  if (locked) {
+    appendFileSync(probePath, "blocked:" + locked + "\\n");
+    console.error("error: local changes would be overwritten by merge");
+    console.error("\\t" + locked);
+    process.exit(1);
+  }
+  appendFileSync(probePath, "clean\\n");
+}
+
+const result = spawnSync(realGit, args, { stdio: "inherit", env: process.env });
+process.exit(result.status ?? 1);
+`,
+    "utf-8",
+  );
+
+  if (process.platform === "win32") {
+    writeFileSync(join(bin, "git.cmd"), `@echo off\r\nnode "%~dp0git-proxy.cjs" %*\r\n`, "utf-8");
+  } else {
+    const executable = join(bin, "git");
+    writeFileSync(executable, `#!/bin/sh\nexec node "${shim}" "$@"\n`, "utf-8");
+    chmodSync(executable, 0o755);
+  }
+}
+
+function createRepo(root: string): { repo: string; worktree: string } {
+  const repo = join(root, "repo");
+  mkdirSync(repo, { recursive: true });
+  git(["init"], repo);
+  git(["config", "user.email", "test@test.com"], repo);
+  git(["config", "user.name", "Test"], repo);
+  writeFileSync(join(repo, ".gitignore"), ".gsd/\n", "utf-8");
+  writeFileSync(join(repo, "README.md"), "# test\n", "utf-8");
+  git(["add", "."], repo);
+  git(["commit", "-m", "init"], repo);
+  git(["branch", "-M", "main"], repo);
+
+  git(["checkout", "-b", "milestone/M001"], repo);
+  writeFileSync(join(repo, "feature.txt"), "milestone change\n", "utf-8");
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  writeFileSync(join(repo, ".gsd", "gsd.db-shm"), "milestone placeholder\n", "utf-8");
+  git(["add", "feature.txt"], repo);
+  git(["add", "-f", ".gsd/gsd.db-shm"], repo);
+  git(["commit", "-m", "feat: milestone change"], repo);
+  git(["checkout", "main"], repo);
+
+  const wt = worktreePath(repo, "M001");
+  mkdirSync(join(repo, ".gsd", "worktrees"), { recursive: true });
+  git(["worktree", "add", wt, "milestone/M001"], repo);
+  return { repo, worktree: wt };
+}
+
+test("mergeMilestoneToMain keeps the Windows DB cycle closed through squash merge", () => {
+  const savedCwd = process.cwd();
+  const originalPath = process.env.PATH ?? "";
+  const gitEnv = GIT_NO_PROMPT_ENV as NodeJS.ProcessEnv;
+  const originalGitEnvPath = gitEnv.PATH;
+  const originalHome = process.env.HOME;
+  const originalGsdHome = process.env.GSD_HOME;
+
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-db-cycle-")));
+  const fakeHome = join(root, "home");
+  const bin = join(root, "bin");
+  const probePath = join(root, "merge-probe.txt");
+  mkdirSync(fakeHome, { recursive: true });
+  mkdirSync(bin, { recursive: true });
+  installGitShim(bin, probePath);
+
+  try {
+    process.env.HOME = fakeHome;
+    process.env.GSD_HOME = join(fakeHome, ".gsd");
+    _clearGsdRootCache();
+    _resetServiceCache();
+
+    const { repo, worktree } = createRepo(root);
+    mkdirSync(join(repo, ".gsd"), { recursive: true });
+
+    withPlatform("win32", () => {
+      assert.equal(openDatabase(join(repo, ".gsd", "gsd.db")), true);
+      assert.equal(existsSync(join(repo, ".gsd", "gsd.db-shm")), true);
+
+      process.env.PATH = `${bin}${delimiter}${originalPath}`;
+      gitEnv.PATH = process.env.PATH;
+      process.chdir(worktree);
+
+      const result = mergeMilestoneToMain(repo, "M001", "# M001: Windows DB cycle\n");
+      assert.equal(result.codeFilesChanged, true);
+    });
+
+    assert.equal(git(["show", "HEAD:feature.txt"], repo), "milestone change");
+    assert.equal(readFileSync(probePath, "utf-8"), "clean\n");
+  } finally {
+    closeDatabase();
+    process.chdir(savedCwd);
+    process.env.PATH = originalPath;
+    gitEnv.PATH = originalGitEnvPath;
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+    if (originalGsdHome === undefined) {
+      delete process.env.GSD_HOME;
+    } else {
+      process.env.GSD_HOME = originalGsdHome;
+    }
+    _clearGsdRootCache();
+    _resetServiceCache();
+    if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/merge-self-branch-guard.test.ts

@@ -1,12 +1,9 @@
-// gsd-2 / merge-self-branch-guard.test.ts — regression for #5024
+// gsd-2 / merge-self-branch-guard.test.ts — regressions for #5024 and #6250
 //
-// mergeMilestoneToMain() must fail closed when the resolved integration
-// branch is the same ref as the milestone branch. Stale or corrupt
-// integration metadata (e.g. integrationBranch recorded as "milestone/<MID>")
-// would otherwise let the squash merge resolve to a self-merge: the post-
-// merge no-op safety check (#1792) compares main vs milestone and finds an
-// empty diff (because they're the same ref), so the helper returns success
-// for work that never landed on a distinct integration branch.
+// mergeMilestoneToMain() must recover from stale/corrupt integration metadata
+// that points at milestone branches (integrationBranch recorded as
+// "milestone/<MID>"). #6250 requires this to fall back to a safe integration
+// target (configured/detected main branch) instead of failing forever.
 
 import test from "node:test";
 import assert from "node:assert/strict";
@@ -42,7 +39,7 @@ function createTempRepo(): string {
   return dir;
 }
 
-function assertSelfMergeRefIsRejected(recordedIntegrationBranch: string): void {
+function assertSelfMergeRefRecoversToMain(recordedIntegrationBranch: string): void {
   const savedCwd = process.cwd();
   let tempDir = "";
 
@@ -70,39 +67,23 @@ function assertSelfMergeRefIsRejected(recordedIntegrationBranch: string): void {
     git(["add", "."], tempDir);
     git(["commit", "-m", "chore: plant corrupt M001 meta"], tempDir);
 
-    // Create the milestone branch ref so any pre-guard branch operations
-    // wouldn't fail for unrelated reasons.
-    git(["branch", "milestone/M001"], tempDir);
+    // Create milestone branch with a unique commit so successful merge-back
+    // to main can be observed.
+    git(["checkout", "-b", "milestone/M001"], tempDir);
+    writeFileSync(join(tempDir, "feature.txt"), "feature work\n");
+    git(["add", "feature.txt"], tempDir);
+    git(["commit", "-m", "feat: milestone work"], tempDir);
+    git(["checkout", "main"], tempDir);
 
     const mainHeadBefore = git(["rev-parse", "main"], tempDir);
-    const milestoneHeadBefore = git(["rev-parse", "milestone/M001"], tempDir);
-
     process.chdir(tempDir);
 
-    assert.throws(
-      () => mergeMilestoneToMain(tempDir, "M001", ""),
-      (err: unknown) => {
-        assert.ok(err instanceof Error, "expected an Error to be thrown");
-        assert.match(
-          err.message,
-          /self-merge|same ref/i,
-          "error message should explain the self-merge refusal",
-        );
-        return true;
-      },
-    );
+    mergeMilestoneToMain(tempDir, "M001", "");
 
-    // Postcondition: neither branch should have been advanced by a merge
-    // commit. The guard fires before checkout/merge, so both refs must be
-    // unchanged from their pre-call state.
+    // Postcondition: merge-back lands on main.
     const mainHeadAfter = git(["rev-parse", "main"], tempDir);
-    const milestoneHeadAfter = git(["rev-parse", "milestone/M001"], tempDir);
-    assert.equal(mainHeadAfter, mainHeadBefore, "main must not have advanced");
-    assert.equal(
-      milestoneHeadAfter,
-      milestoneHeadBefore,
-      "milestone branch must not have advanced",
-    );
+    assert.notEqual(mainHeadAfter, mainHeadBefore, "main must advance via merge-back");
+    assert.equal(git(["rev-parse", "HEAD"], tempDir), mainHeadAfter, "repo remains on main after merge-back");
   } finally {
     process.chdir(savedCwd);
     process.env.HOME = originalHome;
@@ -115,10 +96,10 @@ function assertSelfMergeRefIsRejected(recordedIntegrationBranch: string): void {
   }
 }
 
-test("mergeMilestoneToMain refuses exact milestone branch self-merge metadata (#5024)", () => {
-  assertSelfMergeRefIsRejected("milestone/M001");
+test("mergeMilestoneToMain recovers from exact milestone self-ref integration metadata (#6250)", () => {
+  assertSelfMergeRefRecoversToMain("milestone/M001");
 });
 
-test("mergeMilestoneToMain refuses refs/heads milestone branch self-merge metadata (#5024)", () => {
-  assertSelfMergeRefIsRejected("refs/heads/milestone/M001");
+test("mergeMilestoneToMain recovers from refs/heads milestone self-ref integration metadata (#6250)", () => {
+  assertSelfMergeRefRecoversToMain("refs/heads/milestone/M001");
 });

package/src/resources/extensions/gsd/tests/migrate-validator-parsers.test.ts

@@ -41,6 +41,15 @@ const SAMPLE_ROADMAP = `# Project Roadmap
 - [ ] 31 — Notifications
 `;
 
+const SAMPLE_VERSION_PREFIX_ROADMAP = `# Project Roadmap
+
+## Phases
+
+- ✅ **v1.0 MVP** — Phases 1-6 (shipped 2026-02-24)
+- ✅ **v1.1 Onboarding** — Phases 7-9 (shipped 2026-03-01)
+- 🚧 **v1.8 Production** — Phases 44-53
+`;
+
 const SAMPLE_PROJECT = `# My Project
 
 A sample project for testing the migration parser.
@@ -65,6 +74,17 @@ const SAMPLE_MILESTONE_SECTIONED_ROADMAP = `# Project Roadmap
 - [ ] 31 — Notifications
 `;
 
+const SAMPLE_MILESTONE_SUMMARY_SUBSECTION_ROADMAP = `# Project Roadmap
+
+## Milestones
+- [x] **Phase 1: v1.0 MVP** — Phases 1-6 (shipped 2026-02-24)
+- [ ] **Phase 45: v1.8 Production Readiness** — Phases 45-54 (in progress)
+
+### v1.8 Production Readiness (Phases 45-54)
+- [ ] **Phase 45: Feature X** — long description...
+- [ ] **Phase 46: Feature Y** — long description...
+`;
+
 const SAMPLE_PLAN_XML = `---
 phase: "29-auth-system"
 plan: "01"
@@ -246,6 +266,21 @@ test('parseOldRoadmap: flat format', () => {
     assert.deepStrictEqual(roadmap.phases[1].done, false, 'flat roadmap: second phase not done');
 });
 
+test('parseOldRoadmap: emoji version-prefix phase ranges', () => {
+    const roadmap = parseOldRoadmap(SAMPLE_VERSION_PREFIX_ROADMAP);
+    assert.deepStrictEqual(roadmap.milestones.length, 0, 'version roadmap: no milestone sections');
+    assert.deepStrictEqual(roadmap.phases.length, 3, 'version roadmap: 3 phase ranges');
+    assert.deepStrictEqual(roadmap.phases[0].number, 1, 'version roadmap: first range starts at phase 1');
+    assert.deepStrictEqual(roadmap.phases[0].title, 'MVP', 'version roadmap: first title');
+    assert.deepStrictEqual(roadmap.phases[0].done, true, 'version roadmap: first range done');
+    assert.deepStrictEqual(roadmap.phases[1].number, 7, 'version roadmap: second range starts at phase 7');
+    assert.deepStrictEqual(roadmap.phases[1].title, 'Onboarding', 'version roadmap: second title');
+    assert.deepStrictEqual(roadmap.phases[1].done, true, 'version roadmap: second range done');
+    assert.deepStrictEqual(roadmap.phases[2].number, 44, 'version roadmap: third range starts at phase 44');
+    assert.deepStrictEqual(roadmap.phases[2].title, 'Production', 'version roadmap: third title');
+    assert.deepStrictEqual(roadmap.phases[2].done, false, 'version roadmap: third range in progress');
+});
+
 test('parseOldRoadmap: milestone-sectioned with <details>', () => {
     const roadmap = parseOldRoadmap(SAMPLE_MILESTONE_SECTIONED_ROADMAP);
     assert.ok(roadmap.milestones.length >= 2, 'ms roadmap: has milestone sections');
@@ -267,6 +302,30 @@ test('parseOldRoadmap: milestone-sectioned with <details>', () => {
     assert.deepStrictEqual(p30?.done, false, 'ms roadmap: phase 30 not done');
 });
 
+test('parseOldRoadmap: milestones summary + vN.N subsections', () => {
+    const roadmap = parseOldRoadmap(SAMPLE_MILESTONE_SUMMARY_SUBSECTION_ROADMAP);
+    assert.deepStrictEqual(roadmap.phases.length, 0, 'summary+subsections: no flat phases');
+    assert.deepStrictEqual(roadmap.milestones.length, 2, 'summary+subsections: two milestones');
+
+    const v10 = roadmap.milestones.find(m => m.id === 'v1.0');
+    assert.ok(v10 !== undefined, 'summary+subsections: v1.0 found');
+    assert.deepStrictEqual(v10?.phases.length, 6, 'summary+subsections: v1.0 uses synthetic completed range');
+    assert.ok(v10?.phases.every(p => p.done) ?? false, 'summary+subsections: v1.0 synthetic phases marked done');
+
+    const v18 = roadmap.milestones.find(m => m.id === 'v1.8');
+    assert.ok(v18 !== undefined, 'summary+subsections: v1.8 found');
+    assert.deepStrictEqual(v18?.phases.length, 2, 'summary+subsections: v1.8 phases parsed from subsection');
+    assert.deepStrictEqual(v18?.phases[0]?.number, 45, 'summary+subsections: first subsection phase number');
+    assert.deepStrictEqual(v18?.phases[0]?.title, 'Feature X', 'summary+subsections: em-dash description stripped');
+    assert.deepStrictEqual(v18?.phases[1]?.number, 46, 'summary+subsections: second subsection phase number');
+});
+
+test('parseOldRoadmap: phase title strips em-dash suffix description', () => {
+    const roadmap = parseOldRoadmap('- [ ] Phase 45: Feature X — long description...');
+    assert.deepStrictEqual(roadmap.phases.length, 1, 'em-dash strip: one parsed phase');
+    assert.deepStrictEqual(roadmap.phases[0]?.title, 'Feature X', 'em-dash strip: title excludes suffix description');
+});
+
   // ═══════════════════════════════════════════════════════════════════════
   // Plan Parser Tests
   // ═══════════════════════════════════════════════════════════════════════
@@ -387,4 +446,3 @@ test('parseOldProject', () => {
     const project = parseOldProject(SAMPLE_PROJECT);
     assert.deepStrictEqual(project, SAMPLE_PROJECT, 'project: returns raw content');
 });
-