gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

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

@@ -1,20 +1,20 @@
-/**
- * Structural tests for slice-level parallel orchestrator.
- * Verifies the orchestrator module exists and has the correct shape,
- * env var usage, and preference gating.
- */
+// GSD-2 — Slice parallel orchestrator behavior tests.
 
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { execFileSync, spawn } from "node:child_process";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { restoreSliceState, SLICE_WORKER_AUTO_ARGS } from "../slice-parallel-orchestrator.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const gsdDir = join(__dirname, "..");
+import { deriveState } from "../state.js";
+import { validatePreferences } from "../preferences-validation.ts";
+import {
+  _buildSliceWorkerEnvForTest,
+  _resolveSliceParallelMaxWorkersForTest,
+  restoreSliceState,
+  SLICE_WORKER_AUTO_ARGS,
+} from "../slice-parallel-orchestrator.ts";
 
 function readLinuxProcessStartFingerprint(pid: number): string | null {
   try {
@@ -83,81 +83,31 @@ function writeSliceOrchestratorState(
   );
 }
 
-describe("slice-parallel-orchestrator structural tests", () => {
-  it("orchestrator uses GSD_SLICE_LOCK env var", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_SLICE_LOCK"),
-      "Orchestrator must use GSD_SLICE_LOCK env var to isolate slice workers",
-    );
-  });
-
-  it("orchestrator sets GSD_PARALLEL_WORKER=1 to prevent nesting", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_PARALLEL_WORKER"),
-      "Orchestrator must set GSD_PARALLEL_WORKER to prevent nested parallel",
-    );
-  });
-
-  it("slice workers use headless auto instead of print-mode slash commands", () => {
-    const args: readonly string[] = SLICE_WORKER_AUTO_ARGS;
-    assert.deepEqual([...args], ["headless", "--json", "auto"]);
-    assert.equal(args.includes("--print"), false);
-  });
-
-  it("maxWorkers default is 2", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    // Check that default max workers is 2 (in opts.maxWorkers ?? 2 or similar)
-    assert.ok(
-      source.includes("maxWorkers") && source.includes("2"),
-      "Default maxWorkers should be 2",
-    );
-  });
-
-  it("orchestrator imports GSD_MILESTONE_LOCK for milestone isolation", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_MILESTONE_LOCK"),
-      "Orchestrator must also pass GSD_MILESTONE_LOCK for milestone context",
-    );
+describe("slice worker launch contract", () => {
+  it("uses headless auto instead of print-mode slash commands", () => {
+    assert.deepEqual([...SLICE_WORKER_AUTO_ARGS], ["headless", "--json", "auto"]);
+    assert.equal(SLICE_WORKER_AUTO_ARGS.includes("--print" as never), false);
   });
 
-  it("recovery preserves terminal workers for coordinator-side collection", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes('} else if (w.state === "running")') &&
-        source.includes("survivors.push(w);"),
-      "Recovery must only prune dead running workers, not stopped/error workers",
+  it("builds isolated worker environment", () => {
+    const env = _buildSliceWorkerEnvForTest(
+      "/repo",
+      "M001",
+      "S02",
+      "worker-token",
+      { PATH: "/bin" } as NodeJS.ProcessEnv,
     );
-  });
 
-  it("recovered PID-only workers are validated before signaling", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("isRecoveredSliceWorkerAlive(worker)") &&
-        source.includes('process.kill(worker.pid, "SIGTERM")'),
-      "stopSliceParallel must validate recovered worker identity before signaling a PID",
-    );
+    assert.equal(env.GSD_SLICE_LOCK, "S02");
+    assert.equal(env.GSD_MILESTONE_LOCK, "M001");
+    assert.equal(env.GSD_PROJECT_ROOT, "/repo");
+    assert.equal(env.GSD_PARALLEL_WORKER, "1");
+    assert.equal(env.GSD_SLICE_WORKER_TOKEN, "worker-token");
   });
 
-  it("persists worker identity for crash recovery", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("workerToken") &&
-        source.includes("processStartFingerprint") &&
-        source.includes("GSD_SLICE_WORKER_TOKEN"),
-      "Orchestrator must persist stable worker identity metadata for recovered workers",
-    );
-  });
-
-  it("spawn failures remove stale worker state and worktree", () => {
-    const source = readFileSync(join(gsdDir, "slice-parallel-orchestrator.ts"), "utf-8");
-    assert.ok(
-      source.includes("sliceState.workers.delete(slice.id)") &&
-        source.includes("removeWorktree(basePath, wtName, { deleteBranch: true, force: true })"),
-      "Failed slice worker spawns must remove stale worker state and clean up the worktree",
-    );
+  it("defaults to two workers unless explicitly configured", () => {
+    assert.equal(_resolveSliceParallelMaxWorkersForTest(), 2);
+    assert.equal(_resolveSliceParallelMaxWorkersForTest(4), 4);
   });
 });
 
@@ -217,36 +167,47 @@ describe("slice-parallel-orchestrator recovery identity", () => {
   });
 });
 
-describe("slice_parallel preference gating", () => {
-  it("preferences-types.ts includes slice_parallel in interface", () => {
-    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
-    assert.ok(
-      source.includes("slice_parallel"),
-      "GSDPreferences should have slice_parallel field",
-    );
-  });
-
-  it("slice_parallel is in KNOWN_PREFERENCE_KEYS", () => {
-    const source = readFileSync(join(gsdDir, "preferences-types.ts"), "utf-8");
-    assert.ok(
-      source.includes('"slice_parallel"'),
-      'KNOWN_PREFERENCE_KEYS should include "slice_parallel"',
-    );
+describe("slice_parallel preference and state gating", () => {
+  it("validates slice_parallel preferences", () => {
+    const result = validatePreferences({
+      slice_parallel: { enabled: true, max_workers: 3 },
+    });
+
+    assert.equal(result.errors.length, 0);
+    assert.deepEqual(result.preferences.slice_parallel, {
+      enabled: true,
+      max_workers: 3,
+    });
   });
 
-  it("state.ts checks GSD_SLICE_LOCK for slice isolation", () => {
-    const source = readFileSync(join(gsdDir, "state.ts"), "utf-8");
-    assert.ok(
-      source.includes("GSD_SLICE_LOCK"),
-      "State derivation should check GSD_SLICE_LOCK for slice-level parallel isolation",
-    );
-  });
+  it("derives the locked slice for parallel workers", async () => {
+    const basePath = makeTempProject();
+    const oldWorker = process.env.GSD_PARALLEL_WORKER;
+    const oldSlice = process.env.GSD_SLICE_LOCK;
+    try {
+      const msDir = join(basePath, ".gsd", "milestones", "M001");
+      mkdirSync(msDir, { recursive: true });
+      writeFileSync(
+        join(msDir, "M001-ROADMAP.md"),
+        [
+          "# M001",
+          "",
+          "## Slices",
+          "- [ ] **S01: First** `risk:low` `depends:[]`",
+          "- [ ] **S02: Second** `risk:low` `depends:[]`",
+        ].join("\n"),
+      );
+      process.env.GSD_PARALLEL_WORKER = "1";
+      process.env.GSD_SLICE_LOCK = "S02";
 
-  it("auto.ts imports slice parallel orchestrator when enabled", () => {
-    const source = readFileSync(join(gsdDir, "auto.ts"), "utf-8");
-    assert.ok(
-      source.includes("slice_parallel") || source.includes("slice-parallel"),
-      "auto.ts should reference slice_parallel for dispatch gating",
-    );
+      const state = await deriveState(basePath);
+      assert.equal(state.activeSlice?.id, "S02");
+    } finally {
+      if (oldWorker === undefined) delete process.env.GSD_PARALLEL_WORKER;
+      else process.env.GSD_PARALLEL_WORKER = oldWorker;
+      if (oldSlice === undefined) delete process.env.GSD_SLICE_LOCK;
+      else process.env.GSD_SLICE_LOCK = oldSlice;
+      rmSync(basePath, { recursive: true, force: true });
+    }
   });
 });

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

@@ -1,51 +1,124 @@
 /**
- * Regression test for #3697 — set slice sequence on insert
- *
- * All three insertSlice call sites must pass a sequence value so slices
- * are ordered correctly instead of defaulting to 0.
+ * Regression test for #3697 — set slice sequence on insert.
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-const planMilestoneSrc = readFileSync(
-  join(__dirname, '..', 'tools', 'plan-milestone.ts'),
-  'utf-8',
-);
-const reassessRoadmapSrc = readFileSync(
-  join(__dirname, '..', 'tools', 'reassess-roadmap.ts'),
-  'utf-8',
-);
-const mdImporterSrc = readFileSync(
-  join(__dirname, '..', 'md-importer.ts'),
-  'utf-8',
-);
-
-describe('slice sequence on insert (#3697)', () => {
-  test('plan-milestone.ts passes sequence to insertSlice', () => {
-    assert.match(planMilestoneSrc, /insertSlice\(/,
-      'plan-milestone.ts should call insertSlice');
-    assert.match(planMilestoneSrc, /sequence:\s*i\s*\+\s*1/,
-      'plan-milestone.ts should pass sequence: i + 1');
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { handlePlanMilestone } from "../tools/plan-milestone.ts";
+import { handleReassessRoadmap } from "../tools/reassess-roadmap.ts";
+import { migrateHierarchyToDb } from "../md-importer.ts";
+import {
+  closeDatabase,
+  getMilestoneSlices,
+  insertMilestone,
+  insertSlice,
+  openDatabase,
+} from "../gsd-db.ts";
+
+let tempBase: string | null = null;
+
+afterEach(() => {
+  closeDatabase();
+  if (tempBase) rmSync(tempBase, { recursive: true, force: true });
+  tempBase = null;
+});
+
+function makeBase(name: string): string {
+  tempBase = mkdtempSync(join(tmpdir(), name));
+  mkdirSync(join(tempBase, ".gsd", "milestones"), { recursive: true });
+  openDatabase(join(tempBase, ".gsd", "gsd.db"));
+  return tempBase;
+}
+
+function slice(sliceId: string, title: string) {
+  return {
+    sliceId,
+    title,
+    risk: "low",
+    depends: [],
+    demo: `${title} demo`,
+    goal: `${title} goal`,
+    successCriteria: `${title} success`,
+    proofLevel: "unit",
+    integrationClosure: "covered",
+    observabilityImpact: "none",
+  };
+}
+
+describe("slice sequence on insert (#3697)", () => {
+  test("plan milestone persists slices in agent-provided order", async () => {
+    const base = makeBase("gsd-sequence-plan-");
+
+    const result = await handlePlanMilestone({
+      milestoneId: "M001",
+      title: "Sequence",
+      vision: "Preserve slice order",
+      slices: [slice("S01", "First"), slice("S02", "Second"), slice("S03", "Third")],
+    }, base);
+
+    assert.ok(!("error" in result), JSON.stringify(result));
+    assert.deepEqual(
+      getMilestoneSlices("M001").map((row) => [row.id, row.sequence]),
+      [["S01", 1], ["S02", 2], ["S03", 3]],
+    );
   });
 
-  test('reassess-roadmap.ts passes sequence to insertSlice', () => {
-    assert.match(reassessRoadmapSrc, /insertSlice\(/,
-      'reassess-roadmap.ts should call insertSlice');
-    assert.match(reassessRoadmapSrc, /sequence:\s*existingCount\s*\+\s*i\s*\+\s*1/,
-      'reassess-roadmap.ts should pass sequence: existingCount + i + 1');
+  test("reassess roadmap appends new slices after existing slices", async () => {
+    const base = makeBase("gsd-sequence-reassess-");
+    insertMilestone({ id: "M001", title: "Sequence", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Done", status: "complete", risk: "low", depends: [], demo: "", sequence: 1 });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Existing", status: "pending", risk: "low", depends: [], demo: "", sequence: 2 });
+
+    const result = await handleReassessRoadmap({
+      milestoneId: "M001",
+      completedSliceId: "S01",
+      verdict: "pass",
+      assessment: "Add follow-up slices.",
+      sliceChanges: {
+        modified: [],
+        added: [
+          { sliceId: "S03", title: "Added 1", risk: "low", depends: [], demo: "" },
+          { sliceId: "S04", title: "Added 2", risk: "low", depends: [], demo: "" },
+        ],
+        removed: [],
+      },
+    }, base);
+
+    assert.ok(!("error" in result), JSON.stringify(result));
+    assert.deepEqual(
+      getMilestoneSlices("M001").map((row) => [row.id, row.sequence]),
+      [["S01", 1], ["S02", 2], ["S03", 3], ["S04", 4]],
+    );
   });
 
-  test('md-importer.ts passes sequence to insertSlice', () => {
-    assert.match(mdImporterSrc, /insertSlice\(/,
-      'md-importer.ts should call insertSlice');
-    assert.match(mdImporterSrc, /sequence:\s*si\s*\+\s*1/,
-      'md-importer.ts should pass sequence: si + 1');
+  test("markdown importer preserves roadmap order in sequence values", () => {
+    const base = makeBase("gsd-sequence-import-");
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(
+      join(milestoneDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Imported",
+        "",
+        "## Slices",
+        "- [ ] **S01: First** `risk:low`",
+        "  Demo: first.",
+        "- [ ] **S02: Second** `risk:low`",
+        "  Demo: second.",
+      ].join("\n"),
+      "utf-8",
+    );
+
+    const result = migrateHierarchyToDb(base);
+
+    assert.equal(result.slices, 2);
+    assert.deepEqual(
+      getMilestoneSlices("M001").map((row) => [row.id, row.sequence]),
+      [["S01", 1], ["S02", 2]],
+    );
   });
 });

package/src/resources/extensions/gsd/tests/smart-entry-complete.test.ts

@@ -1,34 +1,33 @@
+// GSD-2 — Guided smart entry complete-state behavior tests.
+
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-const { deriveState } = await import("../state.js");
+import { deriveState } from "../state.js";
+
+function writeCompleteMilestone(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-ROADMAP.md"),
+    [
+      "# M001: Complete Milestone",
+      "",
+      "## Slices",
+      "- [x] **S01: Done slice** `risk:low` `depends:[]`",
+      "  > Done.",
+    ].join("\n"),
+  );
+  writeFileSync(join(milestoneDir, "M001-SUMMARY.md"), "# M001 Summary\n\nComplete.");
+}
 
 test("deriveState reports the last completed milestone when all milestone slices are done", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-smart-entry-complete-"));
-
   try {
-    const milestoneDir = join(base, ".gsd", "milestones", "M001");
-    mkdirSync(milestoneDir, { recursive: true });
-
-    writeFileSync(
-      join(milestoneDir, "M001-ROADMAP.md"),
-      [
-        "# M001: Complete Milestone",
-        "",
-        "## Slices",
-        "- [x] **S01: Done slice** `risk:low` `depends:[]`",
-        "  > Done.",
-      ].join("\n"),
-    );
-
-    writeFileSync(
-      join(milestoneDir, "M001-SUMMARY.md"),
-      "# M001 Summary\n\nComplete.",
-    );
-
+    writeCompleteMilestone(base);
     const state = await deriveState(base);
     assert.equal(state.phase, "complete");
     assert.equal(state.lastCompletedMilestone?.id, "M001");
@@ -36,58 +35,3 @@ test("deriveState reports the last completed milestone when all milestone slices
     rmSync(base, { recursive: true, force: true });
   }
 });
-
-test("guided-flow complete branch offers a chooser for next milestone or status", () => {
-  const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  const branchIdx = guidedFlowSource.indexOf('state.phase === "complete"');
-
-  assert.ok(branchIdx > -1, "guided-flow.ts should have a complete-phase smart-entry branch");
-
-  const nextBranchIdx = guidedFlowSource.indexOf('state.phase === "needs-discussion"', branchIdx);
-  const branchChunk = guidedFlowSource.slice(branchIdx, nextBranchIdx === -1 ? branchIdx + 1600 : nextBranchIdx);
-
-  assert.match(branchChunk, /showNextAction\(/, "complete branch should present a chooser");
-  assert.match(branchChunk, /id:\s*"quick_task"/, "complete branch should offer quick task before milestone planning");
-  assert.match(branchChunk, /Do a small bounded task without opening a milestone/, "quick task action should explain that it avoids milestones");
-  assert.match(branchChunk, /recommended:\s*true/, "quick task action should be the recommended complete-state action");
-  assert.match(branchChunk, /findMilestoneIds\(basePath\)/, "complete branch should compute the next milestone id");
-  assert.match(
-    branchChunk,
-    /nextMilestoneIdReserved\(milestoneIds,\s*uniqueMilestoneIds,\s*basePath\)/,
-    "complete branch should derive the next milestone id",
-  );
-  assert.match(branchChunk, /dispatchWorkflow\(pi, await prepareAndBuildDiscussPrompt\(/, "complete branch should dispatch the prepared discuss prompt");
-});
-
-test("dispatcher routes multi-word freeform /gsd input through /gsd do", () => {
-  const dispatcherSource = readFileSync(join(import.meta.dirname, "..", "commands", "dispatcher.ts"), "utf-8");
-
-  assert.match(
-    dispatcherSource,
-    /if\s*\(trimmed\.includes\(" "\)\)\s*\{[\s\S]*handleDo\(trimmed,\s*ctx,\s*pi\)/,
-    "dispatcher should treat multi-word unknown input as natural-language /gsd do work",
-  );
-  assert.match(
-    dispatcherSource,
-    /Unknown: \/gsd/,
-    "single-token unknown commands should still report the normal unknown-command warning",
-  );
-});
-
-test("guided-flow needs-discussion skip branch opens the project DB before reserving a new milestone", () => {
-  const guidedFlowSource = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  const laterDbOpenIdx = guidedFlowSource.indexOf("// Ensure DB is open before querying slices (#2560).");
-  assert.ok(laterDbOpenIdx > -1, "guided-flow.ts should contain the post-draft DB-open guard");
-
-  const branchPrefix = guidedFlowSource.slice(0, laterDbOpenIdx);
-  const skipBranchIdx = branchPrefix.lastIndexOf('choice === "skip_milestone"');
-  assert.ok(skipBranchIdx > -1, "needs-discussion skip branch should be present");
-
-  const branchChunk = branchPrefix.slice(skipBranchIdx);
-  const ensureIdx = branchChunk.indexOf("ensureDbOpen(basePath)");
-  const reserveIdx = branchChunk.indexOf("nextMilestoneIdReserved");
-
-  assert.ok(ensureIdx > -1, "skip branch should open the project DB");
-  assert.ok(reserveIdx > -1, "skip branch should reserve the next milestone ID");
-  assert.ok(ensureIdx < reserveIdx, "project DB must be opened before milestone ID reservation");
-});

package/src/resources/extensions/gsd/tests/smart-entry-draft.test.ts

@@ -1,124 +1,33 @@
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+// GSD-2 — Guided smart entry draft-state behavior tests.
+
+import 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 { deriveState } from "../state.js";
 import { resolveMilestoneFile } from "../paths.js";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-let passed = 0;
-let failed = 0;
 
-function assert(condition: boolean, message: string): void {
-  if (condition) {
-    passed++;
-  } else {
-    failed++;
-    console.error(`  FAIL: ${message}`);
-  }
+function writeDraftOnlyMilestone(base: string): void {
+  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+  mkdirSync(milestoneDir, { recursive: true });
+  writeFileSync(
+    join(milestoneDir, "M001-CONTEXT-DRAFT.md"),
+    "# M001: Test Milestone\n\n**Status:** Draft\n\nSeed material.\n",
+  );
 }
 
-// ─── Fixture: milestone with only CONTEXT-DRAFT.md ──────────────────────
-
-const tmpBase = mkdtempSync(join(tmpdir(), "gsd-smart-entry-draft-test-"));
-const gsd = join(tmpBase, ".gsd");
-
-mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
-
-const draftContent = `# M001: Test Milestone — Context\n\n**Status:** Draft\n\nSeed material from a prior discussion.\n`;
-writeFileSync(
-  join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
-  draftContent,
-);
-
-// ─── Test: deriveState returns 'needs-discussion' for draft-only milestone ───
-
-const state = await deriveState(tmpBase);
-
-assert(
-  state.phase === "needs-discussion",
-  `phase should be 'needs-discussion' for draft-only milestone, got: "${state.phase}"`,
-);
-
-assert(
-  state.activeMilestone?.id === "M001",
-  `active milestone should be M001, got: "${state.activeMilestone?.id}"`,
-);
-
-// ─── Test: resolveMilestoneFile resolves CONTEXT-DRAFT ─────────────────────
-
-const draftFile = resolveMilestoneFile(tmpBase, "M001", "CONTEXT-DRAFT");
-
-assert(
-  draftFile !== null && draftFile !== undefined,
-  `resolveMilestoneFile should resolve CONTEXT-DRAFT, got: ${draftFile}`,
-);
-
-assert(
-  draftFile!.endsWith("M001-CONTEXT-DRAFT.md"),
-  `resolved path should end with M001-CONTEXT-DRAFT.md, got: "${draftFile}"`,
-);
-
-// ─── Test: CONTEXT.md is NOT resolved (only draft exists) ──────────────────
-
-const contextFile = resolveMilestoneFile(tmpBase, "M001", "CONTEXT");
-
-assert(
-  contextFile === null || contextFile === undefined,
-  `resolveMilestoneFile should NOT resolve CONTEXT when only CONTEXT-DRAFT exists, got: "${contextFile}"`,
-);
-
-// ─── Static: guided-flow.ts has 'needs-discussion' branch ─────────────────
-
-const guidedFlowSource = readFileSync(
-  join(import.meta.dirname, "..", "guided-flow.ts"),
-  "utf-8",
-);
-
-assert(
-  guidedFlowSource.includes('state.phase === "needs-discussion"'),
-  "guided-flow.ts should have 'needs-discussion' phase check in showSmartEntry",
-);
-
-// Check the branch has draft-aware menu options
-const branchIdx = guidedFlowSource.indexOf('state.phase === "needs-discussion"');
-const branchChunk = extractSourceRegion(guidedFlowSource, 'state.phase === "needs-discussion"');
-
-assert(
-  branchChunk.includes("discuss_draft"),
-  "needs-discussion branch should have 'discuss_draft' option",
-);
-
-assert(
-  branchChunk.includes("discuss_fresh"),
-  "needs-discussion branch should have 'discuss_fresh' option",
-);
-
-assert(
-  branchChunk.includes("skip_milestone"),
-  "needs-discussion branch should have 'skip_milestone' option",
-);
-
-assert(
-  branchChunk.includes("CONTEXT-DRAFT"),
-  "needs-discussion branch should load CONTEXT-DRAFT via resolveMilestoneFile",
-);
-
-assert(
-  branchChunk.includes("Draft Seed") || branchChunk.includes("draftContent"),
-  "discuss_draft path should include draft content as seed in the dispatched prompt",
-);
-
-assert(
-  branchChunk.includes("return"),
-  "needs-discussion branch should return early (not fall through to generic no-roadmap menu)",
-);
-
-// ─── Cleanup ──────────────────────────────────────────────────────────────
-
-rmSync(tmpBase, { recursive: true, force: true });
-
-// ─── Results ──────────────────────────────────────────────────────────────
-
-console.log(`\nsmart-entry-draft: ${passed} passed, ${failed} failed`);
-if (failed > 0) process.exit(1);
+test("deriveState returns needs-discussion for draft-only milestone", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-smart-entry-draft-"));
+  try {
+    writeDraftOnlyMilestone(base);
+    const state = await deriveState(base);
+    assert.equal(state.phase, "needs-discussion");
+    assert.equal(state.activeMilestone?.id, "M001");
+    assert.match(resolveMilestoneFile(base, "M001", "CONTEXT-DRAFT") ?? "", /M001-CONTEXT-DRAFT\.md$/);
+    assert.equal(resolveMilestoneFile(base, "M001", "CONTEXT"), null);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});