gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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

@@ -1,10 +1,9 @@
-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';
@@ -26,6 +25,8 @@ import {
 } from '../db-writer.ts';
 import type { Requirement } from '../types.ts';
 
+const { assertEq, assertTrue, assertMatch, report } = createTestContext();
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
 // ═══════════════════════════════════════════════════════════════════════════
@@ -45,249 +46,281 @@ 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.
  */
 
-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_decision_save 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_decision_save ──');
 
-      closeDatabase();
-    } finally {
-      cleanupDir(tmpDir);
-    }
-  });
+{
+  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);
+  }
+}
 
-  test('gsd_requirement_update', async () => {
-    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,
-      );
+// ═══════════════════════════════════════════════════════════════════════════
+// gsd_requirement_update tool tests
+// ═══════════════════════════════════════════════════════════════════════════
 
-      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);
-    }
-  });
+console.log('\n── gsd_requirement_update ──');
 
-  test('gsd_summary_save', async () => {
-    const tmpDir = makeTmpDir();
+{
+  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 {
-      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,
+      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');
 
-      // 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,
-      );
+    closeDatabase();
+  } finally {
+    cleanupDir(tmpDir);
+  }
+}
 
-      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,
-      );
+// ═══════════════════════════════════════════════════════════════════════════
+// gsd_summary_save tool tests
+// ═══════════════════════════════════════════════════════════════════════════
 
-      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');
+console.log('\n── gsd_summary_save ──');
 
-      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('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 */ }
+// ═══════════════════════════════════════════════════════════════════════════
+// DB unavailable error paths
+// ═══════════════════════════════════════════════════════════════════════════
 
-    // isDbAvailable() should return false
-    assert.ok(!isDbAvailable(), 'DB should be unavailable after close');
+console.log('\n── DB unavailable error paths ──');
 
-    // nextDecisionId degrades gracefully
-    const fallbackId = await nextDecisionId();
-    assert.deepStrictEqual(fallbackId, 'D001', 'nextDecisionId should return D001 when DB unavailable');
-  });
+{
+  // (d) All tools return isError when DB unavailable
+  // Close any open DB and don't open a new one
+  try { closeDatabase(); } catch { /* already closed */ }
 
-  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,
-      );
+  // 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');
+}
 
-      // 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');
+// ═══════════════════════════════════════════════════════════════════════════
+// Tool result format verification
+// ═══════════════════════════════════════════════════════════════════════════
 
-      closeDatabase();
-    } finally {
-      cleanupDir(tmpDir);
-    }
-  });
-});
+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/src/resources/extensions/gsd/tests/headless-answers.test.ts

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