gsd-pi 2.26.1-next.1 → 2.28.0-dev.346ee62

package/dist/resources/extensions/gsd/tests/extension-selector-separator.test.ts

@@ -0,0 +1,122 @@
+// Tests for the SEPARATOR_PREFIX convention used by ExtensionSelectorComponent.
+// We cannot import the component directly in node:test because its transitive
+// dependency (countdown-timer.ts) uses TypeScript parameter properties which
+// are unsupported under --experimental-strip-types. Instead we duplicate the
+// separator detection logic here and verify the contract.
+
+import test, { describe } from "node:test";
+import assert from "node:assert/strict";
+
+/** Must match the constant exported from extension-selector.ts */
+const SEPARATOR_PREFIX = "───";
+
+function isSeparator(options: string[], index: number): boolean {
+	return options[index]?.startsWith(SEPARATOR_PREFIX) ?? false;
+}
+
+function nextSelectable(options: string[], from: number, direction: 1 | -1): number {
+	let idx = from;
+	while (idx >= 0 && idx < options.length && isSeparator(options, idx)) {
+		idx += direction;
+	}
+	if (idx < 0 || idx >= options.length) {
+		return Math.max(0, Math.min(from, options.length - 1));
+	}
+	return idx;
+}
+
+describe("separator detection", () => {
+	const options = [
+		`${SEPARATOR_PREFIX} anthropic (2) ${SEPARATOR_PREFIX}`,
+		"claude-opus-4-6 · anthropic",
+		"claude-sonnet-4-5 · anthropic",
+		`${SEPARATOR_PREFIX} openai (1) ${SEPARATOR_PREFIX}`,
+		"gpt-4o · openai",
+		"(keep current)",
+		"(clear)",
+	];
+
+	test("identifies separator rows correctly", () => {
+		assert.ok(isSeparator(options, 0));
+		assert.ok(!isSeparator(options, 1));
+		assert.ok(!isSeparator(options, 2));
+		assert.ok(isSeparator(options, 3));
+		assert.ok(!isSeparator(options, 4));
+	});
+
+	test("nextSelectable skips leading separator", () => {
+		assert.strictEqual(nextSelectable(options, 0, 1), 1);
+	});
+
+	test("nextSelectable skips separator going down", () => {
+		// From index 2 (claude-sonnet), next is index 3 (separator), should skip to 4
+		assert.strictEqual(nextSelectable(options, 3, 1), 4);
+	});
+
+	test("nextSelectable skips separator going up", () => {
+		// From index 4 (gpt-4o), prev is index 3 (separator), should skip to 2
+		assert.strictEqual(nextSelectable(options, 3, -1), 2);
+	});
+
+	test("nextSelectable clamps to bounds", () => {
+		assert.strictEqual(nextSelectable(options, 6, 1), 6);
+	});
+
+	test("works with no separators", () => {
+		const plain = ["alpha", "beta", "gamma"];
+		assert.strictEqual(nextSelectable(plain, 0, 1), 0);
+		assert.strictEqual(nextSelectable(plain, 1, 1), 1);
+	});
+});
+
+describe("model grouping", () => {
+	test("groups models by provider with separator headers", () => {
+		// Simulate the grouping logic from configureModels
+		const availableModels = [
+			{ id: "claude-opus-4-6", provider: "anthropic" },
+			{ id: "gpt-4o", provider: "openai" },
+			{ id: "claude-sonnet-4-5", provider: "anthropic" },
+			{ id: "o3-mini", provider: "openai" },
+		];
+
+		const byProvider = new Map<string, typeof availableModels>();
+		for (const m of availableModels) {
+			let group = byProvider.get(m.provider);
+			if (!group) {
+				group = [];
+				byProvider.set(m.provider, group);
+			}
+			group.push(m);
+		}
+		const providers = Array.from(byProvider.keys()).sort((a, b) => a.localeCompare(b));
+
+		const modelOptions: string[] = [];
+		for (const provider of providers) {
+			const group = byProvider.get(provider)!;
+			modelOptions.push(`${SEPARATOR_PREFIX} ${provider} (${group.length}) ${SEPARATOR_PREFIX}`);
+			for (const m of group) {
+				modelOptions.push(`${m.id} · ${m.provider}`);
+			}
+		}
+		modelOptions.push("(keep current)", "(clear)");
+
+		// Verify structure
+		assert.strictEqual(modelOptions[0], `${SEPARATOR_PREFIX} anthropic (2) ${SEPARATOR_PREFIX}`);
+		assert.strictEqual(modelOptions[1], "claude-opus-4-6 · anthropic");
+		assert.strictEqual(modelOptions[2], "claude-sonnet-4-5 · anthropic");
+		assert.strictEqual(modelOptions[3], `${SEPARATOR_PREFIX} openai (2) ${SEPARATOR_PREFIX}`);
+		assert.strictEqual(modelOptions[4], "gpt-4o · openai");
+		assert.strictEqual(modelOptions[5], "o3-mini · openai");
+		assert.strictEqual(modelOptions[6], "(keep current)");
+		assert.strictEqual(modelOptions[7], "(clear)");
+
+		// Verify separators are correctly detected
+		assert.ok(isSeparator(modelOptions, 0));
+		assert.ok(!isSeparator(modelOptions, 1));
+		assert.ok(isSeparator(modelOptions, 3));
+		assert.ok(!isSeparator(modelOptions, 6));
+
+		// Verify first selectable is index 1, not the separator at 0
+		assert.strictEqual(nextSelectable(modelOptions, 0, 1), 1);
+	});
+});

package/dist/resources/extensions/gsd/tests/feature-branch-lifecycle-integration.test.ts

@@ -75,6 +75,9 @@ function createFeatureBranchRepo(featureBranch: string): string {
 
   // Initial commit on main
   writeFileSync(join(dir, "README.md"), "# project\n");
+  // Mirror production: GSD runtime dirs are gitignored so autoCommitDirtyState
+  // doesn't pick up the worktrees directory as dirty state (#1127 fix).
+  writeFileSync(join(dir, ".gitignore"), ".gsd/worktrees/\n");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
   writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
   run("git add .", dir);

package/dist/resources/extensions/gsd/tests/headless-answers.test.ts

@@ -0,0 +1,340 @@
+/**
+ * Tests for the headless-answers module.
+ *
+ * Covers loadAndValidateAnswerFile (file loading + schema validation) and
+ * AnswerInjector (event observation, answer matching, deferred resolution,
+ * secrets, stats, and unused warnings).
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { loadAndValidateAnswerFile, AnswerInjector } from '../../../../headless-answers.ts';
+
+function makeTempDir(prefix: string): string {
+  const dir = join(tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ---------------------------------------------------------------------------
+// loadAndValidateAnswerFile
+// ---------------------------------------------------------------------------
+
+test('loadAndValidateAnswerFile — valid file', () => {
+  const tmp = makeTempDir('answers-valid');
+  try {
+    const data = {
+      questions: { deploy_target: 'GCP', features: ['auth', 'payments'] },
+      secrets: { API_KEY: 'sk-123' },
+      defaults: { strategy: 'first_option' },
+    };
+    const filePath = join(tmp, 'answers.json');
+    writeFileSync(filePath, JSON.stringify(data));
+
+    const result = loadAndValidateAnswerFile(filePath);
+    assert.deepStrictEqual(result.questions, data.questions);
+    assert.deepStrictEqual(result.secrets, data.secrets);
+    assert.deepStrictEqual(result.defaults, data.defaults);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('loadAndValidateAnswerFile — invalid JSON', () => {
+  const tmp = makeTempDir('answers-bad-json');
+  try {
+    const filePath = join(tmp, 'answers.json');
+    writeFileSync(filePath, '{not valid json!!!');
+
+    assert.throws(
+      () => loadAndValidateAnswerFile(filePath),
+      (err: Error) => err.message.includes('JSON'),
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('loadAndValidateAnswerFile — wrong types (non-string question value)', () => {
+  const tmp = makeTempDir('answers-bad-q');
+  try {
+    const filePath = join(tmp, 'answers.json');
+    writeFileSync(filePath, JSON.stringify({ questions: { q1: 42 } }));
+
+    assert.throws(
+      () => loadAndValidateAnswerFile(filePath),
+      (err: Error) => err.message.includes('questions.q1'),
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+test('loadAndValidateAnswerFile — wrong types (non-string secret value)', () => {
+  const tmp = makeTempDir('answers-bad-secret');
+  try {
+    const filePath = join(tmp, 'answers.json');
+    writeFileSync(filePath, JSON.stringify({ secrets: { KEY: 42 } }));
+
+    assert.throws(
+      () => loadAndValidateAnswerFile(filePath),
+      (err: Error) => err.message.includes('secrets.KEY'),
+    );
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});
+
+// ---------------------------------------------------------------------------
+// AnswerInjector — observeEvent + tryHandle
+// ---------------------------------------------------------------------------
+
+function makeToolExecutionStart(questions: Record<string, unknown>[]) {
+  return {
+    type: 'tool_execution_start',
+    toolName: 'ask_user_questions',
+    input: { questions },
+  };
+}
+
+function makeSelectEvent(
+  id: string,
+  title: string,
+  options: string[],
+  extra?: Record<string, unknown>,
+) {
+  return {
+    type: 'extension_ui_request',
+    id,
+    method: 'select',
+    title,
+    options,
+    ...extra,
+  };
+}
+
+test('observeEvent stores metadata', () => {
+  const injector = new AnswerInjector({});
+
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'deploy_target',
+    header: 'Deploy',
+    question: 'Where to deploy?',
+    options: [{ label: 'AWS' }, { label: 'GCP' }],
+  }]));
+
+  // Verify metadata was stored: tryHandle with a matching select event should
+  // go through processWithMeta. With no answer in the file, first_option
+  // strategy returns false (falls through to auto-responder).
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  const event = makeSelectEvent('req-1', 'Deploy: Where to deploy?', ['AWS', 'GCP']);
+  const handled = injector.tryHandle(event, captureStdin);
+
+  // No answer file entry → first_option strategy → returns false (let auto-responder handle)
+  assert.strictEqual(handled, false);
+  // But questionsDefaulted should be incremented because processWithMeta was reached
+  assert.strictEqual(injector.getStats().questionsDefaulted, 1);
+});
+
+test('tryHandle matches by question ID — single select', () => {
+  const injector = new AnswerInjector({ questions: { deploy_target: 'GCP' } });
+
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'deploy_target',
+    header: 'Deploy',
+    question: 'Where to deploy?',
+    options: [{ label: 'AWS' }, { label: 'GCP' }],
+  }]));
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  const event = makeSelectEvent('req-1', 'Deploy: Where to deploy?', ['AWS', 'GCP']);
+  const handled = injector.tryHandle(event, captureStdin);
+
+  assert.strictEqual(handled, true);
+  assert.strictEqual(captured.length, 1);
+  const response = JSON.parse(captured[0].trim());
+  assert.strictEqual(response.type, 'extension_ui_response');
+  assert.strictEqual(response.id, 'req-1');
+  assert.strictEqual(response.value, 'GCP');
+  assert.strictEqual(injector.getStats().questionsAnswered, 1);
+});
+
+test('tryHandle unknown question deferred — first_option timeout', async () => {
+  const injector = new AnswerInjector({ defaults: { strategy: 'first_option' } });
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  // No observeEvent call — no metadata exists
+  const event = makeSelectEvent('req-d', 'Unknown: Unknown question?', ['OptionA', 'OptionB']);
+  const handled = injector.tryHandle(event, captureStdin);
+
+  // Should be deferred (returns true)
+  assert.strictEqual(handled, true);
+  assert.strictEqual(captured.length, 0, 'nothing sent immediately');
+
+  // Wait for the 500ms deferred timeout to fire
+  await new Promise((resolve) => setTimeout(resolve, 600));
+
+  assert.strictEqual(captured.length, 1);
+  const response = JSON.parse(captured[0].trim());
+  assert.strictEqual(response.type, 'extension_ui_response');
+  assert.strictEqual(response.id, 'req-d');
+  assert.strictEqual(response.value, 'OptionA');
+  assert.strictEqual(injector.getStats().questionsDefaulted, 1);
+});
+
+test('tryHandle multi-select', () => {
+  const injector = new AnswerInjector({ questions: { features: ['auth', 'payments'] } });
+
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'features',
+    header: 'Features',
+    question: 'Which features?',
+    options: [{ label: 'auth' }, { label: 'payments' }, { label: 'analytics' }],
+    allowMultiple: true,
+  }]));
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  const event = makeSelectEvent(
+    'req-2',
+    'Features: Which features?',
+    ['auth', 'payments', 'analytics'],
+    { allowMultiple: true },
+  );
+  const handled = injector.tryHandle(event, captureStdin);
+
+  assert.strictEqual(handled, true);
+  assert.strictEqual(captured.length, 1);
+  const response = JSON.parse(captured[0].trim());
+  assert.strictEqual(response.type, 'extension_ui_response');
+  assert.strictEqual(response.id, 'req-2');
+  assert.deepStrictEqual(response.values, ['auth', 'payments']);
+  assert.strictEqual(injector.getStats().questionsAnswered, 1);
+});
+
+test('tryHandle answer not in options — first_option strategy returns false', () => {
+  const injector = new AnswerInjector({ questions: { deploy_target: 'Azure' } });
+
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'deploy_target',
+    header: 'Deploy',
+    question: 'Where to deploy?',
+    options: [{ label: 'AWS' }, { label: 'GCP' }],
+  }]));
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  const event = makeSelectEvent('req-3', 'Deploy: Where to deploy?', ['AWS', 'GCP']);
+  const handled = injector.tryHandle(event, captureStdin);
+
+  // first_option strategy with invalid answer: returns false (auto-responder handles it)
+  assert.strictEqual(handled, false);
+  assert.strictEqual(captured.length, 0);
+  assert.strictEqual(injector.getStats().questionsDefaulted, 1);
+  assert.strictEqual(injector.getStats().questionsAnswered, 0);
+});
+
+test('tryHandle deferred resolution — observeEvent after tryHandle', async () => {
+  const injector = new AnswerInjector({ questions: { deploy_target: 'GCP' } });
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+
+  // Call tryHandle BEFORE observeEvent (out-of-order)
+  const event = makeSelectEvent('req-4', 'Deploy: Where to deploy?', ['AWS', 'GCP']);
+  const handled = injector.tryHandle(event, captureStdin);
+  assert.strictEqual(handled, true, 'event should be deferred');
+  assert.strictEqual(captured.length, 0, 'nothing sent yet');
+
+  // Now deliver the metadata — deferred event should be resolved immediately
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'deploy_target',
+    header: 'Deploy',
+    question: 'Where to deploy?',
+    options: [{ label: 'AWS' }, { label: 'GCP' }],
+  }]));
+
+  assert.strictEqual(captured.length, 1, 'deferred event resolved synchronously');
+  const response = JSON.parse(captured[0].trim());
+  assert.strictEqual(response.type, 'extension_ui_response');
+  assert.strictEqual(response.id, 'req-4');
+  assert.strictEqual(response.value, 'GCP');
+  assert.strictEqual(injector.getStats().questionsAnswered, 1);
+});
+
+// ---------------------------------------------------------------------------
+// AnswerInjector — getSecretEnvVars
+// ---------------------------------------------------------------------------
+
+test('getSecretEnvVars returns secrets map', () => {
+  const secrets = { API_KEY: 'sk-123', DB_URL: 'postgres://localhost/db' };
+  const injector = new AnswerInjector({ secrets });
+
+  assert.deepStrictEqual(injector.getSecretEnvVars(), secrets);
+});
+
+// ---------------------------------------------------------------------------
+// AnswerInjector — getUnusedWarnings
+// ---------------------------------------------------------------------------
+
+test('getUnusedWarnings reports unused question IDs and secret keys', () => {
+  const injector = new AnswerInjector({
+    questions: { q1: 'val1', q2: 'val2' },
+    secrets: { KEY1: 'v1' },
+  });
+
+  // Set up and use q1, but leave q2 and KEY1 unused
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'q1',
+    header: 'H1',
+    question: 'Question 1?',
+    options: [{ label: 'val1' }, { label: 'other' }],
+  }]));
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  injector.tryHandle(
+    makeSelectEvent('req-u1', 'H1: Question 1?', ['val1', 'other']),
+    captureStdin,
+  );
+
+  const warnings = injector.getUnusedWarnings();
+  assert.ok(warnings.some((w) => w.includes('q2')), 'should warn about unused question q2');
+  assert.ok(warnings.some((w) => w.includes('KEY1')), 'should warn about unused secret KEY1');
+  assert.ok(!warnings.some((w) => w.includes('q1')), 'should not warn about used question q1');
+});
+
+// ---------------------------------------------------------------------------
+// AnswerInjector — defaults.strategy cancel
+// ---------------------------------------------------------------------------
+
+test('defaults.strategy cancel — sends cancelled response', () => {
+  const injector = new AnswerInjector({ defaults: { strategy: 'cancel' } });
+
+  injector.observeEvent(makeToolExecutionStart([{
+    id: 'deploy_target',
+    header: 'Deploy',
+    question: 'Where to deploy?',
+    options: [{ label: 'AWS' }, { label: 'GCP' }],
+  }]));
+
+  const captured: string[] = [];
+  const captureStdin = (data: string) => { captured.push(data); };
+  const event = makeSelectEvent('req-c', 'Deploy: Where to deploy?', ['AWS', 'GCP']);
+  const handled = injector.tryHandle(event, captureStdin);
+
+  // No answer in file + cancel strategy → sends cancelled response
+  assert.strictEqual(handled, true);
+  assert.strictEqual(captured.length, 1);
+  const response = JSON.parse(captured[0].trim());
+  assert.strictEqual(response.type, 'extension_ui_response');
+  assert.strictEqual(response.id, 'req-c');
+  assert.strictEqual(response.cancelled, true);
+  assert.strictEqual(injector.getStats().questionsDefaulted, 1);
+});

package/dist/resources/extensions/gsd/tests/headless-query.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Tests for `gsd headless query` — single JSON snapshot command.
+ *
+ * Validates that the snapshot contains state, next dispatch preview,
+ * and parallel worker costs in one response.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+
+import { handleQuery } from '../../../../headless-query.ts'
+import type { QuerySnapshot } from '../../../../headless-query.ts'
+import { invalidateStateCache } from '../state.ts'
+
+// ─── Fixture Helpers ────────────────────────────────────────────────────────
+
+function createFixture(): string {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-query-test-'))
+  mkdirSync(join(base, '.gsd', 'milestones'), { recursive: true })
+  return base
+}
+
+function writeRoadmap(base: string, mid: string, content: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid)
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, `${mid}-ROADMAP.md`), content)
+}
+
+function writeContext(base: string, mid: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid)
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, `${mid}-CONTEXT.md`), `---\ntitle: Test Milestone\n---\n\n# Context\nTest.`)
+}
+
+function writeSlicePlan(base: string, mid: string, sid: string, content: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid)
+  mkdirSync(join(dir, 'tasks'), { recursive: true })
+  writeFileSync(join(dir, `${sid}-PLAN.md`), content)
+}
+
+function writeTaskPlan(base: string, mid: string, sid: string, tid: string): void {
+  const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid, 'tasks')
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, `${tid}-PLAN.md`), `---\nestimated_steps: 3\nestimated_files: 2\n---\n\n# ${tid}: Test Task\nDo something.`)
+}
+
+function writeParallelStatus(base: string, mid: string, cost: number): void {
+  const dir = join(base, '.gsd', 'parallel')
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, `${mid}.status.json`), JSON.stringify({
+    milestoneId: mid,
+    pid: process.pid,
+    state: 'running',
+    currentUnit: { type: 'execute-task', id: `${mid}/S01/T01`, startedAt: Date.now() },
+    completedUnits: 2,
+    cost,
+    lastHeartbeat: Date.now(),
+    startedAt: Date.now() - 60_000,
+    worktreePath: `/tmp/worktrees/${mid}`,
+  }))
+}
+
+function createExecutingFixture(base: string): void {
+  writeContext(base, 'M001')
+  writeRoadmap(base, 'M001', `# M001: Test Milestone
+
+**Vision:** Build something.
+
+## Slices
+
+- [ ] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > After this: The first slice works.
+`)
+  writeSlicePlan(base, 'M001', 'S01', `# S01: First Slice
+
+**Goal:** Implement something.
+**Demo:** It works.
+
+## Tasks
+
+- [ ] **T01: First Task** — Do the first thing
+  - Files: foo.ts
+  - Verify: run tests
+- [ ] **T02: Second Task** — Do the second thing
+  - Files: bar.ts
+`)
+  writeTaskPlan(base, 'M001', 'S01', 'T01')
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe('headless query', () => {
+  let base: string
+
+  beforeEach(() => {
+    base = createFixture()
+    invalidateStateCache()
+  })
+
+  afterEach(() => {
+    rmSync(base, { recursive: true, force: true })
+  })
+
+  it('returns snapshot with state, next, and cost', async () => {
+    createExecutingFixture(base)
+    const result = await handleQuery(base)
+    const snap = result.data as QuerySnapshot
+
+    assert.equal(result.exitCode, 0)
+    // state
+    assert.equal(snap.state.phase, 'executing')
+    assert.equal(snap.state.activeMilestone!.id, 'M001')
+    assert.equal(snap.state.activeSlice!.id, 'S01')
+    assert.equal(snap.state.activeTask!.id, 'T01')
+    assert.ok(Array.isArray(snap.state.registry))
+    assert.ok(snap.state.progress)
+    // next
+    assert.equal(snap.next.action, 'dispatch')
+    assert.equal(snap.next.unitType, 'execute-task')
+    assert.ok(snap.next.unitId)
+    // cost (no parallel workers)
+    assert.equal(snap.cost.workers.length, 0)
+    assert.equal(snap.cost.total, 0)
+  })
+
+  it('returns stop when no milestones exist', async () => {
+    const result = await handleQuery(base)
+    const snap = result.data as QuerySnapshot
+
+    assert.equal(result.exitCode, 0)
+    assert.equal(snap.state.phase, 'pre-planning')
+    assert.equal(snap.state.activeMilestone, null)
+    assert.equal(snap.next.action, 'stop')
+    assert.ok(snap.next.reason)
+  })
+
+  it('aggregates parallel worker costs', async () => {
+    createExecutingFixture(base)
+    writeParallelStatus(base, 'M001', 1.50)
+    writeParallelStatus(base, 'M002', 2.75)
+    const result = await handleQuery(base)
+    const snap = result.data as QuerySnapshot
+
+    assert.equal(snap.cost.workers.length, 2)
+    assert.equal(snap.cost.total, 4.25)
+    assert.ok(snap.cost.workers.some(w => w.milestoneId === 'M001' && w.cost === 1.50))
+    assert.ok(snap.cost.workers.some(w => w.milestoneId === 'M002' && w.cost === 2.75))
+  })
+
+  it('shows dispatch preview for pre-planning with context', async () => {
+    writeContext(base, 'M001')
+    const result = await handleQuery(base)
+    const snap = result.data as QuerySnapshot
+
+    assert.equal(snap.state.phase, 'pre-planning')
+    assert.equal(snap.state.activeMilestone!.id, 'M001')
+    assert.equal(snap.next.action, 'dispatch')
+  })
+})