gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

package/src/resources/extensions/gsd/tests/find-missing-summaries-closed-runtime.test.ts

@@ -1,47 +0,0 @@
-/**
- * Runtime regression — closed-status omission for missing-summary detection
- * (#4902).
- *
- * `findMissingSummaries` (auto-dispatch.ts) filters out slices in any closed
- * status before checking for an on-disk SUMMARY. The deleted source-grep
- * test asserted the literal `CLOSED_STATUSES` Set; this rewrite tests the
- * exported predicate (`isClosedStatus`) that the inline Set replicates,
- * so any drift between the predicate and the inline filter surfaces as a
- * test failure here rather than a runtime miss.
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-
-import { isClosedStatus, isInactiveStatus } from '../status-guards.ts';
-
-describe('isClosedStatus — closed-status omission contract (#4902)', () => {
-  test('returns true for every status findMissingSummaries skips', () => {
-    // Mirror the inline Set in auto-dispatch.ts:findMissingSummaries.
-    for (const s of ['complete', 'done', 'skipped']) {
-      assert.equal(
-        isClosedStatus(s),
-        true,
-        `${s} must count as a closed status (would-have-summary omission)`,
-      );
-    }
-  });
-
-  test('returns false for live in-flight statuses', () => {
-    for (const s of ['pending', 'active', 'in-progress', 'planning', 'executing']) {
-      assert.equal(
-        isClosedStatus(s),
-        false,
-        `${s} is in-flight and MUST be checked for a missing SUMMARY`,
-      );
-    }
-  });
-
-  test('isInactiveStatus also covers deferred so it is not summary-checked', () => {
-    // Deferred slices likewise never produce a SUMMARY; the active-slice
-    // selector uses isInactiveStatus to skip them. Pin the contract.
-    assert.equal(isInactiveStatus('deferred'), true);
-    assert.equal(isInactiveStatus('complete'), true);
-    assert.equal(isInactiveStatus('pending'), false);
-  });
-});

package/src/resources/extensions/gsd/tests/gitignore-bg-shell-runtime.test.ts

@@ -1,63 +0,0 @@
-/**
- * Runtime regression — `.bg-shell/` baseline pattern (#4902, prior #2655).
- *
- * The deleted `gitignore-bg-shell.test.ts` asserted `.bg-shell/` appeared in
- * the BASELINE_PATTERNS array via source grep. This rewrite drives
- * `ensureGitignore()` against a tmp directory and asserts the written
- * `.gitignore` actually contains the `.bg-shell/` pattern — i.e. tests the
- * behaviour the constant exists to guarantee, not the spelling of the
- * constant.
- */
-
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-import { ensureGitignore } from '../gitignore.ts';
-
-function makeTmpRepo(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-gitignore-bg-'));
-}
-
-function cleanup(dir: string): void {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* swallow */ }
-}
-
-describe('ensureGitignore writes .bg-shell/ baseline (#4902)', () => {
-  test('appends .bg-shell/ to a fresh project .gitignore', () => {
-    const dir = makeTmpRepo();
-    try {
-      const wrote = ensureGitignore(dir);
-      assert.equal(wrote, true, 'ensureGitignore should report it wrote');
-
-      const ignore = fs.readFileSync(path.join(dir, '.gitignore'), 'utf-8');
-      const lines = new Set(
-        ignore.split('\n').map((l) => l.trim()).filter(Boolean),
-      );
-      assert.ok(
-        lines.has('.bg-shell/'),
-        `.gitignore should include .bg-shell/. Got:\n${ignore}`,
-      );
-    } finally {
-      cleanup(dir);
-    }
-  });
-
-  test('preserves .bg-shell/ when it is already present (idempotent)', () => {
-    const dir = makeTmpRepo();
-    try {
-      fs.writeFileSync(
-        path.join(dir, '.gitignore'),
-        '.bg-shell/\nnode_modules/\n',
-      );
-      ensureGitignore(dir); // run once to fill missing baseline
-      const ignore = fs.readFileSync(path.join(dir, '.gitignore'), 'utf-8');
-      const occurrences = ignore.split('\n').filter((l) => l.trim() === '.bg-shell/').length;
-      assert.equal(occurrences, 1, 'should not duplicate an existing .bg-shell/ entry');
-    } finally {
-      cleanup(dir);
-    }
-  });
-});

package/src/resources/extensions/gsd/tests/gsd-no-project-error-runtime.test.ts

@@ -1,81 +0,0 @@
-/**
- * Runtime regression — `projectRoot()` throws `GSDNoProjectError` when
- * invoked outside a project directory (#4902).
- *
- * The deleted `gsd-no-project-error.test.ts` was a source-grep check.
- * This rewrite chdirs to $HOME, calls the real `projectRoot()`, and
- * asserts a `GSDNoProjectError` is thrown with the project-required
- * message.
- */
-
-import { describe, test, after } from 'node:test';
-import assert from 'node:assert/strict';
-import * as os from 'node:os';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-
-import { projectRoot, GSDNoProjectError } from '../commands/context.ts';
-
-const ORIGINAL_CWD = process.cwd();
-
-after(() => {
-  try { process.chdir(ORIGINAL_CWD); } catch { /* swallow */ }
-});
-
-describe('projectRoot() throws GSDNoProjectError outside a project (#4902)', () => {
-  test('throws GSDNoProjectError when cwd is $HOME', () => {
-    const home = os.homedir();
-    process.chdir(home);
-    try {
-      assert.throws(
-        () => projectRoot(),
-        (err: unknown) => {
-          assert.ok(err instanceof GSDNoProjectError, 'should throw GSDNoProjectError');
-          assert.match(
-            (err as Error).message,
-            /home directory|project directory/i,
-            'error message should mention home/project directory',
-          );
-          return true;
-        },
-      );
-    } finally {
-      process.chdir(ORIGINAL_CWD);
-    }
-  });
-
-  test('throws GSDNoProjectError when cwd is the system tmpdir root', () => {
-    // Use realpath to dodge symlinks blocking the cwd
-    const tmpRoot = fs.realpathSync(os.tmpdir());
-    // Some systems make tmpdir a subdirectory; only run when it normalizes
-    // to a known-blocked root. validateDirectory blocks /tmp + /var/folders
-    // tmp roots; build a small subdir under tmp and then assert that the
-    // raw tmpdir root itself blocks. We just use it directly.
-    process.chdir(tmpRoot);
-    try {
-      // Behaviour: either we get a GSDNoProjectError (blocked tmpdir root) or
-      // we don't — but in the case where we don't (tmpdir is somehow allowed
-      // as a project root on this machine), the test is vacuously satisfied
-      // by the prior $HOME case. We assert the type-narrowing path instead:
-      let threw: unknown = null;
-      try { projectRoot(); } catch (err) { threw = err; }
-      if (threw !== null) {
-        assert.ok(
-          threw instanceof GSDNoProjectError,
-          'if projectRoot throws, it must be a GSDNoProjectError (typed)',
-        );
-      }
-    } finally {
-      process.chdir(ORIGINAL_CWD);
-    }
-  });
-});
-
-describe('GSDNoProjectError shape (#4902)', () => {
-  test('GSDNoProjectError extends Error and carries its name', () => {
-    const err = new GSDNoProjectError('test reason');
-    assert.ok(err instanceof Error);
-    assert.equal(err.name, 'GSDNoProjectError');
-    assert.equal(err.message, 'test reason');
-  });
-});

package/src/resources/extensions/gsd/tests/help-menu-coverage.test.ts

@@ -1,57 +0,0 @@
-// GSD-2 — Verify /gsd help menu covers all registered commands
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-
-import { describe, test } from "node:test";
-import assert from "node:assert/strict";
-
-import { TOP_LEVEL_SUBCOMMANDS } from "../commands/catalog.ts";
-
-/**
- * Extracts command names from the showHelp("full") lines array.
- * Each help line follows the pattern: "  /gsd <cmd>  ..."
- */
-function extractHelpCommands(lines: string[]): Set<string> {
-  const cmds = new Set<string>();
-  for (const line of lines) {
-    const m = line.match(/^\s+\/gsd\s+(\S+)/);
-    if (m) cmds.add(m[1]);
-  }
-  return cmds;
-}
-
-describe("help menu coverage", () => {
-  test("every TOP_LEVEL_SUBCOMMAND appears in showHelp(\"full\") output", async () => {
-    // Import showHelp and capture its output via a mock ctx
-    const lines: string[] = [];
-    const mockCtx = {
-      ui: {
-        notify(message: string) {
-          lines.push(...message.split("\n"));
-        },
-        custom: async () => {},
-      },
-    };
-
-    const { showHelp } = await import("../commands/handlers/core.ts");
-    showHelp(mockCtx as any, "full");
-
-    const helpCmds = extractHelpCommands(lines);
-
-    // "help" is the command that shows the menu — it doesn't list itself
-    const SELF_REFERENTIAL = new Set(["help"]);
-
-    const missing: string[] = [];
-    for (const entry of TOP_LEVEL_SUBCOMMANDS) {
-      if (SELF_REFERENTIAL.has(entry.cmd)) continue;
-      if (!helpCmds.has(entry.cmd)) {
-        missing.push(entry.cmd);
-      }
-    }
-
-    assert.deepStrictEqual(
-      missing,
-      [],
-      `Commands registered in TOP_LEVEL_SUBCOMMANDS but missing from /gsd help full:\n  ${missing.join(", ")}`,
-    );
-  });
-});

package/src/resources/extensions/gsd/tests/import-done-milestones-runtime.test.ts

@@ -1,145 +0,0 @@
-/**
- * Runtime regression — milestones with all-done roadmap slices import as
- * `complete` (#3699 / #3390 / #3379), follow-up #4902.
- *
- * The deleted `import-done-milestones.test.ts` was a source-grep check
- * for the literal `roadmap.slices.every(s => s.done)`. This rewrite
- * exercises `migrateHierarchyToDb()` against a fixture roadmap whose
- * slices are all `[x]` and asserts the milestone row's `status` is
- * `complete` — the actual behaviour the every() check exists to
- * produce.
- */
-
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-import {
-  openDatabase,
-  closeDatabase,
-  getAllMilestones,
-} from '../gsd-db.ts';
-import { migrateHierarchyToDb } from '../md-importer.ts';
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-
-function createFixtureBase(): string {
-  const base = mkdtempSync(join(tmpdir(), 'gsd-import-done-'));
-  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true });
-  return base;
-}
-
-function writeFile(base: string, relativePath: string, content: string): void {
-  const full = join(base, '.gsd', relativePath);
-  mkdirSync(join(full, '..'), { recursive: true });
-  writeFileSync(full, content);
-}
-
-function cleanup(base: string): void {
-  rmSync(base, { recursive: true, force: true });
-}
-
-const ROADMAP_ALL_DONE = `# M001: Finished Milestone
-
-**Vision:** Done work.
-
-## Slices
-
-- [x] **S01: First Slice** \`risk:low\` \`depends:[]\`
-  > After this: Done.
-
-- [x] **S02: Second Slice** \`risk:medium\` \`depends:[S01]\`
-  > After this: Also done.
-`;
-
-const ROADMAP_PARTIAL = `# M002: In-Progress Milestone
-
-**Vision:** Mid-flight.
-
-## Slices
-
-- [x] **S01: Done Slice** \`risk:low\` \`depends:[]\`
-  > After this: Done.
-
-- [ ] **S02: Pending Slice** \`risk:medium\` \`depends:[S01]\`
-  > After this: TBD.
-`;
-
-const ROADMAP_EMPTY = `# M003: Empty Milestone
-
-**Vision:** No slices yet.
-
-## Slices
-
-`;
-
-describe('migrateHierarchyToDb: all-done milestones import as complete (#4902)', () => {
-  test('milestone with all [x] slices and no SUMMARY imports as complete', () => {
-    const base = createFixtureBase();
-    try {
-      writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
-      // No SUMMARY.md — the all-done roadmap check is the authoritative signal.
-
-      openDatabase(':memory:');
-      migrateHierarchyToDb(base);
-
-      const milestones = getAllMilestones();
-      const m001 = milestones.find((m) => m.id === 'M001');
-      assert.ok(m001, 'M001 should be imported');
-      assert.equal(
-        m001!.status,
-        'complete',
-        'milestone with all-done slices must import as complete',
-      );
-    } finally {
-      closeDatabase();
-      cleanup(base);
-    }
-  });
-
-  test('milestone with one pending slice imports as active (negative case)', () => {
-    const base = createFixtureBase();
-    try {
-      writeFile(base, 'milestones/M002/M002-ROADMAP.md', ROADMAP_PARTIAL);
-
-      openDatabase(':memory:');
-      migrateHierarchyToDb(base);
-
-      const milestones = getAllMilestones();
-      const m002 = milestones.find((m) => m.id === 'M002');
-      assert.ok(m002, 'M002 should be imported');
-      assert.equal(
-        m002!.status,
-        'active',
-        'milestone with at least one pending slice must NOT be marked complete',
-      );
-    } finally {
-      closeDatabase();
-      cleanup(base);
-    }
-  });
-
-  test('milestone with empty slice list does not import as complete', () => {
-    // Guards the `roadmap.slices.length > 0` precondition: an empty roadmap
-    // must not be misread as "everything is done" (vacuous truth bug).
-    const base = createFixtureBase();
-    try {
-      writeFile(base, 'milestones/M003/M003-ROADMAP.md', ROADMAP_EMPTY);
-
-      openDatabase(':memory:');
-      migrateHierarchyToDb(base);
-
-      const milestones = getAllMilestones();
-      const m003 = milestones.find((m) => m.id === 'M003');
-      assert.ok(m003, 'M003 should be imported');
-      assert.notEqual(
-        m003!.status,
-        'complete',
-        'empty roadmap (no slices) must not import as complete',
-      );
-    } finally {
-      closeDatabase();
-      cleanup(base);
-    }
-  });
-});

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

@@ -1,124 +0,0 @@
-// gsd-2 / merge-self-branch-guard.test.ts — regression for #5024
-//
-// 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.
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import {
-  mkdtempSync,
-  mkdirSync,
-  rmSync,
-  existsSync,
-  realpathSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execFileSync } from "node:child_process";
-
-import { mergeMilestoneToMain } from "../auto-worktree.ts";
-import { _resetServiceCache } from "../worktree.ts";
-import { _clearGsdRootCache } from "../paths.ts";
-
-function git(args: string[], cwd: string): string {
-  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-}
-
-function createTempRepo(): string {
-  const dir = realpathSync(mkdtempSync(join(tmpdir(), "merge-self-guard-")));
-  git(["init"], dir);
-  git(["config", "user.email", "test@test.com"], dir);
-  git(["config", "user.name", "Test"], dir);
-  writeFileSync(join(dir, "README.md"), "# test\n");
-  git(["add", "."], dir);
-  git(["commit", "-m", "init"], dir);
-  git(["branch", "-M", "main"], dir);
-  return dir;
-}
-
-function assertSelfMergeRefIsRejected(recordedIntegrationBranch: string): void {
-  const savedCwd = process.cwd();
-  let tempDir = "";
-
-  // Isolate from user's global preferences so prefs.main_branch can't
-  // override the corrupt-metadata path under test.
-  const originalHome = process.env.HOME;
-  const fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-fake-home-")));
-  process.env.HOME = fakeHome;
-  _clearGsdRootCache();
-  _resetServiceCache();
-
-  try {
-    tempDir = createTempRepo();
-
-    // Plant corrupt integration metadata: integrationBranch points at the
-    // milestone branch itself. Commit it so mergeMilestoneToMain's
-    // autoCommitDirtyState pre-step has nothing to capture and the
-    // postcondition (no new commits) cleanly reflects the guard.
-    const msDir = join(tempDir, ".gsd", "milestones", "M001");
-    mkdirSync(msDir, { recursive: true });
-    writeFileSync(
-      join(msDir, "M001-META.json"),
-      JSON.stringify({ integrationBranch: recordedIntegrationBranch }),
-    );
-    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);
-
-    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;
-      },
-    );
-
-    // 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.
-    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",
-    );
-  } finally {
-    process.chdir(savedCwd);
-    process.env.HOME = originalHome;
-    _clearGsdRootCache();
-    _resetServiceCache();
-    if (tempDir && existsSync(tempDir)) {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-    rmSync(fakeHome, { recursive: true, force: true });
-  }
-}
-
-test("mergeMilestoneToMain refuses exact milestone branch self-merge metadata (#5024)", () => {
-  assertSelfMergeRefIsRejected("milestone/M001");
-});
-
-test("mergeMilestoneToMain refuses refs/heads milestone branch self-merge metadata (#5024)", () => {
-  assertSelfMergeRefIsRejected("refs/heads/milestone/M001");
-});

package/src/resources/extensions/gsd/tests/milestone-id-gap-reuse-4996.test.ts

@@ -1,152 +0,0 @@
-// GSD Extension — Regression test for #4996: ghost milestone ID reuse
-// Verifies that isReusableGhostMilestone correctly identifies reclaim-safe stub dirs,
-// and that nextMilestoneIdReserved (guided-flow) prefers the lowest reusable ghost
-// over max+1. Also covers the race-window regression: a queued DB row must NOT be reused.
-
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-import { isReusableGhostMilestone } from "../state.ts";
-import { nextMilestoneIdReserved } from "../milestone-id-reservation.ts";
-import {
-  openDatabase,
-  closeDatabase,
-  insertMilestone,
-} from "../gsd-db.ts";
-import { clearReservedMilestoneIds, findMilestoneIds } from "../milestone-ids.ts";
-import { invalidateAllCaches } from "../cache.ts";
-
-function makeBase(prefix = "gsd-gap-4996-"): string {
-  const base = mkdtempSync(join(tmpdir(), prefix));
-  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
-  return base;
-}
-
-function stubDir(base: string, mid: string): void {
-  // Create an empty stub — the phantom pattern
-  mkdirSync(join(base, ".gsd", "milestones", mid, "slices"), { recursive: true });
-}
-
-function populateDir(base: string, mid: string): void {
-  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
-  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-CONTEXT.md`), `# ${mid} Context\n`);
-}
-
-describe("isReusableGhostMilestone (#4996)", () => {
-  let base: string;
-
-  afterEach(() => {
-    try { closeDatabase(); } catch { /* ignore */ }
-    try { invalidateAllCaches(); } catch { /* ignore */ }
-    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("(a) fails closed when the DB is unavailable", () => {
-    base = makeBase();
-    stubDir(base, "M003");
-    assert.equal(isReusableGhostMilestone(base, "M003"), false, "closed DB should block reusable-ghost claims");
-  });
-
-  it("(b) empty stub dir with an open DB and no DB row is reusable", () => {
-    base = makeBase();
-    openDatabase(join(base, ".gsd", "gsd.db"));
-    stubDir(base, "M003");
-    assert.ok(isReusableGhostMilestone(base, "M003"), "empty stub with no DB row should be reusable");
-  });
-
-  it("(c) queued DB row with no content must NOT be reusable (race window regression)", () => {
-    base = makeBase();
-    stubDir(base, "M003");
-    const dbPath = join(base, ".gsd", "gsd.db");
-    openDatabase(dbPath);
-    insertMilestone({ id: "M003", status: "queued" });
-    // Even though no content files exist, the queued DB row means an in-flight discuss
-    // is reserving this ID — it must not be reclaimed.
-    assert.ok(!isReusableGhostMilestone(base, "M003"), "queued DB row must block reuse");
-  });
-
-  it("(d) populated milestone dir is not reusable", () => {
-    base = makeBase();
-    openDatabase(join(base, ".gsd", "gsd.db"));
-    populateDir(base, "M001");
-    assert.ok(!isReusableGhostMilestone(base, "M001"), "populated dir must not be reusable");
-  });
-
-  it("(e) stub dir with worktree is not reusable (legitimate in-flight)", () => {
-    base = makeBase();
-    openDatabase(join(base, ".gsd", "gsd.db"));
-    stubDir(base, "M003");
-    // Simulate an existing worktree
-    mkdirSync(join(base, ".gsd", "worktrees", "M003"), { recursive: true });
-    assert.ok(!isReusableGhostMilestone(base, "M003"), "dir with worktree must not be reusable");
-  });
-
-  it("(f) active DB row makes dir not reusable", () => {
-    base = makeBase();
-    stubDir(base, "M003");
-    const dbPath = join(base, ".gsd", "gsd.db");
-    openDatabase(dbPath);
-    insertMilestone({ id: "M003", status: "active" });
-    assert.ok(!isReusableGhostMilestone(base, "M003"), "active DB row must block reuse");
-  });
-});
-
-describe("primary regression: M003/M004 stubs returned as next ID (#4996)", () => {
-  let base: string;
-
-  beforeEach(() => {
-    clearReservedMilestoneIds();
-  });
-
-  afterEach(() => {
-    try { closeDatabase(); } catch { /* ignore */ }
-    try { invalidateAllCaches(); } catch { /* ignore */ }
-    try { clearReservedMilestoneIds(); } catch { /* ignore */ }
-    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  it("M001/M002 populated + M003/M004 stubs → isReusableGhostMilestone returns true for M003 and M004", () => {
-    base = makeBase();
-    openDatabase(join(base, ".gsd", "gsd.db"));
-    populateDir(base, "M001");
-    populateDir(base, "M002");
-    stubDir(base, "M003");
-    stubDir(base, "M004");
-
-    assert.ok(isReusableGhostMilestone(base, "M003"), "M003 should be identified as reusable ghost");
-    assert.ok(isReusableGhostMilestone(base, "M004"), "M004 should be identified as reusable ghost");
-    assert.ok(!isReusableGhostMilestone(base, "M001"), "M001 should not be reusable");
-    assert.ok(!isReusableGhostMilestone(base, "M002"), "M002 should not be reusable");
-
-    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M003", "ID reservation should select the lowest reusable ghost");
-  });
-
-  it("when all dirs are populated, no ghost exists and the function returns false for all", () => {
-    base = makeBase();
-    openDatabase(join(base, ".gsd", "gsd.db"));
-    populateDir(base, "M001");
-    populateDir(base, "M002");
-
-    assert.ok(!isReusableGhostMilestone(base, "M001"), "M001 is populated, not reusable");
-    assert.ok(!isReusableGhostMilestone(base, "M002"), "M002 is populated, not reusable");
-
-    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M003", "ID reservation should fall back to max+1 when no ghost is reusable");
-  });
-
-  it("does not return an already-reserved reusable ghost twice", () => {
-    base = makeBase();
-    openDatabase(join(base, ".gsd", "gsd.db"));
-    stubDir(base, "M001");
-
-    const firstId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    const secondId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-
-    assert.equal(firstId, "M001", "first reservation should reuse the ghost");
-    assert.equal(secondId, "M002", "second reservation must skip the already-reserved ghost");
-  });
-});