@opengsd/gsd-pi 1.8.1 → 1.9.0

package/src/resources/extensions/gsd/tests/rework-brief.test.ts

@@ -0,0 +1,197 @@
+import { createTestContext } from './test-helpers.ts';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import {
+  openDatabase,
+  closeDatabase,
+  _getAdapter,
+  type ReworkBriefFindingInput,
+} from '../gsd-db.ts';
+import { handleReworkBriefSave } from '../tools/rework-brief.ts';
+
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Helpers
+// ═══════════════════════════════════════════════════════════════════════════
+
+function tempDbPath(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-rework-brief-'));
+  return path.join(dir, 'test.db');
+}
+
+function cleanup(dbPath: string): void {
+  closeDatabase();
+  try {
+    const dir = path.dirname(dbPath);
+    for (const f of fs.readdirSync(dir)) fs.unlinkSync(path.join(dir, f));
+    fs.rmdirSync(dir);
+  } catch {
+    // best effort
+  }
+}
+
+function finding(overrides: Partial<ReworkBriefFindingInput> = {}): ReworkBriefFindingInput {
+  return {
+    findingId: 'F1',
+    severity: 'blocking',
+    description: 'Compile regression',
+    requiredFix: 'Fix compile error',
+    verificationCommands: ['pnpm run typecheck:extensions'],
+    ...overrides,
+  };
+}
+
+const baseParams = {
+  briefId: 'RB-001',
+  milestoneId: 'M001',
+  sliceId: 'S01',
+  taskId: 'T01',
+};
+
+function findingRow(): { status: string; evidence: string; decision_ref: string } | undefined {
+  return _getAdapter()!
+    .prepare("SELECT status, evidence, decision_ref FROM rework_brief_findings WHERE brief_id = 'RB-001' AND finding_id = 'F1'")
+    .get() as { status: string; evidence: string; decision_ref: string } | undefined;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// rework-brief: a blocking finding saved as non-pending must carry the same
+// justification a reworkResolution would, otherwise it bypasses the
+// gsd_task_complete blocking gate (which only sees `pending` rows).
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== rework-brief: rejects blocking resolved finding without evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'resolved' })],
+  });
+
+  assertTrue('error' in result, 'blocking resolved finding without evidence should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /evidence is required/i, 'error should mention the evidence requirement');
+  }
+  const rows = _getAdapter()!.prepare('SELECT COUNT(*) AS n FROM rework_brief_findings').get() as { n: number };
+  assertEq(rows.n, 0, 'no finding rows should be persisted when validation fails');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: rejects blocking deferred-with-override without decisionRef ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'deferred-with-override', evidence: 'Maintainer accepted temporary deferral.' })],
+  });
+
+  assertTrue('error' in result, 'deferred-with-override without decisionRef should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /decisionRef is required/i, 'error should mention the decisionRef requirement');
+  }
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: rejects invalid finding status ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'bogus' as unknown as ReworkBriefFindingInput['status'] })],
+  });
+
+  assertTrue('error' in result, 'an unknown status value should be rejected');
+  if ('error' in result) {
+    assertMatch(result.error, /status must be/i, 'error should name the allowed statuses');
+  }
+
+  cleanup(dbPath);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// rework-brief: legitimate saves still succeed.
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log('\n=== rework-brief: blocking finding defaults to pending ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding()],
+  });
+
+  assertTrue(!('error' in result), 'a blocking finding without a status should be accepted');
+  assertEq(findingRow()?.status, 'pending', 'finding without status should default to pending');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: accepts blocking resolved finding with evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ status: 'resolved', evidence: 'Fixed compile error and reran pnpm run typecheck:extensions.' })],
+  });
+
+  assertTrue(!('error' in result), 'a resolved blocking finding with evidence should be accepted');
+  assertEq(findingRow()?.status, 'resolved', 'finding should persist as resolved when evidence is supplied');
+  assertMatch(findingRow()?.evidence ?? '', /Fixed compile error/, 'resolution evidence should be persisted');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: accepts blocking deferred-with-override with evidence and decisionRef ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({
+      status: 'deferred-with-override',
+      evidence: 'Maintainer accepted temporary deferral.',
+      decisionRef: 'DEC-2026-07-07-rework-deferral',
+    })],
+  });
+
+  assertTrue(!('error' in result), 'a deferred-with-override finding with evidence and decisionRef should be accepted');
+  assertEq(findingRow()?.status, 'deferred-with-override', 'finding should persist the override status');
+  assertEq(findingRow()?.decision_ref, 'DEC-2026-07-07-rework-deferral', 'decision reference should be persisted');
+
+  cleanup(dbPath);
+}
+
+console.log('\n=== rework-brief: advisory resolved finding does not require evidence ===');
+{
+  const dbPath = tempDbPath();
+  openDatabase(dbPath);
+
+  // Advisory findings never gate gsd_task_complete, so pre-resolving one
+  // without evidence is harmless and stays permitted.
+  const result = await handleReworkBriefSave({
+    ...baseParams,
+    findings: [finding({ severity: 'advisory', status: 'resolved' })],
+  });
+
+  assertTrue(!('error' in result), 'an advisory resolved finding should be accepted without evidence');
+  assertEq(findingRow()?.status, 'resolved', 'advisory finding status should be preserved');
+
+  cleanup(dbPath);
+}
+
+report();

package/src/resources/extensions/gsd/tests/skip-slice-cascades-tasks.test.ts

@@ -25,6 +25,7 @@ import {
   updateTaskStatus,
 } from "../gsd-db.ts";
 import { handleSkipSlice } from "../tools/skip-slice.ts";
+import { skipSliceCascade } from "../db/writers/cascades.ts";
 
 describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
   let dir: string;
@@ -122,4 +123,24 @@ describe("handleSkipSlice cascades skip to tasks (#4375)", () => {
     assert.match(result.error!, /not found/i);
     assert.equal(result.errorCode, "slice_not_found");
   });
+
+  test("skipSliceCascade rejects a slice in the legacy 'closed' status without nulling completed_at", () => {
+    const completedAt = "2026-01-01T00:00:00.000Z";
+    updateSliceStatus("M001", "S03", "closed", completedAt);
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.deepEqual(outcome, { ok: false, reason: "slice-already-complete" });
+
+    const slice = getSlice("M001", "S03");
+    assert.equal(slice?.status, "closed", "closed slice must not be downgraded to skipped");
+    assert.equal(slice?.completed_at, completedAt, "completed_at must be preserved");
+  });
+
+  test("skipSliceCascade still re-skips an already-skipped slice (ok, wasAlreadySkipped)", () => {
+    updateSliceStatus("M001", "S03", "skipped");
+
+    const outcome = skipSliceCascade("M001", "S03");
+    assert.equal(outcome.ok, true);
+    if (outcome.ok) assert.equal(outcome.wasAlreadySkipped, true);
+  });
 });

package/src/resources/extensions/gsd/tests/stop-notice.test.ts

@@ -14,6 +14,7 @@ import {
   isPauseNotice,
   isBlockedNoticeMessage,
   isManualResolutionNotice,
+  isInteractiveMenuUnavailableNotice,
   PAUSED_NOTICE_PREFIXES,
   TERMINAL_NOTICE_PREFIXES,
 } from "../stop-notice.js";
@@ -62,6 +63,22 @@ describe("emitter↔detector round-trip", () => {
     assert.ok(isBlockedNoticeMessage(message));
   });
 
+  test("un-showable menu notices classify as blocked (#1294)", () => {
+    // Emitted verbatim by notifyCommandMenuUnavailable (next-action-ui.ts / command-feedback.ts).
+    const menuUnavailable =
+      "gsd — m002: editorial hn menu could not be shown in this session.\nrun /gsd when ready.";
+    assert.ok(isInteractiveMenuUnavailableNotice(menuUnavailable));
+    assert.ok(isBlockedNoticeMessage(menuUnavailable));
+
+    // Emitted by notifyPickerCommandNeedsInteractiveMenu (command-feedback.ts).
+    const pickerGuidance = "/gsd did not start: milestone menu needs an interactive session";
+    assert.ok(isInteractiveMenuUnavailableNotice(pickerGuidance));
+    assert.ok(isBlockedNoticeMessage(pickerGuidance));
+
+    // Unrelated notices are not swept up.
+    assert.equal(isInteractiveMenuUnavailableNotice("auto-mode complete"), false);
+  });
+
   test("terminal prefixes cover the known stop vocabulary", () => {
     for (const message of ["auto-mode stopped.", "auto-mode complete", "auto-mode idle", "no active milestone"]) {
       assert.ok(TERMINAL_NOTICE_PREFIXES.some((prefix) => message.startsWith(prefix)), message);

package/src/resources/extensions/gsd/tests/sync-lock.test.ts

@@ -174,3 +174,22 @@ test('sync-lock: contended fresh lock fails fast without honoring long sync time
     cleanupDir(base);
   }
 });
+
+test('sync-lock: uncreatable lock path fails open instead of spinning forever', () => {
+  const base = tempDir();
+  try {
+    // `.gsd` is a dangling symlink to a missing target: the O_EXCL open lands
+    // on a missing parent and throws non-EEXIST on every attempt. Without the
+    // fail-open guard the retry loop spins forever, blocking the event loop.
+    fs.symlinkSync(path.join(base, 'missing-external-state'), path.join(base, '.gsd'), 'junction');
+
+    const startedAt = performance.now();
+    const result = acquireSyncLock(base, 0, 'write-gate.lock');
+    const elapsedMs = performance.now() - startedAt;
+
+    assert.strictEqual(result.acquired, false, 'uncreatable lock path must fail open, not acquire');
+    assert.ok(elapsedMs < 250, `must return promptly, not spin; elapsed=${elapsedMs.toFixed(1)}ms`);
+  } finally {
+    cleanupDir(base);
+  }
+});

package/src/resources/extensions/gsd/tests/unit-context-composer.test.ts

@@ -43,6 +43,8 @@ import {
   insertMilestone,
   upsertMilestonePlanning,
   insertSlice,
+  insertTask,
+  saveReworkBrief,
 } from "../gsd-db.ts";
 
 // ─── Pure composer tests ──────────────────────────────────────────────────
@@ -518,6 +520,38 @@ test("#4782 phase 2: buildReassessRoadmapPrompt emits composer-shaped context wi
   assert.ok(!prompt.includes("Slice Context (from discussion)"));
 });
 
+
+test("execute-task prompt injects unresolved blocking rework findings", async (t) => {
+  const base = makeFixtureBase();
+  t.after(() => cleanup(base));
+  invalidateAllCaches();
+
+  seed(base, "M001");
+  writeArtifacts(base);
+  insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+  saveReworkBrief({
+    briefId: "RB-001",
+    milestoneId: "M001",
+    sliceId: "S01",
+    taskId: "T01",
+    findings: [{
+      findingId: "F1",
+      severity: "blocking",
+      description: "Compile regression",
+      requiredFix: "Restore typecheck",
+      verificationCommands: ["pnpm run typecheck:extensions"],
+    }],
+  });
+
+  const prompt = await buildExecuteTaskPrompt("M001", "S01", "First", "T01", "Task", base);
+
+  assert.match(prompt, /Blocking Rework Findings \(non-optional\)/);
+  assert.match(prompt, /F1/);
+  assert.match(prompt, /Compile regression/);
+  assert.match(prompt, /pnpm run typecheck:extensions/);
+  assert.match(prompt, /reworkResolution/);
+});
+
 test("execute-task prompt omits on-demand slice research when the artifact is absent", async (t) => {
   const base = makeFixtureBase();
   t.after(() => cleanup(base));

package/src/resources/extensions/gsd/tests/uok-plan-v2-wiring.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -239,6 +239,98 @@ test("plan-v2 ensure rejects empty executable graph", () => {
   assert.equal(isEmptyPlanV2GraphResult(compiled), true);
 });
 
+function seedMultiSliceRows(): void {
+  insertMilestone({ id: MILESTONE_ID, title: "Milestone", status: "active" });
+  const slices: Array<[string, number, Array<[string, number]>]> = [
+    ["S01", 1, [["T01", 1], ["T02", 2]]],
+    ["S02", 2, [["T03", 1], ["T04", 2]]],
+  ];
+  for (const [sid, sseq, tasks] of slices) {
+    insertSlice({ id: sid, milestoneId: MILESTONE_ID, title: `Slice ${sid}`, status: "in_progress", sequence: sseq });
+    for (const [tid, tseq] of tasks) {
+      insertTask({
+        id: tid,
+        milestoneId: MILESTONE_ID,
+        sliceId: sid,
+        title: `Task ${tid}`,
+        status: "pending",
+        keyFiles: [`src/${tid}.ts`],
+        sequence: tseq,
+      });
+    }
+  }
+}
+
+test("plan-v2 batched compile preserves node ids, order, and count", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const compiled = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(compiled.ok, true);
+
+  const graph = JSON.parse(readFileSync(compiled.graphPath ?? "", "utf-8")) as {
+    nodes: Array<{ id: string }>;
+  };
+  assert.deepEqual(
+    graph.nodes.map((n) => n.id),
+    [
+      "execute-task:M001:S01:T01",
+      "execute-task:M001:S01:T02",
+      "complete-slice:M001:S01",
+      "execute-task:M001:S02:T03",
+      "execute-task:M001:S02:T04",
+      "complete-slice:M001:S02",
+    ],
+  );
+});
+
+test("plan-v2 skips the disk write when the graph is unchanged", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(first.ok, true);
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+
+  // Backdate mtime so a rewrite is detectable even within the same millisecond.
+  utimesSync(graphPath, 1000, 1000);
+  const backdatedMtime = statSync(graphPath).mtimeMs;
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.equal(statSync(graphPath).mtimeMs, backdatedMtime, "identical state must not rewrite the graph");
+  assert.equal(readFileSync(graphPath, "utf-8"), before);
+});
+
+test("plan-v2 rewrites the graph when it changes", () => {
+  const basePath = createBasePath();
+  seedMultiSliceRows();
+  writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");
+
+  const first = ensurePlanV2Graph(basePath, buildState("executing"));
+  const graphPath = first.graphPath ?? "";
+  const before = readFileSync(graphPath, "utf-8");
+  utimesSync(graphPath, 1000, 1000);
+
+  insertTask({
+    id: "T05",
+    milestoneId: MILESTONE_ID,
+    sliceId: "S02",
+    title: "Added task",
+    status: "pending",
+    keyFiles: ["src/T05.ts"],
+    sequence: 3,
+  });
+
+  const second = ensurePlanV2Graph(basePath, buildState("executing"));
+  assert.equal(second.ok, true);
+  assert.notEqual(statSync(graphPath).mtimeMs, 1000000, "changed graph must rewrite");
+  assert.notEqual(readFileSync(graphPath, "utf-8"), before);
+});
+
 test("plan-v2 allows empty graph for milestone terminal phases", () => {
   const basePath = createBasePath();
   writeMilestoneFile(basePath, "CONTEXT", "Finalized context.");

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

@@ -94,6 +94,8 @@ test("complete-slice requires status, closeout, and execution handoff tools", ()
     "gsd_slice_complete",
     "gsd_task_reopen",
     "gsd_replan_slice",
+    "gsd_replan_task",
+    "gsd_rework_brief_save",
     "gsd_requirement_update",
     "gsd_summary_save",
   ];

package/src/resources/extensions/gsd/tests/workflow-migration-gates.test.ts

@@ -0,0 +1,139 @@
+// GSD Extension - Auto-migration gate tests (plan 026).
+// Covers needsAutoMigration's trigger (empty milestones table + .gsd/milestones
+// present) and validateMigration's engine-vs-markdown count comparison.
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+
+import { openDatabase, closeDatabase, insertMilestone, insertSlice } from '../gsd-db.ts';
+import { needsAutoMigration, validateMigration } from '../workflow-migration.ts';
+
+function makeProject(): string {
+  return mkdtempSync(join(tmpdir(), 'gsd-migration-gates-'));
+}
+
+function openProjectDb(base: string): string {
+  const gsdDir = join(base, '.gsd');
+  mkdirSync(gsdDir, { recursive: true });
+  const dbPath = join(gsdDir, 'gsd.db');
+  assert.ok(openDatabase(dbPath), 'openDatabase should succeed');
+  return dbPath;
+}
+
+function cleanup(base: string): void {
+  closeDatabase();
+  rmSync(base, { recursive: true, force: true });
+}
+
+function writeRoadmap(base: string, mId: string, sliceLines: string[]): void {
+  const mDir = join(base, '.gsd', 'milestones', mId);
+  mkdirSync(mDir, { recursive: true });
+  writeFileSync(join(mDir, 'ROADMAP.md'), [
+    `# ${mId}: Test`,
+    '',
+    '## Slices',
+    '',
+    ...sliceLines,
+    '',
+  ].join('\n'));
+}
+
+describe('needsAutoMigration', () => {
+  test('false for a fresh project with no legacy markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      assert.equal(needsAutoMigration(base), false, 'no .gsd/milestones dir → no migration');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('true when engine tables are empty and .gsd/milestones exists', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      assert.equal(needsAutoMigration(base), true, 'legacy markdown + empty engine → migrate');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('false once the milestones table has rows (migration already done)', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      insertMilestone({ id: 'M001', title: 'Migrated' });
+      assert.equal(needsAutoMigration(base), false, 'engine rows present → migration already done');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('false when no database connection is open', () => {
+    const base = makeProject();
+    try {
+      mkdirSync(join(base, '.gsd', 'milestones', 'M001'), { recursive: true });
+      closeDatabase();
+      assert.equal(needsAutoMigration(base), false, 'no DB → cannot migrate');
+    } finally {
+      cleanup(base);
+    }
+  });
+});
+
+describe('validateMigration', () => {
+  test('reports no discrepancies when engine counts match markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      writeRoadmap(base, 'M001', ['- [ ] **S01: Test Slice** `risk:low` `depends:[]`']);
+      insertMilestone({ id: 'M001', title: 'Test' });
+      insertSlice({ id: 'S01', milestoneId: 'M001', title: 'Test Slice' });
+
+      const result = validateMigration(base);
+      assert.deepEqual(result.discrepancies, [], 'matching engine/markdown counts → clean');
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('reports discrepancies when engine counts diverge from markdown', () => {
+    const base = makeProject();
+    try {
+      openProjectDb(base);
+      writeRoadmap(base, 'M001', [
+        '- [ ] **S01: Test Slice** `risk:low` `depends:[]`',
+        '- [ ] **S02: Second Slice** `risk:low` `depends:[]`',
+      ]);
+      // Engine has no rows at all → milestone and slice counts both diverge.
+      const result = validateMigration(base);
+      assert.ok(
+        result.discrepancies.some((d) => d.includes('Milestone count mismatch')),
+        `expected milestone mismatch, got: ${result.discrepancies.join('; ')}`,
+      );
+      assert.ok(
+        result.discrepancies.some((d) => d.includes('Slice count mismatch')),
+        `expected slice mismatch, got: ${result.discrepancies.join('; ')}`,
+      );
+    } finally {
+      cleanup(base);
+    }
+  });
+
+  test('reports a validation failure when no database connection is open', () => {
+    const base = makeProject();
+    try {
+      closeDatabase();
+      const result = validateMigration(base);
+      assert.deepEqual(result.discrepancies, ['No database connection for validation']);
+    } finally {
+      cleanup(base);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/worktree-state-projection.test.ts

@@ -97,6 +97,42 @@ test("projectRootToWorktree forwards root PROJECT.md into isolated worktrees", (
   }
 });
 
+test("projectRootToWorktree projects flat-phase discuss artifacts before dispatch", () => {
+  const { dir, cleanup } = makeProjectRoot();
+  try {
+    const worktree = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(join(worktree, ".gsd", "phases", "01-foundation"), { recursive: true });
+
+    const projectPhaseDir = join(dir, ".gsd", "phases", "01-foundation");
+    mkdirSync(projectPhaseDir, { recursive: true });
+    writeFileSync(join(projectPhaseDir, "01-CONTEXT.md"), "# M001 Context\n");
+    writeFileSync(join(projectPhaseDir, "01-DISCUSSION.md"), "# M001 Discussion\n");
+
+    const metaDir = join(dir, ".gsd", "milestones", "M001");
+    mkdirSync(metaDir, { recursive: true });
+    writeFileSync(join(metaDir, "M001-META.json"), '{"branch":"milestone/M001"}');
+
+    const workspace = createWorkspace(worktree);
+    const scope = scopeMilestone(workspace, "M001");
+    new WorktreeStateProjection().projectRootToWorktree(scope);
+
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "milestones", "M001", "M001-META.json")),
+      "milestone metadata is projected into the worktree",
+    );
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "phases", "01-foundation", "01-CONTEXT.md")),
+      "flat-phase CONTEXT.md is projected into the worktree",
+    );
+    assert.ok(
+      existsSync(join(worktree, ".gsd", "phases", "01-foundation", "01-DISCUSSION.md")),
+      "flat-phase DISCUSSION.md is projected into the worktree",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
 test("projectRootToWorktree projects prior-milestone slice/task SUMMARY.md, not just top-level files", () => {
   // Regression: a worktree opened for the CURRENT milestone (M002) must also
   // receive the full subtree of OTHER, already-completed milestones (M001) so