gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -1,9 +1,10 @@
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 // gsd-tools — Structured LLM tool tests
 //
 // Tests the three registered tools: gsd_decision_save, gsd_requirement_update, gsd_summary_save.
 // 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';
@@ -25,8 +26,6 @@ import {
 } from '../db-writer.ts';
 import type { Requirement } from '../types.ts';
 
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
@@ -46,281 +45,249 @@ function cleanupDir(dir: string): void {
 /**
  * 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.
+ * execute logic pattern: check DB -> call writer -> return result.
  */
 
-// ═══════════════════════════════════════════════════════════════════════════
-// gsd_decision_save tool tests
-// ═══════════════════════════════════════════════════════════════════════════
-
-console.log('\n── gsd_decision_save ──');
-
-{
-  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);
-  }
-}
+describe('gsd-tools', () => {
+  test('gsd_decision_save', async () => {
+    const tmpDir = makeTmpDir();
+    try {
+      const dbPath = path.join(tmpDir, '.gsd', 'gsd.db');
+      openDatabase(dbPath);
+      assert.ok(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,
+      );
 
-// ═══════════════════════════════════════════════════════════════════════════
-// gsd_requirement_update tool tests
-// ═══════════════════════════════════════════════════════════════════════════
+      assert.deepStrictEqual(result.id, 'D001', 'First decision should be D001');
+
+      // Verify DB row exists
+      const row = getDecisionById('D001');
+      assert.ok(row !== null, 'Decision D001 should exist in DB');
+      assert.deepStrictEqual(row!.scope, 'architecture', 'Decision scope should match');
+      assert.deepStrictEqual(row!.decision, 'Use SQLite for metadata', 'Decision text should match');
+      assert.deepStrictEqual(row!.choice, 'SQLite', 'Decision choice should match');
+
+      // Verify DECISIONS.md was generated
+      const mdPath = path.join(tmpDir, '.gsd', 'DECISIONS.md');
+      assert.ok(fs.existsSync(mdPath), 'DECISIONS.md should be created');
+      const mdContent = fs.readFileSync(mdPath, 'utf-8');
+      assert.ok(mdContent.includes('D001'), 'DECISIONS.md should contain D001');
+      assert.ok(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,
+      );
+      assert.deepStrictEqual(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,
+      );
+      assert.deepStrictEqual(result3.id, 'D003', 'Third decision should be D003');
 
-console.log('\n── gsd_requirement_update ──');
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
 
-{
-  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;
+  test('gsd_requirement_update', async () => {
+    const tmpDir = makeTmpDir();
     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',
+      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,
       );
-    }
-    assertTrue(threwForMissing, 'Should throw for non-existent requirement');
-
-    closeDatabase();
-  } finally {
-    cleanupDir(tmpDir);
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════
-// gsd_summary_save tool tests
-// ═══════════════════════════════════════════════════════════════════════════
 
-console.log('\n── gsd_summary_save ──');
+      const updated = getRequirementById('R001');
+      assert.ok(updated !== null, 'R001 should still exist');
+      assert.deepStrictEqual(updated!.status, 'validated', 'Status should be updated');
+      assert.deepStrictEqual(updated!.validation, 'Unit tests pass', 'Validation should be updated');
+      assert.deepStrictEqual(updated!.notes, 'Verified in S06', 'Notes should be updated');
+      // Original fields preserved
+      assert.deepStrictEqual(updated!.description, 'Must support SQLite storage', 'Description should be preserved');
+      assert.deepStrictEqual(updated!.primary_owner, 'S03', 'Primary owner should be preserved');
+
+      // Verify REQUIREMENTS.md was generated
+      const mdPath = path.join(tmpDir, '.gsd', 'REQUIREMENTS.md');
+      assert.ok(fs.existsSync(mdPath), 'REQUIREMENTS.md should be created');
+      const mdContent = fs.readFileSync(mdPath, 'utf-8');
+      assert.ok(mdContent.includes('R001'), 'REQUIREMENTS.md should contain R001');
+      assert.ok(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;
+        assert.ok(
+          (err as Error).message.includes('R999'),
+          'Error should mention the missing requirement ID',
+        );
+      }
+      assert.ok(threwForMissing, 'Should throw for non-existent requirement');
+
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
 
-{
-  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);
-  }
-}
+  test('gsd_summary_save', async () => {
+    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,
+      );
 
-// ═══════════════════════════════════════════════════════════════════════════
-// DB unavailable error paths
-// ═══════════════════════════════════════════════════════════════════════════
+      // Verify artifact in DB
+      const adapter = _getAdapter();
+      assert.ok(adapter !== null, 'Adapter should be available');
+      const rows = adapter!.prepare(
+        "SELECT * FROM artifacts WHERE path = 'milestones/M001/slices/S01/S01-SUMMARY.md'",
+      ).all();
+      assert.deepStrictEqual(rows.length, 1, 'Should have 1 artifact row');
+      assert.deepStrictEqual(rows[0]['artifact_type'] as string, 'SUMMARY', 'Artifact type should be SUMMARY');
+      assert.deepStrictEqual(rows[0]['milestone_id'] as string, 'M001', 'Milestone ID should match');
+      assert.deepStrictEqual(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');
+      assert.ok(fs.existsSync(filePath), 'Summary file should be written to disk');
+      const fileContent = fs.readFileSync(filePath, 'utf-8');
+      assert.ok(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,
+      );
 
-console.log('\n── DB unavailable error paths ──');
+      const mFilePath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'M001-CONTEXT.md');
+      assert.ok(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,
+      );
 
-{
-  // (d) All tools return isError when DB unavailable
-  // Close any open DB and don't open a new one
-  try { closeDatabase(); } catch { /* already closed */ }
+      const tFilePath = path.join(tmpDir, '.gsd', 'milestones', 'M001', 'slices', 'S01', 'tasks', 'T01-SUMMARY.md');
+      assert.ok(fs.existsSync(tFilePath), 'Task-level artifact file should be created');
 
-  // isDbAvailable() should return false
-  assertTrue(!isDbAvailable(), 'DB should be unavailable after close');
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
 
-  // nextDecisionId degrades gracefully
-  const fallbackId = await nextDecisionId();
-  assertEq(fallbackId, 'D001', 'nextDecisionId should return D001 when DB unavailable');
-}
+  test('DB unavailable error paths', async () => {
+    // (d) All tools return isError when DB unavailable
+    // Close any open DB and don't open a new one
+    try { closeDatabase(); } catch { /* already closed */ }
 
-// ═══════════════════════════════════════════════════════════════════════════
-// Tool result format verification
-// ═══════════════════════════════════════════════════════════════════════════
+    // isDbAvailable() should return false
+    assert.ok(!isDbAvailable(), 'DB should be unavailable after close');
 
-console.log('\n── Tool result format ──');
+    // nextDecisionId degrades gracefully
+    const fallbackId = await nextDecisionId();
+    assert.deepStrictEqual(fallbackId, 'D001', 'nextDecisionId should return D001 when DB unavailable');
+  });
 
-{
-  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);
-  }
-}
+  test('Tool result format', async () => {
+    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.
+      assert.ok(typeof result.id === 'string', 'saveDecisionToDb should return {id: string}');
+      assert.match(result.id, /^D\d{3}$/, 'ID should match DXXX pattern');
 
-report();
+      closeDatabase();
+    } finally {
+      cleanupDir(tmpDir);
+    }
+  });
+});

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

@@ -23,7 +23,7 @@ function makeTempDir(prefix: string): string {
 // loadAndValidateAnswerFile
 // ---------------------------------------------------------------------------
 
-test('loadAndValidateAnswerFile — valid file', () => {
+test('loadAndValidateAnswerFile — valid file', (t) => {
   const tmp = makeTempDir('answers-valid');
   try {
     const data = {
@@ -43,7 +43,7 @@ test('loadAndValidateAnswerFile — valid file', () => {
   }
 });
 
-test('loadAndValidateAnswerFile — invalid JSON', () => {
+test('loadAndValidateAnswerFile — invalid JSON', (t) => {
   const tmp = makeTempDir('answers-bad-json');
   try {
     const filePath = join(tmp, 'answers.json');
@@ -58,7 +58,7 @@ test('loadAndValidateAnswerFile — invalid JSON', () => {
   }
 });
 
-test('loadAndValidateAnswerFile — wrong types (non-string question value)', () => {
+test('loadAndValidateAnswerFile — wrong types (non-string question value)', (t) => {
   const tmp = makeTempDir('answers-bad-q');
   try {
     const filePath = join(tmp, 'answers.json');
@@ -73,7 +73,7 @@ test('loadAndValidateAnswerFile — wrong types (non-string question value)', ()
   }
 });
 
-test('loadAndValidateAnswerFile — wrong types (non-string secret value)', () => {
+test('loadAndValidateAnswerFile — wrong types (non-string secret value)', (t) => {
   const tmp = makeTempDir('answers-bad-secret');
   try {
     const filePath = join(tmp, 'answers.json');
@@ -116,7 +116,7 @@ function makeSelectEvent(
   };
 }
 
-test('observeEvent stores metadata', () => {
+test('observeEvent stores metadata', (t) => {
   const injector = new AnswerInjector({});
 
   injector.observeEvent(makeToolExecutionStart([{
@@ -140,7 +140,7 @@ test('observeEvent stores metadata', () => {
   assert.strictEqual(injector.getStats().questionsDefaulted, 1);
 });
 
-test('tryHandle matches by question ID — single select', () => {
+test('tryHandle matches by question ID — single select', (t) => {
   const injector = new AnswerInjector({ questions: { deploy_target: 'GCP' } });
 
   injector.observeEvent(makeToolExecutionStart([{
@@ -164,7 +164,7 @@ test('tryHandle matches by question ID — single select', () => {
   assert.strictEqual(injector.getStats().questionsAnswered, 1);
 });
 
-test('tryHandle unknown question deferred — first_option timeout', async () => {
+test('tryHandle unknown question deferred — first_option timeout', async (t) => {
   const injector = new AnswerInjector({ defaults: { strategy: 'first_option' } });
 
   const captured: string[] = [];
@@ -188,7 +188,7 @@ test('tryHandle unknown question deferred — first_option timeout', async () =>
   assert.strictEqual(injector.getStats().questionsDefaulted, 1);
 });
 
-test('tryHandle multi-select', () => {
+test('tryHandle multi-select', (t) => {
   const injector = new AnswerInjector({ questions: { features: ['auth', 'payments'] } });
 
   injector.observeEvent(makeToolExecutionStart([{
@@ -218,7 +218,7 @@ test('tryHandle multi-select', () => {
   assert.strictEqual(injector.getStats().questionsAnswered, 1);
 });
 
-test('tryHandle answer not in options — first_option strategy returns false', () => {
+test('tryHandle answer not in options — first_option strategy returns false', (t) => {
   const injector = new AnswerInjector({ questions: { deploy_target: 'Azure' } });
 
   injector.observeEvent(makeToolExecutionStart([{
@@ -240,7 +240,7 @@ test('tryHandle answer not in options — first_option strategy returns false',
   assert.strictEqual(injector.getStats().questionsAnswered, 0);
 });
 
-test('tryHandle deferred resolution — observeEvent after tryHandle', async () => {
+test('tryHandle deferred resolution — observeEvent after tryHandle', async (t) => {
   const injector = new AnswerInjector({ questions: { deploy_target: 'GCP' } });
 
   const captured: string[] = [];
@@ -272,7 +272,7 @@ test('tryHandle deferred resolution — observeEvent after tryHandle', async ()
 // AnswerInjector — getSecretEnvVars
 // ---------------------------------------------------------------------------
 
-test('getSecretEnvVars returns secrets map', () => {
+test('getSecretEnvVars returns secrets map', (t) => {
   const secrets = { API_KEY: 'sk-123', DB_URL: 'postgres://localhost/db' };
   const injector = new AnswerInjector({ secrets });
 
@@ -283,7 +283,7 @@ test('getSecretEnvVars returns secrets map', () => {
 // AnswerInjector — getUnusedWarnings
 // ---------------------------------------------------------------------------
 
-test('getUnusedWarnings reports unused question IDs and secret keys', () => {
+test('getUnusedWarnings reports unused question IDs and secret keys', (t) => {
   const injector = new AnswerInjector({
     questions: { q1: 'val1', q2: 'val2' },
     secrets: { KEY1: 'v1' },
@@ -314,7 +314,7 @@ test('getUnusedWarnings reports unused question IDs and secret keys', () => {
 // AnswerInjector — defaults.strategy cancel
 // ---------------------------------------------------------------------------
 
-test('defaults.strategy cancel — sends cancelled response', () => {
+test('defaults.strategy cancel — sends cancelled response', (t) => {
   const injector = new AnswerInjector({ defaults: { strategy: 'cancel' } });
 
   injector.observeEvent(makeToolExecutionStart([{