@opengsd/gsd-pi 1.7.0 → 1.8.1-dev.897b3c90

package/src/resources/extensions/gsd/tests/import-slice-milestone-completion-preserve.test.ts

@@ -0,0 +1,116 @@
+// Project/App: gsd-pi
+// File Purpose: Regression for #1291 — a full markdown re-import must NOT rewrite
+// the completed_at of an already-complete slice or milestone with the current
+// import time. The task path was fixed for this (#1222/#1228) via
+// preserveCompletionMetadata; the slice and milestone backfills in
+// migrateHierarchyToDb had no such guard, so every re-import re-stamped every
+// complete slice/milestone. The fix threads preserveCompletion through
+// updateSliceStatus/updateMilestoneStatus so an existing completed_at survives.
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import {
+  openDatabase,
+  closeDatabase,
+  getAllMilestones,
+  getMilestoneSlices,
+  updateSliceStatus,
+  updateMilestoneStatus,
+} from '../gsd-db.ts';
+import { migrateHierarchyToDb } from '../md-importer.ts';
+import { describe, test, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+
+const tmpDirs: string[] = [];
+afterEach(() => {
+  closeDatabase();
+  for (const d of tmpDirs) { try { rmSync(d, { recursive: true, force: true }); } catch { /* */ } }
+  tmpDirs.length = 0;
+});
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-preserve-completion-'));
+  tmpDirs.push(base);
+  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);
+}
+
+// All slices [x] → milestone imports complete, slices import complete.
+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 REAL_S01 = '2026-07-05T19:52:04.672Z';
+const REAL_S02 = '2026-07-05T20:36:51.313Z';
+const REAL_M001 = '2026-07-05T21:00:00.000Z';
+
+describe('migrateHierarchyToDb: re-import preserves existing completion timestamps (#1291)', () => {
+  test('a re-import does not rewrite already-complete slice completed_at', () => {
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    // Simulate the durable completion timestamps the real run wrote hours apart.
+    updateSliceStatus('M001', 'S01', 'complete', REAL_S01);
+    updateSliceStatus('M001', 'S02', 'complete', REAL_S02);
+
+    // A second full re-import (the class of event that bit the reporter).
+    migrateHierarchyToDb(base);
+
+    const slices = getMilestoneSlices('M001');
+    const s01 = slices.find((s) => s.id === 'S01')!;
+    const s02 = slices.find((s) => s.id === 'S02')!;
+    assert.equal(s01.completed_at, REAL_S01, 'S01 completed_at must survive re-import unchanged');
+    assert.equal(s02.completed_at, REAL_S02, 'S02 completed_at must survive re-import unchanged');
+  });
+
+  test('a re-import does not rewrite an already-complete milestone completed_at', () => {
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    updateMilestoneStatus('M001', 'complete', REAL_M001);
+
+    migrateHierarchyToDb(base);
+
+    const m001 = getAllMilestones().find((m) => m.id === 'M001')!;
+    assert.equal(m001.completed_at, REAL_M001, 'M001 completed_at must survive re-import unchanged');
+  });
+
+  test('an initial import of a complete slice still backfills a completed_at when the row has none', () => {
+    // The guard preserves an existing timestamp but must not suppress the
+    // legitimate first-time backfill for a slice imported as complete.
+    const base = createFixtureBase();
+    writeFile(base, 'milestones/M001/M001-ROADMAP.md', ROADMAP_ALL_DONE);
+
+    openDatabase(join(base, '.gsd', 'gsd.db'));
+    migrateHierarchyToDb(base);
+
+    const slices = getMilestoneSlices('M001');
+    for (const s of slices) {
+      assert.ok(s.completed_at, `complete slice ${s.id} should receive a backfilled completed_at on first import`);
+    }
+    const m001 = getAllMilestones().find((m) => m.id === 'M001')!;
+    assert.ok(m001.completed_at, 'complete milestone should receive a backfilled completed_at on first import');
+  });
+});

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

@@ -427,3 +427,56 @@ test('migrate-hier: demo text extracted', () => {
     }
 });
 
+  // ─── Test (i): Sketch slice stub tasks are not seeded (#1286) ─────────
+
+test('migrate-hier: sketch slice stub PLAN tasks are not imported', () => {
+    const base = createFixtureBase();
+    try {
+      // S01 is a sketch (badge before risk, per ADR-011 render); its PLAN is a
+      // stub with a placeholder <tasks> block. S02 is a real, refined slice.
+      const roadmap = `# M001: Test Milestone
+
+**Vision:** Sketch slices must not seed DB tasks.
+
+## Slices
+
+- [ ] **S01: Sketch Slice** \`[sketch]\` \`risk:low\` \`depends:[]\`
+  > After this: Sketch decomposed.
+
+- [ ] **S02: Real Slice** \`risk:low\` \`depends:[]\`
+  > After this: Real work done.
+`;
+      const sketchPlan = `# S01: Sketch Slice
+
+**Goal:** Placeholder.
+
+## Tasks
+
+- [ ] **T01: Plan 01**
+  Stub placeholder task.
+`;
+      writeFile(base, 'milestones/M001/M001-ROADMAP.md', roadmap);
+      writeFile(base, 'milestones/M001/slices/S01/S01-PLAN.md', sketchPlan);
+      writeFile(base, 'milestones/M001/slices/S02/S02-PLAN.md', PLAN_S02_1_TASK);
+
+      openDatabase(':memory:');
+      const counts = migrateHierarchyToDb(base);
+
+      const slices = getMilestoneSlices('M001');
+      assert.deepStrictEqual(slices.length, 2, 'sketch: 2 slices inserted');
+      assert.deepStrictEqual(slices[0]!.is_sketch, 1, 'sketch: S01 preserves is_sketch flag');
+
+      const s01Tasks = getSliceTasks('M001', 'S01');
+      assert.deepStrictEqual(s01Tasks.length, 0, 'sketch: no stub tasks seeded for sketch slice S01');
+
+      const s02Tasks = getSliceTasks('M001', 'S02');
+      assert.deepStrictEqual(s02Tasks.length, 1, 'sketch: real slice S02 still imports its task');
+      assert.deepStrictEqual(counts.tasks, 1, 'sketch: only the non-sketch slice contributes tasks');
+
+      closeDatabase();
+    } finally {
+      closeDatabase();
+      cleanup(base);
+    }
+});
+

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

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { createMigrationPlan, splitValidationIssues } from "../migrate/plan.ts";
+import type { ValidationResult } from "../migrate/types.ts";
+
+function makeBase(prefix: string): string {
+  return mkdtempSync(join(tmpdir(), prefix));
+}
+
+function write(path: string, content: string): void {
+  mkdirSync(join(path, ".."), { recursive: true });
+  writeFileSync(path, content);
+}
+
+test("splitValidationIssues separates warnings from fatals without dropping issue order", () => {
+  const validation: ValidationResult = {
+    valid: false,
+    issues: [
+      { file: "ROADMAP.md", severity: "warning", message: "missing roadmap" },
+      { file: ".planning", severity: "fatal", message: "missing directory" },
+      { file: "PROJECT.md", severity: "warning", message: "missing project" },
+    ],
+  };
+
+  assert.deepEqual(splitValidationIssues(validation), {
+    warnings: [
+      { file: "ROADMAP.md", severity: "warning", message: "missing roadmap" },
+      { file: "PROJECT.md", severity: "warning", message: "missing project" },
+    ],
+    fatals: [
+      { file: ".planning", severity: "fatal", message: "missing directory" },
+    ],
+  });
+});
+
+test("createMigrationPlan reports a missing .planning source without parsing", async () => {
+  const base = makeBase("gsd-migrate-plan-missing-");
+  try {
+    const result = await createMigrationPlan(base);
+
+    assert.equal(result.status, "missing-source");
+    assert.equal(result.sourcePath, join(base, ".planning"));
+    assert.equal(result.targetRoot, base);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("createMigrationPlan reports zero-slice migrations as blocked after validation", async () => {
+  const base = makeBase("gsd-migrate-plan-blocked-");
+  try {
+    mkdirSync(join(base, ".planning"), { recursive: true });
+    write(join(base, ".planning", "PROJECT.md"), "# Legacy Project\n");
+
+    const result = await createMigrationPlan(base);
+
+    assert.equal(result.status, "blocked");
+    assert.match(result.message, /zero slices/);
+    assert.equal(result.validation.valid, true);
+    assert.ok(result.warnings.some((issue) => issue.file === "ROADMAP.md"));
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import {
+  buildMigrationPreviewSummary,
+  buildReviewPrompt,
+  formatMigrationPreviewStats,
+} from "../migrate/presentation.ts";
+import { gsdRoot } from "../paths.ts";
+import type { MigrationPreview } from "../migrate/writer.ts";
+
+function previewFixture(overrides: Partial<MigrationPreview> = {}): MigrationPreview {
+  return {
+    decisions: { total: 2 },
+    migrationInputs: {
+      milestonePhaseDirs: 3,
+      decisions: 2,
+      seeds: 1,
+    },
+    milestoneCount: 1,
+    totalSlices: 2,
+    totalTasks: 5,
+    doneSlices: 1,
+    doneTasks: 3,
+    sliceCompletionPct: 50,
+    taskCompletionPct: 60,
+    requirements: {
+      active: 1,
+      validated: 2,
+      deferred: 1,
+      outOfScope: 1,
+      total: 5,
+    },
+    ...overrides,
+  };
+}
+
+test("buildMigrationPreviewSummary includes counts, legacy inputs, and existing-target warning", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrate-presentation-"));
+  try {
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    assert.deepEqual(buildMigrationPreviewSummary(previewFixture(), base), [
+      "Decisions: 2",
+      "Milestones: 1",
+      "Slices: 2 (1 done — 50%)",
+      "Tasks: 5 (3 done — 60%)",
+      "Requirements: 5 (2 validated, 1 active, 1 deferred, 1 out of scope)",
+      "Legacy inputs: 3 milestone phase dir(s), 2 decision file(s), 1 seed file(s)",
+      "",
+      `⚠ A .gsd directory already exists at ${gsdRoot(base)}.`,
+      "It will be backed up, deleted, and rewritten fresh before DB import.",
+    ]);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("formatMigrationPreviewStats uses bullet formatting for review prompts", () => {
+  assert.equal(
+    formatMigrationPreviewStats(previewFixture({ requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, total: 0 } })),
+    [
+      "- Decisions: 2",
+      "- Milestones: 1",
+      "- Slices: 2 (1 done — 50%)",
+      "- Tasks: 5 (3 done — 60%)",
+      "- Legacy inputs: 3 milestone phase dir(s), 2 decision file(s), 1 seed file(s)",
+    ].join("\n"),
+  );
+});
+
+test("buildReviewPrompt interpolates source, target, and preview stats", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-migrate-prompt-"));
+  try {
+    const promptsDir = join(base, "prompts");
+    mkdirSync(promptsDir, { recursive: true });
+    writeFileSync(
+      join(promptsDir, "review-migration.md"),
+      "Source={{sourcePath}}\nTarget={{gsdPath}}\nStats:\n{{previewStats}}\n",
+    );
+
+    const prompt = buildReviewPrompt({
+      sourcePath: "/legacy/.planning",
+      gsdPath: "/project/.gsd",
+      preview: previewFixture(),
+      templatePath: join(promptsDir, "review-migration.md"),
+    });
+
+    assert.match(prompt, /Source=\/legacy\/\.planning/);
+    assert.match(prompt, /Target=\/project\/\.gsd/);
+    assert.match(prompt, /- Requirements: 5 \(2 validated, 1 active, 1 deferred, 1 out of scope\)/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/migrate-safety-audit.test.ts

@@ -19,7 +19,7 @@ import {
   archiveLegacyPlanningDirectory,
   verifyMigrationProjection,
 } from "../migrate/audit.ts";
-import { assertMigrationDbReadiness, executeMigrationWrite, importWrittenMigrationToDb } from "../migrate/command.ts";
+import { assertMigrationDbReadiness, executeMigrationWrite, importWrittenMigrationToDb } from "../migrate/execution.ts";
 import { writeGSDDirectory } from "../migrate/writer.ts";
 import { closeDatabase, getArtifact } from "../gsd-db.ts";
 import type { GSDProject } from "../migrate/types.ts";

package/src/resources/extensions/gsd/tests/migration-auto-check.test.ts

@@ -420,6 +420,59 @@ test("migration auto-check still reports real drift with scratch dirs excluded f
   }
 });
 
+test("migration auto-check excludes sketch slice stub tasks from the markdown scan (#1286)", () => {
+  const base = makeBase();
+  try {
+    // S01 is a sketch (`[sketch]` badge): its PLAN is a stub carrying a
+    // placeholder <tasks> block until refinement. migrateHierarchyToDb skips
+    // seeding those stub tasks, so the markdown scan must skip them too — else
+    // the stub inflates the markdown count and reports false drift against a DB
+    // that (correctly) holds zero tasks for the sketch slice.
+    const roadmap = `# M001: Test Milestone
+
+**Vision:** Sketch slices must not inflate markdown task counts.
+
+## Slices
+
+- [ ] **S01: Sketch Slice** \`[sketch]\` \`risk:low\` \`depends:[]\`
+  > After this: Sketch decomposed.
+
+- [ ] **S02: Real Slice** \`risk:low\` \`depends:[]\`
+  > After this: Real work done.
+`;
+    const sketchPlan = `# S01: Sketch Slice
+
+**Goal:** Placeholder.
+
+## Tasks
+
+- [ ] **T01: Plan 01**
+  Stub placeholder task.
+`;
+    const realPlan = `# S02: Real Slice
+
+**Goal:** Real work.
+
+## Tasks
+
+- [ ] **T01: Real Task**
+  Real work.
+`;
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(join(milestoneDir, "slices", "S01"), { recursive: true });
+    mkdirSync(join(milestoneDir, "slices", "S02"), { recursive: true });
+    writeFileSync(join(milestoneDir, "M001-ROADMAP.md"), roadmap);
+    writeFileSync(join(milestoneDir, "slices", "S01", "S01-PLAN.md"), sketchPlan);
+    writeFileSync(join(milestoneDir, "slices", "S02", "S02-PLAN.md"), realPlan);
+
+    // Both slices count, but only the refined slice contributes a task; the
+    // sketch stub task is excluded, matching migrateHierarchyToDb.
+    assert.deepEqual(countMarkdownHierarchy(base), { milestones: 1, slices: 2, tasks: 1 });
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("migration auto-check still compares a roadmapless milestone that HAS a DB row", async () => {
   const base = makeBase();
   try {

package/src/resources/extensions/gsd/tests/milestone-leases.test.ts

@@ -18,6 +18,7 @@ import {
   releaseMilestoneLease,
   refreshMilestoneLease,
   getMilestoneLease,
+  forceReleaseLeasesForWorker,
 } from "../db/milestone-leases.ts";
 
 function makeBase(): string {
@@ -163,6 +164,60 @@ test("refreshMilestoneLease only succeeds with the matching fencing token", (t)
   assert.equal(refreshMilestoneLease(w1, "M001", claim.token - 1), false);
 });
 
+test("forceReleaseLeasesForWorker frees only the dead worker's leases, not a live peer's", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "One", status: "active" });
+  insertMilestone({ id: "M002", title: "Two", status: "active" });
+
+  // Distinct project roots → distinct processes (not re-entrant peers).
+  const wA = registerAutoWorker({ projectRootRealpath: base });
+  const wB = registerAutoWorker({ projectRootRealpath: join(base, "peer") });
+  assert.equal(claimMilestoneLease(wA, "M001").ok, true);
+  assert.equal(claimMilestoneLease(wB, "M002").ok, true);
+
+  const freed = forceReleaseLeasesForWorker(wA);
+  assert.equal(freed, 1, "exactly A's one held lease is released");
+
+  assert.equal(getMilestoneLease("M001")!.status, "released", "A's M001 lease is released");
+  const m2 = getMilestoneLease("M002")!;
+  assert.equal(m2.status, "held", "B's M002 lease must stay held (no over-release)");
+  assert.equal(m2.worker_id, wB);
+});
+
+test("after force release a fresh claim on the freed milestone gets a larger fencing token", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "One", status: "active" });
+
+  const wA = registerAutoWorker({ projectRootRealpath: base });
+  const wB = registerAutoWorker({ projectRootRealpath: join(base, "peer") });
+  const first = claimMilestoneLease(wA, "M001");
+  assert.equal(first.ok, true);
+  const releasedToken = first.ok ? first.token : 0;
+
+  assert.equal(forceReleaseLeasesForWorker(wA), 1);
+
+  const takeover = claimMilestoneLease(wB, "M001");
+  assert.equal(takeover.ok, true);
+  if (takeover.ok) {
+    assert.ok(takeover.token > releasedToken, "takeover token must exceed the released lease's token");
+  }
+  assert.equal(getMilestoneLease("M001")!.worker_id, wB);
+});
+
+test("forceReleaseLeasesForWorker returns 0 for a worker holding no leases", (t) => {
+  const base = makeBase();
+  t.after(() => cleanup(base));
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "One", status: "active" });
+
+  const wA = registerAutoWorker({ projectRootRealpath: base });
+  assert.equal(forceReleaseLeasesForWorker(wA), 0);
+});
+
 test("claimMilestoneLease rethrows foreign-key failures instead of treating them as lease contention", (t) => {
   const base = makeBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/parallel-eligibility-file-overlap.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Regression tests for batched touched-file collection in parallel eligibility.
+ *
+ * `collectTouchedFiles` used to run one `getSliceTasks` query per slice (N+1);
+ * it now issues a single `getTasksBySliceIds` batch and dedups paths into a
+ * Set. These tests pin the observable contract of that path through the public
+ * `analyzeParallelEligibility` API:
+ *   1. files are collected from EVERY slice of a milestone, not just the first
+ *      (a file present only in a non-first slice must still drive overlap), and
+ *   2. a path repeated across a milestone's slices is deduped (Set semantics),
+ *      so it appears once in the cross-milestone overlap.
+ */
+
+import { describe, test, beforeEach, afterEach } 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 { analyzeParallelEligibility } from "../parallel-eligibility.ts";
+import { invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+} from "../gsd-db.ts";
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parallel-elig-overlap-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeMilestoneFile(base: string, milestoneId: string, filename: string, content: string): void {
+  const filePath = join(base, ".gsd", "milestones", milestoneId, filename);
+  mkdirSync(join(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, content);
+}
+
+/**
+ * Write the on-disk planning artifacts that make a milestone eligible
+ * (CONTEXT + ROADMAP listing its slices + a PLAN per slice). Mirrors the
+ * proven-eligible setup used by parallel-eligibility-ghost.test.ts.
+ */
+function writeEligibleMilestoneFiles(base: string, milestoneId: string, sliceIds: string[]): void {
+  writeMilestoneFile(base, milestoneId, `${milestoneId}-CONTEXT.md`, `# ${milestoneId}: Fixture\n\nBatch fixture.`);
+  const roadmapSlices = sliceIds
+    .map((sid) => `- [ ] **${sid}: Slice ${sid}** \`risk:low\` \`depends:[]\`\n  > Slice ${sid}.`)
+    .join("\n");
+  writeMilestoneFile(
+    base,
+    milestoneId,
+    `${milestoneId}-ROADMAP.md`,
+    `# ${milestoneId}: Fixture\n\n## Slices\n\n${roadmapSlices}\n`,
+  );
+  for (const sid of sliceIds) {
+    writeMilestoneFile(
+      base,
+      milestoneId,
+      `slices/${sid}/${sid}-PLAN.md`,
+      `# ${sid}: Slice ${sid}\n\n**Goal:** Do ${sid}.\n**Demo:** Done.\n\n## Tasks\n\n- [ ] **T01: Task** \`est:10m\`\n  Do it.\n`,
+    );
+  }
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("parallel-eligibility: batched touched-file collection", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    cleanup(base);
+    invalidateStateCache();
+  });
+
+  test("collects files from every slice (batch) and dedups repeated paths", async () => {
+    // M001 spans two slices. `src/shared.ts` appears in BOTH slices (dedup
+    // target); `src/beta.ts` appears ONLY in the second slice S02 (proves the
+    // batch covers non-first slices). `src/alpha.ts` is unique to M001.
+    writeEligibleMilestoneFiles(base, "M001", ["S01", "S02"]);
+    insertMilestone({ id: "M001", title: "M001: Fixture", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice S01", status: "active", risk: "low", depends: [], sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Slice S02", status: "active", risk: "low", depends: [], sequence: 2 });
+    insertTask({
+      id: "T01", sliceId: "S01", milestoneId: "M001", title: "S01 task", status: "pending",
+      planning: { files: ["src/alpha.ts", "src/shared.ts"] },
+    });
+    insertTask({
+      id: "T01", sliceId: "S02", milestoneId: "M001", title: "S02 task", status: "pending",
+      planning: { files: ["src/shared.ts", "src/beta.ts"] },
+    });
+
+    // M002 overlaps M001 on both `src/shared.ts` and `src/beta.ts`.
+    writeEligibleMilestoneFiles(base, "M002", ["S01"]);
+    insertMilestone({ id: "M002", title: "M002: Fixture", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M002", title: "Slice S01", status: "active", risk: "low", depends: [], sequence: 1 });
+    insertTask({
+      id: "T01", sliceId: "S01", milestoneId: "M002", title: "S01 task", status: "pending",
+      planning: { files: ["src/shared.ts", "src/beta.ts"] },
+    });
+
+    invalidateStateCache();
+    const result = await analyzeParallelEligibility(base);
+
+    // Both milestones must be eligible so Rule 3 (file overlap) runs on them.
+    assert.ok(result.eligible.find((e) => e.milestoneId === "M001"), "M001 should be eligible");
+    assert.ok(result.eligible.find((e) => e.milestoneId === "M002"), "M002 should be eligible");
+
+    const overlap = result.fileOverlaps.find(
+      (o) =>
+        (o.mid1 === "M001" && o.mid2 === "M002") ||
+        (o.mid1 === "M002" && o.mid2 === "M001"),
+    );
+    assert.ok(overlap, "M001 and M002 must be reported as overlapping");
+
+    // `src/beta.ts` lives only in M001's SECOND slice — its presence proves the
+    // batched query collected tasks from every slice, not just the first.
+    assert.ok(
+      overlap!.files.includes("src/beta.ts"),
+      "overlap must include src/beta.ts (only present in M001's non-first slice S02)",
+    );
+    assert.ok(overlap!.files.includes("src/shared.ts"), "overlap must include src/shared.ts");
+
+    // `src/shared.ts` appears in both of M001's slices but must be deduped to a
+    // single entry (Set collection), so the sorted overlap is exactly these two.
+    assert.deepEqual(
+      [...overlap!.files].sort(),
+      ["src/beta.ts", "src/shared.ts"],
+      "overlap files must be deduped and limited to the shared paths",
+    );
+  });
+});