@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/parallel-monitor-overlay.test.ts

@@ -3,9 +3,14 @@
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
+import { createRequire } from "node:module";
+import { appendFileSync, mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { visibleWidth } from "@gsd/pi-tui";
 import { assertFullOuterBorder } from "./tui-border-assertions.ts";
+import { closeDatabase, insertMilestone, insertSlice, insertTask, openDatabase } from "../gsd-db.ts";
 
 function assertLinesFit(lines: string[], width: number): void {
   for (const line of lines) {
@@ -17,6 +22,92 @@ function assertLinesFit(lines: string[], width: number): void {
 }
 
 describe("parallel-monitor-overlay", () => {
+  it("reads worker DB progress and appended NDJSON cost without sqlite CLI or full stdout reads", async () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-parallel-overlay-"));
+    const stdoutPath = join(base, ".gsd", "parallel", "M001.stdout.log");
+    const cjsRequire = createRequire(import.meta.url);
+    const fsBuiltin = cjsRequire("node:fs") as typeof import("node:fs");
+    const childProcessBuiltin = cjsRequire("node:child_process") as typeof import("node:child_process");
+    const originalReadFileSync = fsBuiltin.readFileSync;
+    const originalSpawnSync = childProcessBuiltin.spawnSync;
+
+    try {
+      mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+      assert.equal(openDatabase(join(base, ".gsd", "gsd.db")), true);
+      insertMilestone({ id: "M001", title: "Monitor Fixture" });
+      insertSlice({ milestoneId: "M001", id: "S01", title: "Build overlay", status: "pending", sequence: 1 });
+      insertTask({
+        milestoneId: "M001",
+        sliceId: "S01",
+        id: "T01",
+        status: "complete",
+        oneLiner: "render progress",
+        sequence: 1,
+      });
+      insertTask({ milestoneId: "M001", sliceId: "S01", id: "T02", status: "pending", sequence: 2 });
+      closeDatabase();
+
+      writeFileSync(
+        join(base, ".gsd", "parallel", "M001.status.json"),
+        JSON.stringify({
+          milestoneId: "M001",
+          pid: process.pid,
+          state: "running",
+          cost: 0,
+          lastHeartbeat: Date.now(),
+          startedAt: Date.now() - 30_000,
+          worktreePath: join(base, ".gsd-worktrees", "M001"),
+        }),
+        "utf-8",
+      );
+      writeFileSync(
+        stdoutPath,
+        JSON.stringify({ type: "message_end", message: { usage: { cost: { total: 1.25 } } } }) + "\n",
+        "utf-8",
+      );
+
+      fsBuiltin.readFileSync = ((filePath: Parameters<typeof originalReadFileSync>[0], ...args: unknown[]) => {
+        if (String(filePath) === stdoutPath) throw new Error("full stdout log reads are disabled in this test");
+        return (originalReadFileSync as (...readArgs: unknown[]) => unknown)(filePath, ...args);
+      }) as typeof fsBuiltin.readFileSync;
+      childProcessBuiltin.spawnSync = ((command: Parameters<typeof originalSpawnSync>[0], ...args: unknown[]) => {
+        if (command === "sqlite3") throw new Error("sqlite3 CLI is disabled in this test");
+        return (originalSpawnSync as (...spawnArgs: unknown[]) => unknown)(command, ...args);
+      }) as typeof childProcessBuiltin.spawnSync;
+
+      const mod = await import("../parallel-monitor-overlay.js");
+      const mockTui = { requestRender: () => {} };
+      const mockTheme = {
+        fg: (_color: string, text: string) => text,
+        bold: (text: string) => text,
+      };
+      const overlay = new mod.ParallelMonitorOverlay(mockTui, mockTheme as any, () => {}, base);
+
+      try {
+        const joined = overlay.render(100).join("\n");
+        assert.match(joined, /S01:1\/2/, "slice progress should come from the in-process DB reader");
+        assert.match(joined, /S01\/T01: render progress/, "recent completions should come from the in-process DB reader");
+        assert.match(joined, /\$1\.25/, "cost should come from bounded NDJSON reads");
+
+        appendFileSync(
+          stdoutPath,
+          JSON.stringify({ type: "message_end", message: { usage: { cost: { total: 2.00 } } } }) + "\n",
+          "utf-8",
+        );
+        (overlay as any).refresh();
+        const refreshed = overlay.render(100).join("\n");
+        assert.match(refreshed, /\$3\.25/, "cost should include only newly appended NDJSON events");
+      } finally {
+        overlay.dispose();
+      }
+    } finally {
+      fsBuiltin.readFileSync = originalReadFileSync;
+      childProcessBuiltin.spawnSync = originalSpawnSync;
+      try { closeDatabase(); } catch { /* already closed */ }
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
   it("progressBar generates correct width", async () => {
     // Dynamic import to test the module loads cleanly
     const mod = await import("../parallel-monitor-overlay.js");

package/src/resources/extensions/gsd/tests/plan-milestone-boundary-map-preservation.test.ts

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
@@ -86,7 +86,12 @@ function planParams() {
 
 test('#4402 plan-milestone preserves ## Boundary Map after post-mutation projections', async (t) => {
   const base = mkdtempSync(join(tmpdir(), 'gsd-4402-'));
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+  const mDir = join(base, '.gsd', 'milestones', 'M001');
+  mkdirSync(mDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone) so the layout sniffer treats it as a
+  // real legacy milestone rather than a metadata-only placeholder.
+  writeFileSync(join(mDir, 'M001-CONTEXT.md'), '# M001\n');
   openDatabase(join(base, '.gsd', 'gsd.db'));
 
   t.after(() => {

package/src/resources/extensions/gsd/tests/plan-milestone-sketch-render.test.ts

@@ -7,7 +7,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -16,7 +16,12 @@ import { handlePlanMilestone, type PlanMilestoneParams } from "../tools/plan-mil
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-plan-sketch-render-"));
-  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  const mDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(mDir, { recursive: true });
+  // A content-bearing legacy milestone dir requires at least one non-META file
+  // (dirIsContentBearingLegacyMilestone) so the layout sniffer treats it as a
+  // real legacy milestone rather than a metadata-only placeholder.
+  writeFileSync(join(mDir, "M001-CONTEXT.md"), "# M001\n");
   openDatabase(join(base, ".gsd", "gsd.db"));
   return base;
 }

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

@@ -13,7 +13,7 @@ import { parseRoadmap } from '../parsers-legacy.ts';
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-plan-milestone-'));
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '01-test'), { recursive: true });
   return base;
 }
 
@@ -91,7 +91,7 @@ test('handlePlanMilestone writes milestone and slice planning state and renders
     assert.equal(slices[0]?.goal, 'Wire the handler.');
     assert.equal(slices[1]?.depends[0], 'S01');
 
-    const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    const roadmapPath = join(base, '.gsd', 'phases', '01-test', '01-ROADMAP.md');
     assert.ok(existsSync(roadmapPath), 'roadmap should be rendered to disk');
     const roadmap = readFileSync(roadmapPath, 'utf-8');
     assert.match(roadmap, /# M001: DB-backed planning/);
@@ -151,14 +151,17 @@ test('handlePlanMilestone surfaces render failures and does not clear parse-visi
   openDatabase(dbPath);
 
   try {
-    const fallbackRoadmapPath = join(base, '.gsd', 'milestones', 'MISSING', 'MISSING-ROADMAP.md');
+    // Block the rendered roadmap path: M999 → phaseNum=999, slug='db-backed-planning'
+    // → renderer targets phases/999-db-backed-planning/999-ROADMAP.md.
+    // Creating that path as a directory causes EISDIR → render fails.
+    const fallbackRoadmapPath = join(base, '.gsd', 'phases', '999-db-backed-planning', '999-ROADMAP.md');
     mkdirSync(fallbackRoadmapPath, { recursive: true });
 
-    const result = await handlePlanMilestone({ ...validParams(), milestoneId: 'MISSING' }, base);
+    const result = await handlePlanMilestone({ ...validParams(), milestoneId: 'M999' }, base);
     assert.ok('error' in result);
     assert.match(result.error, /render failed:/);
 
-    const existingRoadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    const existingRoadmapPath = join(base, '.gsd', 'phases', '01-test', '01-ROADMAP.md');
     writeFileSync(existingRoadmapPath, '# M001: Cached roadmap\n\n**Vision:** old value\n\n## Slices\n\n', 'utf-8');
     const cachedAfter = parseRoadmap(readFileSync(existingRoadmapPath, 'utf-8'));
     assert.equal(cachedAfter.vision, 'old value');
@@ -173,7 +176,7 @@ test('handlePlanMilestone clears parse-visible roadmap state after successful re
   openDatabase(dbPath);
 
   try {
-    const roadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
+    const roadmapPath = join(base, '.gsd', 'phases', '01-test', '01-ROADMAP.md');
     writeFileSync(roadmapPath, '# M001: Cached roadmap\n\n**Vision:** old value\n\n## Slices\n\n', 'utf-8');
 
     const cachedBefore = parseRoadmap(readFileSync(roadmapPath, 'utf-8'));

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

@@ -9,12 +9,11 @@ import { tmpdir } from 'node:os';
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getSlice, getSliceTasks, getTask, getGateResults, updateTaskStatus } from '../gsd-db.ts';
 import { handlePlanSlice } from '../tools/plan-slice.ts';
 import { parsePlan } from '../parsers-legacy.ts';
-import { parseTaskPlanFile } from '../files.ts';
 import { deriveState, invalidateStateCache } from '../state.ts';
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-plan-slice-'));
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '01-test'), { recursive: true });
   mkdirSync(join(base, 'src', 'resources', 'extensions', 'gsd', 'tools'), { recursive: true });
   writeFileSync(join(base, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-milestone.ts'), '// fixture\n', 'utf-8');
   writeFileSync(join(base, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-task.ts'), '// fixture\n', 'utf-8');
@@ -91,17 +90,14 @@ test('handlePlanSlice writes slice/task planning state and renders plan artifact
     assert.deepEqual(slice?.target_repositories, ['project']);
     assert.deepEqual(tasks[0]?.target_repositories, ['project']);
 
-    const planPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
     assert.ok(existsSync(planPath), 'slice plan should be rendered to disk');
     const parsedPlan = parsePlan(readFileSync(planPath, 'utf-8'));
     assert.equal(parsedPlan.goal, 'Persist slice planning through the DB.');
     assert.equal(parsedPlan.tasks.length, 2);
     assert.equal(parsedPlan.tasks[0]?.id, 'T01');
 
-    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T01-PLAN.md');
-    assert.ok(existsSync(taskPlanPath), 'task plan should be rendered to disk');
-    const taskPlan = parseTaskPlanFile(readFileSync(taskPlanPath, 'utf-8'));
-    assert.deepEqual(taskPlan.frontmatter.skills_used, []);
+    // Flat-phase: no per-task plan files — tasks are checkboxes inside the slice plan.
   } finally {
     cleanup(base);
   }
@@ -318,6 +314,9 @@ test('handlePlanSlice renders plan artifacts under worktree-local .gsd while usi
   const base = makeTmpBase();
   const worktree = join(base, '.gsd', 'worktrees', 'M001');
   mkdirSync(join(worktree, '.gsd'), { recursive: true });
+  // Mirror the project's phase dir into the worktree so resolveMilestonePath
+  // finds it and the renderer targets the correct flat-phase location.
+  mkdirSync(join(worktree, '.gsd', 'phases', '01-test'), { recursive: true });
   mkdirSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools'), { recursive: true });
   writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-milestone.ts'), '// fixture\n', 'utf-8');
   writeFileSync(join(worktree, 'src', 'resources', 'extensions', 'gsd', 'tools', 'plan-task.ts'), '// fixture\n', 'utf-8');
@@ -329,8 +328,8 @@ test('handlePlanSlice renders plan artifacts under worktree-local .gsd while usi
     const result = await handlePlanSlice(validParams(), worktree);
     assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
 
-    const worktreePlan = join(worktree, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
-    const projectPlan = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    const worktreePlan = join(worktree, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    const projectPlan = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
     assert.ok(existsSync(worktreePlan), 'slice plan should be rendered to worktree-local .gsd');
     assert.ok(!existsSync(projectPlan), 'slice plan should not be rendered to project .gsd');
     assert.equal(result.planPath, realpathSync(worktreePlan));
@@ -339,6 +338,36 @@ test('handlePlanSlice renders plan artifacts under worktree-local .gsd while usi
   }
 });
 
+test('handlePlanSlice does not regenerate unrelated completed-task summaries during planning', async () => {
+  const base = makeTmpBase();
+  openDatabase(join(base, '.gsd', 'gsd.db'));
+
+  try {
+    insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
+    insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Finished slice', status: 'complete', demo: 'Existing work.' });
+    insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.' });
+    insertTask({
+      id: 'T99',
+      sliceId: 'S01',
+      milestoneId: 'M001',
+      title: 'Already complete',
+      status: 'complete',
+      fullSummaryMd: '# T99 Summary\n\nAlready done.\n',
+    });
+
+    const unrelatedSummaryPath = join(base, '.gsd', 'phases', '01-test', 'T99-SUMMARY.md');
+    assert.equal(existsSync(unrelatedSummaryPath), false, 'fixture should start without unrelated summary projection');
+
+    const result = await handlePlanSlice(validParams(), base);
+    assert.ok(!('error' in result), `unexpected error: ${'error' in result ? result.error : ''}`);
+
+    assert.equal(existsSync(unrelatedSummaryPath), false, 'plan-slice should not flush all milestone summaries');
+    assert.ok(existsSync(join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md')), 'current slice plan still renders');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('handlePlanSlice preserves completed task closeout state when replanning the same task', async () => {
   const base = makeTmpBase();
   openDatabase(join(base, '.gsd', 'gsd.db'));
@@ -435,9 +464,10 @@ test('handlePlanSlice preserves sketch flag when render fails before artifacts e
     insertMilestone({ id: 'M001', title: 'Milestone', status: 'active' });
     insertSlice({ id: 'S02', milestoneId: 'M001', title: 'Planning slice', status: 'pending', demo: 'Rendered plans exist.', isSketch: true });
 
-    const sliceDir = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02');
-    rmSync(sliceDir, { recursive: true, force: true });
-    writeFileSync(sliceDir, 'not a directory', 'utf-8');
+    // Block the rendered plan path by creating a directory where the file would go.
+    // The renderer resolves M001/S02 → phases/01-test/01-02-PLAN.md; creating that
+    // path as a directory causes EISDIR on write → render fails → sketch flag preserved.
+    mkdirSync(join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md'), { recursive: true });
 
     const result = await handlePlanSlice(validParams(), base);
     assert.ok('error' in result);
@@ -470,7 +500,7 @@ test('handlePlanSlice leaves omitted enrichment fields empty instead of renderin
     assert.equal(slice?.integration_closure, '');
     assert.equal(slice?.observability_impact, '');
 
-    const planPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md');
+    const planPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
     const content = readFileSync(planPath, 'utf-8');
     assert.doesNotMatch(content, /Not provided/i);
     assert.doesNotMatch(content, /^## Proof Level$/m);
@@ -644,8 +674,9 @@ test('handlePlanSlice surfaces render failures without changing parse-visible ta
 
   try {
     seedParentSlice();
-    const failingTaskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T01-PLAN.md');
-    writeFileSync(failingTaskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T01: Cached task\n', 'utf-8');
+    // Flat-phase: per-task plan files don't exist; simulate a write failure on the slice plan
+    const failingTaskPlanPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    writeFileSync(failingTaskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# Cached plan\n', 'utf-8');
     rmSync(failingTaskPlanPath, { force: true });
     mkdirSync(failingTaskPlanPath, { recursive: true });
 
@@ -683,7 +714,7 @@ test('handlePlanSlice reruns idempotently and refreshes parse-visible state', as
 
   try {
     seedParentSlice();
-    writeFileSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md'), '# S02: Cached\n\n**Goal:** old value\n\n## Tasks\n\n- [ ] **T01: Cached task**\n', 'utf-8');
+    writeFileSync(join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md'), '# S02: Cached\n\n**Goal:** old value\n\n## Tasks\n\n- [ ] **T01: Cached task**\n', 'utf-8');
 
     const first = await handlePlanSlice(validParams(), base);
     assert.ok(!('error' in first));
@@ -698,7 +729,7 @@ test('handlePlanSlice reruns idempotently and refreshes parse-visible state', as
     }, base);
     assert.ok(!('error' in second));
 
-    const parsedAfter = parsePlan(readFileSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'S02-PLAN.md'), 'utf-8'));
+    const parsedAfter = parsePlan(readFileSync(join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md'), 'utf-8'));
     assert.equal(parsedAfter.goal, 'Updated goal from rerun.');
     const task = getTask('M001', 'S02', 'T01');
     assert.equal(task?.description, 'Updated slice handler description.');
@@ -724,8 +755,10 @@ test('handlePlanSlice removes omitted pending tasks when replanning a smaller ta
 
     const first = await handlePlanSlice(fourTaskPlan, base);
     assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
-    const staleTaskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T04-PLAN.md');
-    assert.ok(existsSync(staleTaskPlanPath), 'initial plan should render T04');
+    // In flat-phase mode tasks are checkboxes in the slice plan; no per-task plan files.
+    const slicePlanPath = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    assert.ok(existsSync(slicePlanPath), 'initial plan should exist');
+    assert.match(readFileSync(slicePlanPath, 'utf-8'), /T04/, 'initial plan should contain T04');
 
     const second = await handlePlanSlice({
       ...validParams(),
@@ -735,7 +768,7 @@ test('handlePlanSlice removes omitted pending tasks when replanning a smaller ta
 
     assert.deepEqual(getSliceTasks('M001', 'S02').map((task) => task.id), ['T01', 'T02', 'T03']);
     assert.equal(getGateResults('M001', 'S02', 'task').some((gate) => gate.task_id === 'T04'), false);
-    assert.equal(existsSync(staleTaskPlanPath), false, 'omitted task plan artifact should be removed');
+    assert.doesNotMatch(readFileSync(slicePlanPath, 'utf-8'), /T04/, 'omitted T04 should be removed from plan');
   } finally {
     cleanup(base);
   }
@@ -758,8 +791,10 @@ test('handlePlanSlice rejects omitted completed tasks without changing slice or
 
     const first = await handlePlanSlice(fourTaskPlan, base);
     assert.ok(!('error' in first), `unexpected error: ${'error' in first ? first.error : ''}`);
-    const staleTaskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T04-PLAN.md');
-    assert.ok(existsSync(staleTaskPlanPath), 'initial plan should render T04');
+    // In flat-phase mode tasks are checkboxes in the slice plan; no per-task plan files.
+    const slicePlanPathR = join(base, '.gsd', 'phases', '01-test', '01-02-PLAN.md');
+    assert.ok(existsSync(slicePlanPathR), 'initial plan should exist');
+    assert.match(readFileSync(slicePlanPathR, 'utf-8'), /T04/, 'initial plan should contain T04');
 
     updateTaskStatus('M001', 'S02', 'T04', 'complete', '2026-05-12T00:00:00.000Z');
     const tasksBefore = getSliceTasks('M001', 'S02');
@@ -775,7 +810,7 @@ test('handlePlanSlice rejects omitted completed tasks without changing slice or
     assert.equal(getSlice('M001', 'S02')?.goal, 'Persist slice planning through the DB.');
     assert.deepEqual(getSliceTasks('M001', 'S02'), tasksBefore);
     assert.deepEqual(getGateResults('M001', 'S02', 'task'), gatesBefore);
-    assert.ok(existsSync(staleTaskPlanPath), 'completed task plan artifact should remain after rejected replan');
+    assert.match(readFileSync(slicePlanPathR, 'utf-8'), /T04/, 'completed task T04 should remain in plan after rejected replan');
   } finally {
     cleanup(base);
   }

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

@@ -10,7 +10,7 @@ import { parseTaskPlanFile } from '../files.ts';
 
 function makeTmpBase(): string {
   const base = mkdtempSync(join(tmpdir(), 'gsd-plan-task-'));
-  mkdirSync(join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks'), { recursive: true });
+  mkdirSync(join(base, '.gsd', 'phases', '01-test'), { recursive: true });
   return base;
 }
 
@@ -55,7 +55,7 @@ test('handlePlanTask writes planning state and renders task plan', async () => {
     assert.equal(task?.description, 'Implement the DB-backed task planning handler.');
     assert.equal(task?.estimate, '30m');
 
-    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T02-PLAN.md');
+    const taskPlanPath = join(base, '.gsd', 'phases', '01-test', 'T02-PLAN.md');
     assert.ok(existsSync(taskPlanPath), 'task plan should be rendered to disk');
     const taskPlan = parseTaskPlanFile(readFileSync(taskPlanPath, 'utf-8'));
     assert.equal(taskPlan.frontmatter.estimated_files, 1);
@@ -157,7 +157,7 @@ test('handlePlanTask surfaces render failures without changing parse-visible tas
   try {
     seedParent();
     insertTask({ id: 'T02', sliceId: 'S02', milestoneId: 'M001', title: 'Cached task', status: 'pending' });
-    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T02-PLAN.md');
+    const taskPlanPath = join(base, '.gsd', 'phases', '01-test', 'T02-PLAN.md');
     writeFileSync(taskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T02: Cached task\n', 'utf-8');
     rmSync(taskPlanPath, { force: true });
     mkdirSync(taskPlanPath, { recursive: true });
@@ -176,7 +176,7 @@ test('handlePlanTask reruns idempotently and refreshes parse-visible state', asy
 
   try {
     seedParent();
-    const taskPlanPath = join(base, '.gsd', 'milestones', 'M001', 'slices', 'S02', 'tasks', 'T02-PLAN.md');
+    const taskPlanPath = join(base, '.gsd', 'phases', '01-test', 'T02-PLAN.md');
     writeFileSync(taskPlanPath, '---\nestimated_steps: 1\nestimated_files: 1\nskills_used: []\n---\n\n# T02: Cached task\n', 'utf-8');
 
     const first = await handlePlanTask(validParams(), base);

package/src/resources/extensions/gsd/tests/planning-crossval.test.ts

@@ -90,6 +90,8 @@ console.log('\n=== planning-crossval Test 1: ROADMAP round-trip parity ===');
 
     // Render ROADMAP.md from DB
     const rendered = await renderRoadmapFromDb(base, 'M001');
+    // Milestone has planned slices — skipped variant is unreachable here.
+    if ('skipped' in rendered) throw new Error('unexpected: milestone has planned slices');
     const content = readFileSync(rendered.roadmapPath, 'utf-8');
 
     // Parse back
@@ -279,6 +281,8 @@ console.log('\n=== planning-crossval Test 3: Sequence ordering parity ===');
 
     // Render ROADMAP from DB — should produce slices in sequence order
     const rendered = await renderRoadmapFromDb(base, 'M001');
+    // Milestone has planned slices — skipped variant is unreachable here.
+    if ('skipped' in rendered) throw new Error('unexpected: milestone has planned slices');
     const content = readFileSync(rendered.roadmapPath, 'utf-8');
 
     // Parse back
@@ -312,6 +316,7 @@ console.log('\n=== planning-crossval Test 4: ROADMAP worktree projection path ==
   const base = createFixtureBase();
   const worktreeBase = join(base, '.gsd', 'worktrees', 'M001');
   const worktreeGsd = join(worktreeBase, '.gsd');
+  // Both base and worktree use the legacy milestones/ layout (no phases/ dir).
   const projectRoadmapPath = join(base, '.gsd', 'milestones', 'M001', 'M001-ROADMAP.md');
   const worktreeRoadmapPath = join(worktreeGsd, 'milestones', 'M001', 'M001-ROADMAP.md');
   const dbPath = join(base, '.gsd', 'gsd.db');
@@ -320,6 +325,10 @@ console.log('\n=== planning-crossval Test 4: ROADMAP worktree projection path ==
   try {
     scaffoldDirs(base, 'M001', []);
     mkdirSync(join(worktreeGsd, 'milestones', 'M001'), { recursive: true });
+    // Add a content file so the worktree M001 dir passes dirIsContentBearingLegacyMilestone.
+    // Without this, an empty dir is treated as a metadata-only dir (post-#852 guard) and
+    // resolveMilestonePath returns null, causing the renderer to write to a flat-phase path.
+    writeFileSync(join(worktreeGsd, 'milestones', 'M001', 'M001-CONTEXT.md'), '# M001\n');
     writeFileSync(projectRoadmapPath, '# stale project roadmap\n');
 
     insertMilestone({
@@ -340,6 +349,8 @@ console.log('\n=== planning-crossval Test 4: ROADMAP worktree projection path ==
     });
 
     const rendered = await renderRoadmapFromDb(worktreeBase, 'M001');
+    // Milestone has a planned slice — skipped variant is unreachable here.
+    if ('skipped' in rendered) throw new Error('unexpected: milestone has planned slices');
 
     assertEq(rendered.roadmapPath, worktreeRoadmapPath, 'T4: roadmap path uses worktree projection');
     assertTrue(existsSync(worktreeRoadmapPath), 'T4: worktree roadmap exists');
@@ -359,6 +370,7 @@ console.log('\n=== planning-crossval Test 5: ROADMAP existing projection file pa
   const base = createFixtureBase();
   const worktreeBase = join(base, '.gsd', 'worktrees', 'M001');
   const worktreeGsd = join(worktreeBase, '.gsd');
+  // Legacy milestones/ layout: roadmap filename is M001-ROADMAP.md (not NN-ROADMAP.md).
   const worktreeRoadmapPath = join(worktreeGsd, 'milestones', 'M001', 'M001-ROADMAP.md');
   const dbPath = join(base, '.gsd', 'gsd.db');
   const originalCwd = process.cwd();
@@ -377,6 +389,8 @@ console.log('\n=== planning-crossval Test 5: ROADMAP existing projection file pa
     });
 
     const rendered = await renderRoadmapFromDb(worktreeBase, 'M001');
+    // Milestone has a non-empty vision — skipped variant is unreachable here.
+    if ('skipped' in rendered) throw new Error('unexpected: milestone has non-empty vision');
 
     assertEq(rendered.roadmapPath, worktreeRoadmapPath, 'T5: existing roadmap path remains absolute');
     assertTrue(existsSync(worktreeRoadmapPath), 'T5: worktree roadmap still exists');
@@ -397,6 +411,7 @@ console.log('\n=== planning-crossval Test 6: ROADMAP descriptor projection dir =
   const worktreeBase = join(base, '.gsd', 'worktrees', 'M001');
   const worktreeGsd = join(worktreeBase, '.gsd');
   const descriptorMilestoneDir = join(worktreeGsd, 'milestones', 'M001-DESCRIPTOR');
+  // Legacy milestones/ layout: roadmap filename is M001-ROADMAP.md (not NN-ROADMAP.md).
   const descriptorRoadmapPath = join(descriptorMilestoneDir, 'M001-ROADMAP.md');
   const bareMilestoneDir = join(worktreeGsd, 'milestones', 'M001');
   const dbPath = join(base, '.gsd', 'gsd.db');
@@ -414,6 +429,8 @@ console.log('\n=== planning-crossval Test 6: ROADMAP descriptor projection dir =
     });
 
     const rendered = await renderRoadmapFromDb(worktreeBase, 'M001');
+    // Milestone has a non-empty vision — skipped variant is unreachable here.
+    if ('skipped' in rendered) throw new Error('unexpected: milestone has non-empty vision');
 
     assertEq(rendered.roadmapPath, descriptorRoadmapPath, 'T6: roadmap path uses descriptor milestone dir');
     assertTrue(existsSync(descriptorRoadmapPath), 'T6: descriptor roadmap exists');
@@ -455,6 +472,8 @@ console.log('\n=== planning-crossval Test 7: renderer recovers bracket-wrapped d
       .run('["[S01]"]', 'S02', 'M001');
 
     const rendered = await renderRoadmapFromDb(base, 'M001');
+    // Milestone has planned slices — skipped variant is unreachable here.
+    if ('skipped' in rendered) throw new Error('unexpected: milestone has planned slices');
     const content = readFileSync(rendered.roadmapPath, 'utf-8');
     const parsed = parseRoadmapSlices(content);
 

package/src/resources/extensions/gsd/tests/planning-layout-detect.test.ts

@@ -0,0 +1,84 @@
+// Project/App: gsd-pi
+// File Purpose: Tests for .planning/ layout classification.
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { detectPlanningLayout } from "../migrate/layout-detect.ts";
+import type { PlanningProject } from "../migrate/types.ts";
+
+function emptyProject(over: Partial<PlanningProject> = {}): PlanningProject {
+  return {
+    path: "", project: null, roadmap: null, requirements: [], state: null,
+    config: null, phases: {}, quickTasks: [], milestones: [], research: [],
+    decisions: [], seeds: [], validation: { valid: true, issues: [] },
+    ...over,
+  } as PlanningProject;
+}
+
+test("detectPlanningLayout returns legacy-milestone-dir when milestones/ has phases", () => {
+  const p = emptyProject({
+    milestones: [{
+      id: "v1.0",
+      requirements: null,
+      roadmap: null,
+      phases: { "01-foo": {} as never },
+      extraFiles: [],
+    }],
+  });
+  assert.equal(detectPlanningLayout(p), "legacy-milestone-dir");
+});
+
+test("detectPlanningLayout returns multi-milestone when roadmap.milestones non-empty", () => {
+  const p = emptyProject({
+    roadmap: {
+      raw: "",
+      milestones: [{ id: "v1", title: "V1", collapsed: false, phases: [] }],
+      phases: [],
+    },
+  });
+  assert.equal(detectPlanningLayout(p), "multi-milestone");
+});
+
+test("detectPlanningLayout returns flat-phases when roadmap.phases non-empty and no milestone dirs", () => {
+  const p = emptyProject({
+    roadmap: {
+      raw: "",
+      milestones: [],
+      phases: [{ number: 1, title: "Foo", done: false, raw: "" }],
+    },
+  });
+  assert.equal(detectPlanningLayout(p), "flat-phases");
+});
+
+test("detectPlanningLayout returns null when nothing recognizable", () => {
+  assert.equal(detectPlanningLayout(emptyProject()), null);
+});
+
+test("priority: legacy-milestone-dir wins over multi-milestone", () => {
+  const p = emptyProject({
+    milestones: [{
+      id: "v1.0",
+      requirements: null,
+      roadmap: null,
+      phases: { "01-foo": {} as never },
+      extraFiles: [],
+    }],
+    roadmap: {
+      raw: "",
+      milestones: [{ id: "v1", title: "V1", collapsed: false, phases: [] }],
+      phases: [],
+    },
+  });
+  assert.equal(detectPlanningLayout(p), "legacy-milestone-dir");
+});
+
+test("priority: multi-milestone wins over flat-phases when both roadmap arrays non-empty", () => {
+  const p = emptyProject({
+    roadmap: {
+      raw: "",
+      milestones: [{ id: "v1", title: "V1", collapsed: false, phases: [] }],
+      phases: [{ number: 1, title: "Foo", done: false, raw: "" }],
+    },
+  });
+  assert.equal(detectPlanningLayout(p), "multi-milestone");
+});