gsd-pi 2.44.0 → 2.45.0-dev.1afbdaa

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -58,17 +58,18 @@ test("guided-resume-task prompt preserves recovery state until work is supersede
   assert.doesNotMatch(prompt, /Delete the continue file after reading it/i);
 });
 
-// ─── Prompt migration: execute-task → gsd_task_complete ───────────────
+// ─── Prompt migration: execute-task → gsd_complete_task ───────────────
 
-test("execute-task prompt references gsd_task_complete tool", () => {
+test("execute-task prompt references gsd_complete_task tool", () => {
   const prompt = readPrompt("execute-task");
-  assert.match(prompt, /gsd_task_complete/);
+  assert.match(prompt, /gsd_complete_task/);
 });
 
-test("execute-task prompt does not instruct LLM to write summary file manually", () => {
+test("execute-task prompt instructs writing task summary before tool call", () => {
   const prompt = readPrompt("execute-task");
-  // Should not contain "Write {{taskSummaryPath}}" as an action instruction
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{taskSummaryPath\}\}`?/m);
+  // The prompt instructs writing the summary file AND calling the tool
+  assert.match(prompt, /\{\{taskSummaryPath\}\}/);
+  assert.match(prompt, /gsd_complete_task/);
 });
 
 test("execute-task prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -93,12 +94,11 @@ test("guided-execute-task prompt does not instruct manual file write", () => {
   assert.doesNotMatch(prompt, /Write `?\{\{taskId\}\}-SUMMARY\.md`?.*mark it done/i);
 });
 
-// ─── Prompt migration: complete-slice → gsd_slice_complete ────────────
-// These tests are for T02 — expected to fail until that task runs.
+// ─── Prompt migration: complete-slice → gsd_complete_slice ────────────
 
-test("complete-slice prompt references gsd_slice_complete tool", () => {
+test("complete-slice prompt references gsd_complete_slice tool", () => {
   const prompt = readPrompt("complete-slice");
-  assert.match(prompt, /gsd_slice_complete/);
+  assert.match(prompt, /gsd_complete_slice/);
 });
 
 test("complete-slice prompt does not instruct LLM to toggle checkboxes manually", () => {
@@ -111,10 +111,12 @@ test("guided-complete-slice prompt references gsd_slice_complete tool", () => {
   assert.match(prompt, /gsd_slice_complete/);
 });
 
-test("complete-slice prompt does not instruct LLM to write summary/UAT files manually", () => {
+test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceSummaryPath\}\}/m);
-  assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{sliceUatPath\}\}/m);
+  // The prompt instructs writing the summary AND UAT files, then calling the tool
+  assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
+  assert.match(prompt, /\{\{sliceUatPath\}\}/);
+  assert.match(prompt, /gsd_complete_slice/);
 });
 
 test("complete-slice prompt preserves decisions and knowledge review steps", () => {
@@ -127,7 +129,6 @@ test("complete-slice prompt still contains template variables for context", () =
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
   assert.match(prompt, /\{\{sliceUatPath\}\}/);
-  assert.match(prompt, /\{\{roadmapPath\}\}/);
 });
 
 test("plan-milestone prompt references DB-backed planning tool and explicitly forbids manual roadmap writes", () => {
@@ -147,12 +148,12 @@ test("plan-slice prompt no longer frames direct PLAN writes as the source of tru
   assert.match(prompt, /Do \*\*not\*\* rely on direct `PLAN\.md` writes as the source of truth/i);
 });
 
-test("plan-slice prompt explicitly names gsd_plan_slice and gsd_plan_task as DB-backed planning tools", () => {
+test("plan-slice prompt explicitly names gsd_plan_slice as DB-backed planning tool", () => {
   const prompt = readPrompt("plan-slice");
   assert.match(prompt, /gsd_plan_slice/);
   assert.match(prompt, /gsd_plan_task/);
-  // The prompt should describe these as the canonical write path
-  assert.match(prompt, /DB-backed tools are the canonical write path/i);
+  // The prompt should describe the DB-backed tool as the canonical write path
+  assert.match(prompt, /DB-backed tool is the canonical write path/i);
 });
 
 test("plan-slice prompt does not instruct direct file writes as a primary step", () => {
@@ -161,14 +162,18 @@ test("plan-slice prompt does not instruct direct file writes as a primary step",
   assert.doesNotMatch(prompt, /^\d+\.\s+Write `?\{\{outputPath\}\}`?\s*$/m);
 });
 
-test("plan-slice prompt instructs calling gsd_plan_task for each task", () => {
+test("plan-slice prompt clarifies gsd_plan_slice handles task persistence", () => {
   const prompt = readPrompt("plan-slice");
-  assert.match(prompt, /call `gsd_plan_task` for each task/i);
+  // gsd_plan_slice persists tasks in its transaction — no separate gsd_plan_task calls needed
+  assert.match(prompt, /gsd_plan_task/);
+  assert.match(prompt, /gsd_plan_slice` handles task persistence/i);
 });
 
-test("replan-slice prompt requires DB-backed planning state when available", () => {
+test("replan-slice prompt uses gsd_replan_slice as canonical DB-backed tool", () => {
   const prompt = readPrompt("replan-slice");
-  assert.match(prompt, /DB-backed planning tool exists for this phase, use it as the source of truth/i);
+  assert.match(prompt, /gsd_replan_slice/);
+  // Degraded fallback (direct file writes) was removed — DB tools are always available
+  assert.doesNotMatch(prompt, /Degraded fallback/i);
 });
 
 test("reassess-roadmap prompt references gsd_reassess_roadmap tool", () => {

package/src/resources/extensions/gsd/tests/prompt-db.test.ts

@@ -5,7 +5,8 @@
 // (b) Helpers fall back to non-null output when DB unavailable
 // (c) Scoped filtering actually reduces content
 
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import {
   openDatabase,
   closeDatabase,
@@ -22,8 +23,6 @@ import {
   formatRequirementsForPrompt,
 } from '../context-store.ts';
 
-const { assertEq, assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
-
 // ═══════════════════════════════════════════════════════════════════════════
 // prompt-db: DB-aware decisions helper returns scoped content
 // ═══════════════════════════════════════════════════════════════════════════
@@ -50,23 +49,23 @@ console.log('\n=== prompt-db: scoped decisions from DB ===');
 
   // Query scoped to M001
   const m001Decisions = queryDecisions({ milestoneId: 'M001' });
-  assertTrue(m001Decisions.length > 0, 'M001 decisions should exist');
-  assertTrue(m001Decisions.length < 10, `scoped query should return fewer than 10 (got ${m001Decisions.length})`);
+  assert.ok(m001Decisions.length > 0, 'M001 decisions should exist');
+  assert.ok(m001Decisions.length < 10, `scoped query should return fewer than 10 (got ${m001Decisions.length})`);
 
   // Verify all returned decisions are for M001
   for (const d of m001Decisions) {
-    assertMatch(d.when_context, /M001/, `decision ${d.id} should be for M001`);
+    assert.match(d.when_context, /M001/, `decision ${d.id} should be for M001`);
   }
 
   // Format and verify wrapping
   const formatted = formatDecisionsForPrompt(m001Decisions);
-  assertTrue(formatted.length > 0, 'formatted decisions should be non-empty');
-  assertMatch(formatted, /\| # \| When \| Scope/, 'formatted decisions have table header');
+  assert.ok(formatted.length > 0, 'formatted decisions should be non-empty');
+  assert.match(formatted, /\| # \| When \| Scope/, 'formatted decisions have table header');
 
   // Verify the expected wrapper format that inlineDecisionsFromDb would produce
   const wrapped = `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${formatted}`;
-  assertMatch(wrapped, /^### Decisions/, 'wrapped decisions start with ### Decisions');
-  assertMatch(wrapped, /Source:.*DECISIONS\.md/, 'wrapped decisions have source path');
+  assert.match(wrapped, /^### Decisions/, 'wrapped decisions start with ### Decisions');
+  assert.match(wrapped, /Source:.*DECISIONS\.md/, 'wrapped decisions have source path');
 
   closeDatabase();
 }
@@ -101,25 +100,25 @@ console.log('\n=== prompt-db: scoped requirements from DB ===');
 
   // Query scoped to S01 — should get R001 (primary) and R002 (supporting)
   const s01Reqs = queryRequirements({ sliceId: 'S01' });
-  assertEq(s01Reqs.length, 2, 'S01 requirements should be 2 (primary + supporting)');
+  assert.deepStrictEqual(s01Reqs.length, 2, 'S01 requirements should be 2 (primary + supporting)');
   const ids = s01Reqs.map(r => r.id).sort();
-  assertEq(ids, ['R001', 'R002'], 'S01 owns R001 and supports R002');
+  assert.deepStrictEqual(ids, ['R001', 'R002'], 'S01 owns R001 and supports R002');
 
   // Unscoped query returns all 3
   const allReqs = queryRequirements();
-  assertEq(allReqs.length, 3, 'unscoped requirements should return all 3');
+  assert.deepStrictEqual(allReqs.length, 3, 'unscoped requirements should return all 3');
 
   // Format and verify wrapping
   const formatted = formatRequirementsForPrompt(s01Reqs);
-  assertTrue(formatted.length > 0, 'formatted requirements should be non-empty');
-  assertMatch(formatted, /### R001/, 'formatted requirements include R001');
-  assertMatch(formatted, /### R002/, 'formatted requirements include R002');
-  assertNoMatch(formatted, /### R003/, 'formatted requirements exclude R003');
+  assert.ok(formatted.length > 0, 'formatted requirements should be non-empty');
+  assert.match(formatted, /### R001/, 'formatted requirements include R001');
+  assert.match(formatted, /### R002/, 'formatted requirements include R002');
+  assert.doesNotMatch(formatted, /### R003/, 'formatted requirements exclude R003');
 
   // Verify the expected wrapper format that inlineRequirementsFromDb would produce
   const wrapped = `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${formatted}`;
-  assertMatch(wrapped, /^### Requirements/, 'wrapped requirements start with ### Requirements');
-  assertMatch(wrapped, /Source:.*REQUIREMENTS\.md/, 'wrapped requirements have source path');
+  assert.match(wrapped, /^### Requirements/, 'wrapped requirements start with ### Requirements');
+  assert.match(wrapped, /Source:.*REQUIREMENTS\.md/, 'wrapped requirements have source path');
 
   closeDatabase();
 }
@@ -142,13 +141,13 @@ console.log('\n=== prompt-db: project content from DB ===');
   });
 
   const content = queryProject();
-  assertEq(content, '# Test Project\n\nThis is the project description.', 'queryProject returns content');
+  assert.deepStrictEqual(content, '# Test Project\n\nThis is the project description.', 'queryProject returns content');
 
   // Verify the expected wrapper format that inlineProjectFromDb would produce
   const wrapped = `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${content}`;
-  assertMatch(wrapped, /^### Project/, 'wrapped project starts with ### Project');
-  assertMatch(wrapped, /Source:.*PROJECT\.md/, 'wrapped project has source path');
-  assertMatch(wrapped, /# Test Project/, 'wrapped project includes content');
+  assert.match(wrapped, /^### Project/, 'wrapped project starts with ### Project');
+  assert.match(wrapped, /Source:.*PROJECT\.md/, 'wrapped project has source path');
+  assert.match(wrapped, /# Test Project/, 'wrapped project includes content');
 
   closeDatabase();
 }
@@ -160,27 +159,27 @@ console.log('\n=== prompt-db: project content from DB ===');
 console.log('\n=== prompt-db: fallback when DB unavailable ===');
 {
   closeDatabase();
-  assertTrue(!isDbAvailable(), 'DB should not be available');
+  assert.ok(!isDbAvailable(), 'DB should not be available');
 
   // queryDecisions returns [] when DB closed — helper would fall back
   const decisions = queryDecisions({ milestoneId: 'M001' });
-  assertEq(decisions, [], 'queryDecisions returns [] when DB closed');
+  assert.deepStrictEqual(decisions, [], 'queryDecisions returns [] when DB closed');
 
   // queryRequirements returns [] when DB closed — helper would fall back
   const requirements = queryRequirements({ sliceId: 'S01' });
-  assertEq(requirements, [], 'queryRequirements returns [] when DB closed');
+  assert.deepStrictEqual(requirements, [], 'queryRequirements returns [] when DB closed');
 
   // queryProject returns null when DB closed — helper would fall back
   const project = queryProject();
-  assertEq(project, null, 'queryProject returns null when DB closed');
+  assert.deepStrictEqual(project, null, 'queryProject returns null when DB closed');
 
   // formatDecisionsForPrompt returns '' for empty input
   const formatted = formatDecisionsForPrompt([]);
-  assertEq(formatted, '', 'formatDecisionsForPrompt returns empty for empty input');
+  assert.deepStrictEqual(formatted, '', 'formatDecisionsForPrompt returns empty for empty input');
 
   // formatRequirementsForPrompt returns '' for empty input
   const formattedReqs = formatRequirementsForPrompt([]);
-  assertEq(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
+  assert.deepStrictEqual(formattedReqs, '', 'formatRequirementsForPrompt returns empty for empty input');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -210,15 +209,15 @@ console.log('\n=== prompt-db: scoped filtering reduces content ===');
   const allDecisions = queryDecisions();
   const m001Decisions = queryDecisions({ milestoneId: 'M001' });
 
-  assertEq(allDecisions.length, 10, 'unscoped returns all 10 decisions');
-  assertTrue(m001Decisions.length < 10, `M001-scoped returns fewer than 10 (got ${m001Decisions.length})`);
-  assertTrue(m001Decisions.length > 0, 'M001-scoped returns at least 1');
+  assert.deepStrictEqual(allDecisions.length, 10, 'unscoped returns all 10 decisions');
+  assert.ok(m001Decisions.length < 10, `M001-scoped returns fewer than 10 (got ${m001Decisions.length})`);
+  assert.ok(m001Decisions.length > 0, 'M001-scoped returns at least 1');
 
   // Format both and compare sizes — scoped should be shorter
   const allFormatted = formatDecisionsForPrompt(allDecisions);
   const scopedFormatted = formatDecisionsForPrompt(m001Decisions);
 
-  assertTrue(
+  assert.ok(
     scopedFormatted.length < allFormatted.length,
     `scoped content (${scopedFormatted.length} chars) should be shorter than unscoped (${allFormatted.length} chars)`,
   );
@@ -245,14 +244,14 @@ console.log('\n=== prompt-db: scoped filtering reduces content ===');
   const allReqs = queryRequirements();
   const s01Reqs = queryRequirements({ sliceId: 'S01' });
 
-  assertEq(allReqs.length, 8, 'unscoped returns all 8 requirements');
-  assertTrue(s01Reqs.length < 8, `S01-scoped returns fewer than 8 (got ${s01Reqs.length})`);
-  assertTrue(s01Reqs.length > 0, 'S01-scoped returns at least 1');
+  assert.deepStrictEqual(allReqs.length, 8, 'unscoped returns all 8 requirements');
+  assert.ok(s01Reqs.length < 8, `S01-scoped returns fewer than 8 (got ${s01Reqs.length})`);
+  assert.ok(s01Reqs.length > 0, 'S01-scoped returns at least 1');
 
   const allReqsFormatted = formatRequirementsForPrompt(allReqs);
   const scopedReqsFormatted = formatRequirementsForPrompt(s01Reqs);
 
-  assertTrue(
+  assert.ok(
     scopedReqsFormatted.length < allReqsFormatted.length,
     `scoped requirements (${scopedReqsFormatted.length} chars) should be shorter than unscoped (${allReqsFormatted.length} chars)`,
   );
@@ -292,23 +291,23 @@ console.log('\n=== prompt-db: DB helpers wrapper format matches expected pattern
 
   // Simulate what inlineDecisionsFromDb does
   const decisions = queryDecisions({ milestoneId: 'M001' });
-  assertTrue(decisions.length === 1, 'got 1 decision for M001');
+  assert.ok(decisions.length === 1, 'got 1 decision for M001');
   const dFormatted = formatDecisionsForPrompt(decisions);
   const dWrapped = `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${dFormatted}`;
-  assertMatch(dWrapped, /^### Decisions\nSource: `.gsd\/DECISIONS\.md`\n\n\| #/, 'decisions wrapper format correct');
+  assert.match(dWrapped, /^### Decisions\nSource: `.gsd\/DECISIONS\.md`\n\n\| #/, 'decisions wrapper format correct');
 
   // Simulate what inlineRequirementsFromDb does
   const reqs = queryRequirements({ sliceId: 'S01' });
-  assertTrue(reqs.length === 1, 'got 1 requirement for S01');
+  assert.ok(reqs.length === 1, 'got 1 requirement for S01');
   const rFormatted = formatRequirementsForPrompt(reqs);
   const rWrapped = `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${rFormatted}`;
-  assertMatch(rWrapped, /^### Requirements\nSource: `.gsd\/REQUIREMENTS\.md`\n\n### R001/, 'requirements wrapper format correct');
+  assert.match(rWrapped, /^### Requirements\nSource: `.gsd\/REQUIREMENTS\.md`\n\n### R001/, 'requirements wrapper format correct');
 
   // Simulate what inlineProjectFromDb does
   const project = queryProject();
-  assertTrue(project !== null, 'project content exists');
+  assert.ok(project !== null, 'project content exists');
   const pWrapped = `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${project}`;
-  assertMatch(pWrapped, /^### Project\nSource: `.gsd\/PROJECT\.md`\n\n# Project Name/, 'project wrapper format correct');
+  assert.match(pWrapped, /^### Project\nSource: `.gsd\/PROJECT\.md`\n\n# Project Name/, 'project wrapper format correct');
 
   closeDatabase();
 }
@@ -322,8 +321,9 @@ import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import { migrateFromMarkdown } from '../md-importer.ts';
 
-console.log('\n=== prompt-db: re-import updates DB when source markdown changes ===');
-{
+
+describe('prompt-db', () => {
+test('prompt-db: re-import updates DB when source markdown changes', () => {
   // Create a temp dir simulating a project with .gsd/DECISIONS.md
   const tmpDir = mkdtempSync(join(tmpdir(), 'prompt-db-reimport-'));
   const gsdDir = join(tmpDir, '.gsd');
@@ -345,9 +345,9 @@ console.log('\n=== prompt-db: re-import updates DB when source markdown changes
 
   // Verify initial state: 2 decisions
   const initial = queryDecisions();
-  assertEq(initial.length, 2, 're-import: initial import has 2 decisions');
+  assert.deepStrictEqual(initial.length, 2, 're-import: initial import has 2 decisions');
   const initialIds = initial.map(d => d.id).sort();
-  assertEq(initialIds, ['D001', 'D002'], 're-import: initial decisions are D001, D002');
+  assert.deepStrictEqual(initialIds, ['D001', 'D002'], 're-import: initial decisions are D001, D002');
 
   // Now "the LLM modifies DECISIONS.md" — add a third decision
   const updatedDecisions = `# Decisions Register
@@ -365,23 +365,23 @@ console.log('\n=== prompt-db: re-import updates DB when source markdown changes
 
   // Verify DB now has 3 decisions
   const afterReimport = queryDecisions();
-  assertEq(afterReimport.length, 3, 're-import: after re-import has 3 decisions');
+  assert.deepStrictEqual(afterReimport.length, 3, 're-import: after re-import has 3 decisions');
   const afterIds = afterReimport.map(d => d.id).sort();
-  assertEq(afterIds, ['D001', 'D002', 'D003'], 're-import: decisions are D001, D002, D003');
+  assert.deepStrictEqual(afterIds, ['D001', 'D002', 'D003'], 're-import: decisions are D001, D002, D003');
 
   // Verify the new decision has correct data
   const d003 = afterReimport.find(d => d.id === 'D003');
-  assertTrue(d003 !== undefined, 're-import: D003 exists');
-  assertEq(d003!.when_context, 'M001/S02', 're-import: D003 when_context is M001/S02');
-  assertEq(d003!.scope, 'runtime', 're-import: D003 scope is runtime');
-  assertEq(d003!.choice, 'D014 pattern', 're-import: D003 choice is D014 pattern');
+  assert.ok(d003 !== undefined, 're-import: D003 exists');
+  assert.deepStrictEqual(d003!.when_context, 'M001/S02', 're-import: D003 when_context is M001/S02');
+  assert.deepStrictEqual(d003!.scope, 'runtime', 're-import: D003 scope is runtime');
+  assert.deepStrictEqual(d003!.choice, 'D014 pattern', 're-import: D003 choice is D014 pattern');
 
   // Verify scoped query picks up the new decision
   const m001Scoped = queryDecisions({ milestoneId: 'M001' });
-  assertTrue(m001Scoped.length === 3, 're-import: all 3 decisions are for M001');
+  assert.ok(m001Scoped.length === 3, 're-import: all 3 decisions are for M001');
 
   closeDatabase();
-}
+});
 
 // ─── Final Report ──────────────────────────────────────────────────────────
-report();
+});

package/src/resources/extensions/gsd/tests/queue-draft-detection.test.ts

@@ -1,3 +1,5 @@
+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";
@@ -5,122 +7,94 @@ import { tmpdir } from "node:os";
 import { deriveState } from "../state.js";
 import { buildExistingMilestonesContext } from "../guided-flow.js";
 
-let passed = 0;
-let failed = 0;
-
-function assert(condition: boolean, message: string): void {
-  if (condition) {
-    passed++;
-  } else {
-    failed++;
-    console.error(`  FAIL: ${message}`);
-  }
-}
-
-// ─── Fixture setup ──────────────────────────────────────────────────────
-
-const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-draft-test-"));
-const gsd = join(tmpBase, ".gsd");
-
-// M001: has only CONTEXT-DRAFT.md (draft milestone)
-mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
-writeFileSync(
-  join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
-  "# M001: Draft Milestone\n\nSeed material from prior discussion.\n",
-);
-
-// M002: has full CONTEXT.md (ready milestone)
-mkdirSync(join(gsd, "milestones", "M002"), { recursive: true });
-writeFileSync(
-  join(gsd, "milestones", "M002", "M002-CONTEXT.md"),
-  "# M002: Ready Milestone\n\nFull context from deep discussion.\n",
-);
-
-// M003: has both CONTEXT.md and CONTEXT-DRAFT.md (CONTEXT wins)
-mkdirSync(join(gsd, "milestones", "M003"), { recursive: true });
-writeFileSync(
-  join(gsd, "milestones", "M003", "M003-CONTEXT.md"),
-  "# M003: Full Context\n\nThis is the real context.\n",
-);
-writeFileSync(
-  join(gsd, "milestones", "M003", "M003-CONTEXT-DRAFT.md"),
-  "# M003: Draft\n\nThis should be ignored.\n",
-);
-
-// M004: has neither (empty milestone dir)
-mkdirSync(join(gsd, "milestones", "M004"), { recursive: true });
-
-// ─── Build context ──────────────────────────────────────────────────────
-
-const state = await deriveState(tmpBase);
-const milestoneIds = ["M001", "M002", "M003", "M004"];
-const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, state);
-
-// ─── Test: draft-only milestone includes "Draft context available" ──────
-
-assert(
-  context.includes("Draft context available"),
-  "M001 (draft-only) should include 'Draft context available' label",
-);
-
-assert(
-  context.includes("Seed material from prior discussion"),
-  "M001 draft content should be included in context output",
-);
-
-// ─── Test: full-context milestone uses "Context:" label ────────────────
-
-assert(
-  context.includes("**Context:**"),
-  "M002 (full context) should use 'Context:' label",
-);
-
-assert(
-  context.includes("Full context from deep discussion"),
-  "M002 context content should be included",
-);
-
-// ─── Test: both files → CONTEXT.md wins, no draft label ────────────────
-
-// Find M003's section and check it has Context: but not Draft
-const m003Idx = context.indexOf("M003:");
-const m003Section = context.slice(m003Idx, m003Idx + 500);
-
-assert(
-  m003Section.includes("**Context:**"),
-  "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
-);
-
-assert(
-  !m003Section.includes("Draft context available"),
-  "M003 (both files) should NOT show draft label — CONTEXT.md takes precedence",
-);
-
-assert(
-  m003Section.includes("This is the real context"),
-  "M003 should show CONTEXT.md content, not draft content",
-);
-
-// ─── Test: neither file → no context section ───────────────────────────
-
-const m004Idx = context.indexOf("M004:");
-const m004Section = context.slice(m004Idx, m004Idx + 500);
-
-assert(
-  !m004Section.includes("**Context:**"),
-  "M004 (neither file) should not have Context: label",
-);
-
-assert(
-  !m004Section.includes("Draft context available"),
-  "M004 (neither file) should not have Draft label",
-);
-
-// ─── Cleanup ──────────────────────────────────────────────────────────
-
-rmSync(tmpBase, { recursive: true, force: true });
-
-// ─── Results ──────────────────────────────────────────────────────────
-
-console.log(`\nqueue-draft-detection: ${passed} passed, ${failed} failed`);
-if (failed > 0) process.exit(1);
+describe('queue-draft-detection', () => {
+  test('draft and context milestone detection', async () => {
+    const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-draft-test-"));
+    const gsd = join(tmpBase, ".gsd");
+
+    try {
+      // M001: has only CONTEXT-DRAFT.md (draft milestone)
+      mkdirSync(join(gsd, "milestones", "M001"), { recursive: true });
+      writeFileSync(
+        join(gsd, "milestones", "M001", "M001-CONTEXT-DRAFT.md"),
+        "# M001: Draft Milestone\n\nSeed material from prior discussion.\n",
+      );
+
+      // M002: has full CONTEXT.md (ready milestone)
+      mkdirSync(join(gsd, "milestones", "M002"), { recursive: true });
+      writeFileSync(
+        join(gsd, "milestones", "M002", "M002-CONTEXT.md"),
+        "# M002: Ready Milestone\n\nFull context from deep discussion.\n",
+      );
+
+      // M003: has both CONTEXT.md and CONTEXT-DRAFT.md (CONTEXT wins)
+      mkdirSync(join(gsd, "milestones", "M003"), { recursive: true });
+      writeFileSync(
+        join(gsd, "milestones", "M003", "M003-CONTEXT.md"),
+        "# M003: Full Context\n\nThis is the real context.\n",
+      );
+      writeFileSync(
+        join(gsd, "milestones", "M003", "M003-CONTEXT-DRAFT.md"),
+        "# M003: Draft\n\nThis should be ignored.\n",
+      );
+
+      // M004: has neither (empty milestone dir)
+      mkdirSync(join(gsd, "milestones", "M004"), { recursive: true });
+
+      // Build context
+      const state = await deriveState(tmpBase);
+      const milestoneIds = ["M001", "M002", "M003", "M004"];
+      const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, state);
+
+      // draft-only milestone includes "Draft context available"
+      assert.ok(
+        context.includes("Draft context available"),
+        "M001 (draft-only) should include 'Draft context available' label",
+      );
+      assert.ok(
+        context.includes("Seed material from prior discussion"),
+        "M001 draft content should be included in context output",
+      );
+
+      // full-context milestone uses "Context:" label
+      assert.ok(
+        context.includes("**Context:**"),
+        "M002 (full context) should use 'Context:' label",
+      );
+      assert.ok(
+        context.includes("Full context from deep discussion"),
+        "M002 context content should be included",
+      );
+
+      // both files: CONTEXT.md wins, no draft label
+      const m003Idx = context.indexOf("M003:");
+      const m003Section = context.slice(m003Idx, m003Idx + 500);
+      assert.ok(
+        m003Section.includes("**Context:**"),
+        "M003 (both files) should use 'Context:' label (CONTEXT.md wins)",
+      );
+      assert.ok(
+        !m003Section.includes("Draft context available"),
+        "M003 (both files) should NOT show draft label — CONTEXT.md takes precedence",
+      );
+      assert.ok(
+        m003Section.includes("This is the real context"),
+        "M003 should show CONTEXT.md content, not draft content",
+      );
+
+      // neither file: no context section
+      const m004Idx = context.indexOf("M004:");
+      const m004Section = context.slice(m004Idx, m004Idx + 500);
+      assert.ok(
+        !m004Section.includes("**Context:**"),
+        "M004 (neither file) should not have Context: label",
+      );
+      assert.ok(
+        !m004Section.includes("Draft context available"),
+        "M004 (neither file) should not have Draft label",
+      );
+    } finally {
+      rmSync(tmpBase, { recursive: true, force: true });
+    }
+  });
+});