gsd-pi 2.33.1 → 2.34.0-dev.6769913

package/dist/resources/extensions/gsd/tests/gsd-tools.test.ts

@@ -1,326 +0,0 @@
-// gsd-tools — Structured LLM tool tests
-//
-// Tests the three registered tools: gsd_save_decision, gsd_update_requirement, gsd_save_summary.
-// Each tool is tested via direct function invocation against an in-memory DB.
-
-import { createTestContext } from './test-helpers.ts';
-import * as path from 'node:path';
-import * as os from 'node:os';
-import * as fs from 'node:fs';
-import {
-  openDatabase,
-  closeDatabase,
-  isDbAvailable,
-  upsertRequirement,
-  getRequirementById,
-  getDecisionById,
-  _getAdapter,
-  insertArtifact,
-} from '../gsd-db.ts';
-import {
-  saveDecisionToDb,
-  updateRequirementInDb,
-  saveArtifactToDb,
-  nextDecisionId,
-} from '../db-writer.ts';
-import type { Requirement } from '../types.ts';
-
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Helpers
-// ═══════════════════════════════════════════════════════════════════════════
-
-function makeTmpDir(): string {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'gsd-tools-'));
-  fs.mkdirSync(path.join(dir, '.gsd'), { recursive: true });
-  return dir;
-}
-
-function cleanupDir(dir: string): void {
-  try {
-    fs.rmSync(dir, { recursive: true, force: true });
-  } catch { /* swallow */ }
-}
-
-/**
- * Simulate tool execute by calling the underlying DB functions directly.
- * The actual tool registration happens in index.ts; here we test the
- * execute logic pattern: check DB → call writer → return result.
- */
-
-// ═══════════════════════════════════════════════════════════════════════════
-// gsd_save_decision tool tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── gsd_save_decision ──');
-
-{
-  const tmpDir = makeTmpDir();
-  try {
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
-    assertTrue(isDbAvailable(), 'DB should be available after open');
-
-    // (a) Decision tool creates DB row + returns new ID
-    const result = await saveDecisionToDb(
-      {
-        scope: 'architecture',
-        decision: 'Use SQLite for metadata',
-        choice: 'SQLite',
-        rationale: 'Sync API fits the CLI model',
-        revisable: 'Yes',
-        when_context: 'M001',
-      },
-      tmpDir,
-    );
-
-    assertEq(result.id, 'D001', 'First decision should be D001');
-
-    // Verify DB row exists
-    const row = getDecisionById('D001');
-    assertTrue(row !== null, 'Decision D001 should exist in DB');
-    assertEq(row!.scope, 'architecture', 'Decision scope should match');
-    assertEq(row!.decision, 'Use SQLite for metadata', 'Decision text should match');
-    assertEq(row!.choice, 'SQLite', 'Decision choice should match');
-
-    // Verify DECISIONS.md was generated
-    const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
-    assertTrue(fs.existsSync(mdPath), 'DECISIONS.md should be created');
-    const mdContent = fs.readFileSync(mdPath, 'utf-8');
-    assertTrue(mdContent.includes('D001'), 'DECISIONS.md should contain D001');
-    assertTrue(mdContent.includes('SQLite'), 'DECISIONS.md should contain choice');
-
-    // (e) Decision tool auto-assigns correct next ID
-    const result2 = await saveDecisionToDb(
-      {
-        scope: 'testing',
-        decision: 'Test runner',
-        choice: 'vitest',
-        rationale: 'Fast and ESM-native',
-      },
-      tmpDir,
-    );
-    assertEq(result2.id, 'D002', 'Second decision should be D002');
-
-    const result3 = await saveDecisionToDb(
-      {
-        scope: 'CI',
-        decision: 'CI platform',
-        choice: 'GitHub Actions',
-        rationale: 'Integrated with repo',
-      },
-      tmpDir,
-    );
-    assertEq(result3.id, 'D003', 'Third decision should be D003');
-
-    closeDatabase();
-  } finally {
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// gsd_update_requirement tool tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── gsd_update_requirement ──');
-
-{
-  const tmpDir = makeTmpDir();
-  try {
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
-
-    // Seed a requirement
-    const seedReq: Requirement = {
-      id: 'R001',
-      class: 'functional',
-      status: 'active',
-      description: 'Must support SQLite storage',
-      why: 'Structured data needs',
-      source: 'design',
-      primary_owner: 'S03',
-      supporting_slices: '',
-      validation: '',
-      notes: '',
-      full_content: '',
-      superseded_by: null,
-    };
-    upsertRequirement(seedReq);
-
-    // (b) Requirement update tool modifies existing requirement
-    await updateRequirementInDb(
-      'R001',
-      { status: 'validated', validation: 'Unit tests pass', notes: 'Verified in S06' },
-      tmpDir,
-    );
-
-    const updated = getRequirementById('R001');
-    assertTrue(updated !== null, 'R001 should still exist');
-    assertEq(updated!.status, 'validated', 'Status should be updated');
-    assertEq(updated!.validation, 'Unit tests pass', 'Validation should be updated');
-    assertEq(updated!.notes, 'Verified in S06', 'Notes should be updated');
-    // Original fields preserved
-    assertEq(updated!.description, 'Must support SQLite storage', 'Description should be preserved');
-    assertEq(updated!.primary_owner, 'S03', 'Primary owner should be preserved');
-
-    // Verify REQUIREMENTS.md was generated
-    const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
-    assertTrue(fs.existsSync(mdPath), 'REQUIREMENTS.md should be created');
-    const mdContent = fs.readFileSync(mdPath, 'utf-8');
-    assertTrue(mdContent.includes('R001'), 'REQUIREMENTS.md should contain R001');
-    assertTrue(mdContent.includes('validated'), 'REQUIREMENTS.md should reflect updated status');
-
-    // Updating non-existent requirement throws
-    let threwForMissing = false;
-    try {
-      await updateRequirementInDb('R999', { status: 'deferred' }, tmpDir);
-    } catch (err) {
-      threwForMissing = true;
-      assertTrue(
-        (err as Error).message.includes('R999'),
-        'Error should mention the missing requirement ID',
-      );
-    }
-    assertTrue(threwForMissing, 'Should throw for non-existent requirement');
-
-    closeDatabase();
-  } finally {
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// gsd_save_summary tool tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── gsd_save_summary ──');
-
-{
-  const tmpDir = makeTmpDir();
-  try {
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
-
-    // (c) Summary tool creates artifact row
-    await saveArtifactToDb(
-      {
-        path: 'milestones/M001/slices/S01/S01-SUMMARY.md',
-        artifact_type: 'SUMMARY',
-        content: '# S01 Summary\n\nThis is a test summary.',
-        milestone_id: 'M001',
-        slice_id: 'S01',
-      },
-      tmpDir,
-    );
-
-    // Verify artifact in DB
-    const adapter = _getAdapter();
-    assertTrue(adapter !== null, 'Adapter should be available');
-    const rows = adapter!.prepare(
-      "SELECT * FROM artifacts WHERE path = 'milestones/M001/slices/S01/S01-SUMMARY.md'",
-    ).all();
-    assertEq(rows.length, 1, 'Should have 1 artifact row');
-    assertEq(rows[0]['artifact_type'] as string, 'SUMMARY', 'Artifact type should be SUMMARY');
-    assertEq(rows[0]['milestone_id'] as string, 'M001', 'Milestone ID should match');
-    assertEq(rows[0]['slice_id'] as string, 'S01', 'Slice ID should match');
-
-    // Verify file was written to disk
-    const filePath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'S01-SUMMARY.md');
-    assertTrue(fs.existsSync(filePath), 'Summary file should be written to disk');
-    const fileContent = fs.readFileSync(filePath, 'utf-8');
-    assertTrue(fileContent.includes('S01 Summary'), 'File should contain summary content');
-
-    // Test milestone-level artifact (no slice_id)
-    await saveArtifactToDb(
-      {
-        path: 'milestones/M001/M001-CONTEXT.md',
-        artifact_type: 'CONTEXT',
-        content: '# M001 Context\n\nContext notes.',
-        milestone_id: 'M001',
-      },
-      tmpDir,
-    );
-
-    const mFilePath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md');
-    assertTrue(fs.existsSync(mFilePath), 'Milestone-level artifact file should be created');
-
-    // Test task-level artifact
-    await saveArtifactToDb(
-      {
-        path: 'milestones/M001/slices/S01/tasks/T01-SUMMARY.md',
-        artifact_type: 'SUMMARY',
-        content: '# T01 Summary\n\nTask summary.',
-        milestone_id: 'M001',
-        slice_id: 'S01',
-        task_id: 'T01',
-      },
-      tmpDir,
-    );
-
-    const tFilePath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md');
-    assertTrue(fs.existsSync(tFilePath), 'Task-level artifact file should be created');
-
-    closeDatabase();
-  } finally {
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// DB unavailable error paths
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── DB unavailable error paths ──');
-
-{
-  // (d) All tools return isError when DB unavailable
-  // Close any open DB and don't open a new one
-  try { closeDatabase(); } catch { /* already closed */ }
-
-  // isDbAvailable() should return false
-  assertTrue(!isDbAvailable(), 'DB should be unavailable after close');
-
-  // nextDecisionId degrades gracefully
-  const fallbackId = await nextDecisionId();
-  assertEq(fallbackId, 'D001', 'nextDecisionId should return D001 when DB unavailable');
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// Tool result format verification
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── Tool result format ──');
-
-{
-  const tmpDir = makeTmpDir();
-  try {
-    const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
-    openDatabase(dbPath);
-
-    // Verify result follows AgentToolResult interface: {content: [{type: "text", text}], details}
-    const result = await saveDecisionToDb(
-      {
-        scope: 'format-test',
-        decision: 'Test format',
-        choice: 'TypeBox',
-        rationale: 'Schema validation',
-      },
-      tmpDir,
-    );
-
-    // The saveDecisionToDb returns {id} — the tool wrapping adds the AgentToolResult shape.
-    // Verify the raw function returns the expected shape.
-    assertTrue(typeof result.id === 'string', 'saveDecisionToDb should return {id: string}');
-    assertMatch(result.id, /^D\d{3}$/, 'ID should match DXXX pattern');
-
-    closeDatabase();
-  } finally {
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-
-report();

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

@@ -1,340 +0,0 @@
-/**
- * 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);
-});