gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/symlink-numbered-variants.test.ts

@@ -23,15 +23,15 @@ import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { ensureGsdSymlink, externalGsdRoot } from "../repo-identity.ts";
-import { createTestContext } from "./test-helpers.ts";
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
 }
 
-async function main(): Promise<void> {
+describe('symlink-numbered-variants', async () => {
   const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-symlink-variants-")));
   const stateDir = realpathSync(mkdtempSync(join(tmpdir(), "gsd-state-variants-")));
 
@@ -58,14 +58,14 @@ async function main(): Promise<void> {
       mkdirSync(join(base, ".gsd 4"), { recursive: true });
 
       const result = ensureGsdSymlink(base);
-      assertEq(result, externalPath, "ensureGsdSymlink returns external path");
-      assertTrue(existsSync(join(base, ".gsd")), ".gsd exists after ensureGsdSymlink");
-      assertTrue(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
+      assert.deepStrictEqual(result, externalPath, "ensureGsdSymlink returns external path");
+      assert.ok(existsSync(join(base, ".gsd")), ".gsd exists after ensureGsdSymlink");
+      assert.ok(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
 
       // The numbered variants must have been removed
-      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" directory was cleaned up');
-      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" directory was cleaned up');
-      assertTrue(!existsSync(join(base, ".gsd 4")), '".gsd 4" directory was cleaned up');
+      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" directory was cleaned up');
+      assert.ok(!existsSync(join(base, ".gsd 3")), '".gsd 3" directory was cleaned up');
+      assert.ok(!existsSync(join(base, ".gsd 4")), '".gsd 4" directory was cleaned up');
     }
 
     // ── Test: numbered variant symlinks are cleaned up ─────────────────
@@ -82,12 +82,12 @@ async function main(): Promise<void> {
       symlinkSync(staleTarget, join(base, ".gsd 3"), "junction");
 
       const result = ensureGsdSymlink(base);
-      assertEq(result, externalPath, "ensureGsdSymlink returns external path when variants exist");
-      assertTrue(existsSync(join(base, ".gsd")), ".gsd exists");
-      assertTrue(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
+      assert.deepStrictEqual(result, externalPath, "ensureGsdSymlink returns external path when variants exist");
+      assert.ok(existsSync(join(base, ".gsd")), ".gsd exists");
+      assert.ok(lstatSync(join(base, ".gsd")).isSymbolicLink(), ".gsd is a symlink");
 
-      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" symlink variant was cleaned up');
-      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" symlink variant was cleaned up');
+      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" symlink variant was cleaned up');
+      assert.ok(!existsSync(join(base, ".gsd 3")), '".gsd 3" symlink variant was cleaned up');
     }
 
     // ── Test: real .gsd directory blocks symlink, but variants still cleaned ──
@@ -104,12 +104,12 @@ async function main(): Promise<void> {
 
       const result = ensureGsdSymlink(base);
       // When .gsd is a real directory, ensureGsdSymlink preserves it
-      assertEq(result, join(base, ".gsd"), "real .gsd directory preserved");
-      assertTrue(lstatSync(join(base, ".gsd")).isDirectory(), ".gsd remains a directory");
+      assert.deepStrictEqual(result, join(base, ".gsd"), "real .gsd directory preserved");
+      assert.ok(lstatSync(join(base, ".gsd")).isDirectory(), ".gsd remains a directory");
 
       // But the numbered variants should still be cleaned up
-      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" cleaned even when .gsd is a directory');
-      assertTrue(!existsSync(join(base, ".gsd 3")), '".gsd 3" cleaned even when .gsd is a directory');
+      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" cleaned even when .gsd is a directory');
+      assert.ok(!existsSync(join(base, ".gsd 3")), '".gsd 3" cleaned even when .gsd is a directory');
     }
 
     // ── Test: only numeric-suffixed variants are removed ───────────────
@@ -127,10 +127,10 @@ async function main(): Promise<void> {
 
       ensureGsdSymlink(base);
 
-      assertTrue(existsSync(join(base, ".gsd-backup")), ".gsd-backup is NOT removed");
-      assertTrue(existsSync(join(base, ".gsd_old")), ".gsd_old is NOT removed");
-      assertTrue(!existsSync(join(base, ".gsd 2")), '".gsd 2" removed');
-      assertTrue(!existsSync(join(base, ".gsd 10")), '".gsd 10" removed');
+      assert.ok(existsSync(join(base, ".gsd-backup")), ".gsd-backup is NOT removed");
+      assert.ok(existsSync(join(base, ".gsd_old")), ".gsd_old is NOT removed");
+      assert.ok(!existsSync(join(base, ".gsd 2")), '".gsd 2" removed');
+      assert.ok(!existsSync(join(base, ".gsd 10")), '".gsd 10" removed');
 
       // Cleanup non-variant dirs
       rmSync(join(base, ".gsd-backup"), { recursive: true, force: true });
@@ -141,11 +141,5 @@ async function main(): Promise<void> {
     delete process.env.GSD_STATE_DIR;
     try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
     try { rmSync(stateDir, { recursive: true, force: true }); } catch { /* ignore */ }
-    report();
   }
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
 });

package/src/resources/extensions/gsd/tests/token-cost-display.test.ts

@@ -0,0 +1,118 @@
+/**
+ * Tests for the show_token_cost preference (#1515).
+ *
+ * Covers:
+ *   - Preference recognition and validation
+ *   - Cost formatting accuracy (inline re-implementation for test isolation)
+ *   - Disabled-by-default behavior
+ *   - Preference parsing from markdown frontmatter
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  validatePreferences,
+  parsePreferencesMarkdown,
+} from "../preferences.ts";
+import { KNOWN_PREFERENCE_KEYS } from "../preferences-types.ts";
+
+// Re-implement formatPromptCost here for test isolation (avoids pi-coding-agent build dep).
+// The canonical implementation lives in footer.ts.
+function formatPromptCost(cost: number): string {
+  if (cost < 0.001) return `$${cost.toFixed(4)}`;
+  if (cost < 0.01) return `$${cost.toFixed(3)}`;
+  if (cost < 1) return `$${cost.toFixed(3)}`;
+  return `$${cost.toFixed(2)}`;
+}
+
+// ── Preference recognition ──────────────────────────────────────────────────
+
+test("show_token_cost is a known preference key", () => {
+  assert.ok(KNOWN_PREFERENCE_KEYS.has("show_token_cost"));
+});
+
+test("show_token_cost: true validates without errors", () => {
+  const { errors, preferences } = validatePreferences({ show_token_cost: true });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.show_token_cost, true);
+});
+
+test("show_token_cost: false validates without errors", () => {
+  const { errors, preferences } = validatePreferences({ show_token_cost: false });
+  assert.equal(errors.length, 0);
+  assert.equal(preferences.show_token_cost, false);
+});
+
+test("show_token_cost: non-boolean produces validation error", () => {
+  const { errors } = validatePreferences({ show_token_cost: "yes" as any });
+  assert.ok(errors.length > 0);
+  assert.ok(errors[0].includes("show_token_cost"));
+  assert.ok(errors[0].includes("boolean"));
+});
+
+test("show_token_cost does not produce unknown-key warning", () => {
+  const { warnings } = validatePreferences({ show_token_cost: true });
+  const unknownWarnings = warnings.filter(w => w.includes("show_token_cost"));
+  assert.equal(unknownWarnings.length, 0);
+});
+
+// ── Disabled by default ─────────────────────────────────────────────────────
+
+test("show_token_cost defaults to undefined (disabled) when not set", () => {
+  const { preferences } = validatePreferences({});
+  assert.equal(preferences.show_token_cost, undefined);
+});
+
+test("empty preferences.md does not enable show_token_cost", () => {
+  const prefs = parsePreferencesMarkdown("---\nversion: 1\n---\n");
+  assert.ok(prefs);
+  assert.equal(prefs.show_token_cost, undefined);
+});
+
+test("preferences.md with show_token_cost: true enables the preference", () => {
+  const prefs = parsePreferencesMarkdown("---\nshow_token_cost: true\n---\n");
+  assert.ok(prefs);
+  assert.equal(prefs.show_token_cost, true);
+});
+
+// ── Cost formatting ─────────────────────────────────────────────────────────
+
+test("formatPromptCost formats sub-cent amounts with 4 decimals", () => {
+  assert.equal(formatPromptCost(0.0003), "$0.0003");
+  assert.equal(formatPromptCost(0.0009), "$0.0009");
+});
+
+test("formatPromptCost formats cent-range amounts with 3 decimals", () => {
+  assert.equal(formatPromptCost(0.003), "$0.003");
+  assert.equal(formatPromptCost(0.012), "$0.012");
+  assert.equal(formatPromptCost(0.1), "$0.100");
+});
+
+test("formatPromptCost formats dollar-range amounts with 2 decimals", () => {
+  assert.equal(formatPromptCost(1.5), "$1.50");
+  assert.equal(formatPromptCost(12.345), "$12.35");
+});
+
+test("formatPromptCost handles zero", () => {
+  assert.equal(formatPromptCost(0), "$0.0000");
+});
+
+// ── Cost calculation correctness ────────────────────────────────────────────
+
+test("cost calculation formula matches Model cost structure", () => {
+  // Simulates: usage.input * model.cost.input / 1_000_000 + usage.output * model.cost.output / 1_000_000
+  // Model.cost fields are $/million tokens
+  const modelCost = { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 }; // claude-opus-4 pricing
+  const usage = { input: 2000, output: 500, cacheRead: 10000, cacheWrite: 1000 };
+
+  const cost =
+    (usage.input * modelCost.input / 1_000_000) +
+    (usage.output * modelCost.output / 1_000_000) +
+    (usage.cacheRead * modelCost.cacheRead / 1_000_000) +
+    (usage.cacheWrite * modelCost.cacheWrite / 1_000_000);
+
+  // 2000*15/1M + 500*75/1M + 10000*1.5/1M + 1000*18.75/1M
+  // = 0.03 + 0.0375 + 0.015 + 0.01875 = 0.10125
+  assert.ok(Math.abs(cost - 0.10125) < 0.0001, `Expected ~$0.10125 but got $${cost}`);
+  assert.equal(formatPromptCost(cost), "$0.101");
+});

package/src/resources/extensions/gsd/tests/token-savings.test.ts

@@ -18,9 +18,9 @@ import {
   formatDecisionsForPrompt,
   formatRequirementsForPrompt,
 } from '../context-store.ts';
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
 
 // ─── Fixture Generators ────────────────────────────────────────────────────
 
@@ -154,8 +154,8 @@ console.log('\n=== token-savings: plan-slice prompt ≥30% character savings ===
   openDatabase(':memory:');
   const result = migrateFromMarkdown(base);
 
-  assertTrue(result.decisions === DECISIONS_COUNT, `imported ${result.decisions} decisions, expected ${DECISIONS_COUNT}`);
-  assertTrue(result.requirements === REQUIREMENTS_COUNT, `imported ${result.requirements} requirements, expected ${REQUIREMENTS_COUNT}`);
+  assert.ok(result.decisions === DECISIONS_COUNT, `imported ${result.decisions} decisions, expected ${DECISIONS_COUNT}`);
+  assert.ok(result.requirements === REQUIREMENTS_COUNT, `imported ${result.requirements} requirements, expected ${REQUIREMENTS_COUNT}`);
 
   // ── DB-scoped content for plan-slice (M001 decisions + S01 requirements) ──
   const scopedDecisions = queryDecisions({ milestoneId: 'M001' });
@@ -174,31 +174,31 @@ console.log('\n=== token-savings: plan-slice prompt ≥30% character savings ===
   const savingsPercent = ((fullTotal - dbTotal) / fullTotal) * 100;
   console.log(`  Plan-slice savings: ${savingsPercent.toFixed(1)}% (DB: ${dbTotal} chars, full: ${fullTotal} chars)`);
 
-  assertTrue(dbTotal > 0, 'DB-scoped content is non-empty');
-  assertTrue(dbDecisionsContent.length > 0, 'DB-scoped decisions content is non-empty');
-  assertTrue(dbRequirementsContent.length > 0, 'DB-scoped requirements content is non-empty');
-  assertTrue(savingsPercent >= 30, `plan-slice savings ≥30% (actual: ${savingsPercent.toFixed(1)}%)`);
-  assertTrue(dbTotal < fullTotal * 0.70, `DB total (${dbTotal}) < 70% of full total (${fullTotal})`);
+  assert.ok(dbTotal > 0, 'DB-scoped content is non-empty');
+  assert.ok(dbDecisionsContent.length > 0, 'DB-scoped decisions content is non-empty');
+  assert.ok(dbRequirementsContent.length > 0, 'DB-scoped requirements content is non-empty');
+  assert.ok(savingsPercent >= 30, `plan-slice savings ≥30% (actual: ${savingsPercent.toFixed(1)}%)`);
+  assert.ok(dbTotal < fullTotal * 0.70, `DB total (${dbTotal}) < 70% of full total (${fullTotal})`);
 
   // ── Verify correct scoping: decisions ──
   // M001 decisions: those with when_context containing 'M001' — indices 1,4,7,10,13,16,19,22
   // (24 decisions round-robin across M001/M002/M003 → 8 for M001)
-  assertTrue(scopedDecisions.length === 8, `M001 decisions: expected 8, got ${scopedDecisions.length}`);
+  assert.ok(scopedDecisions.length === 8, `M001 decisions: expected 8, got ${scopedDecisions.length}`);
   for (const d of scopedDecisions) {
-    assertTrue(d.when_context.includes('M001'), `decision ${d.id} should have M001 in when_context, got "${d.when_context}"`);
+    assert.ok(d.when_context.includes('M001'), `decision ${d.id} should have M001 in when_context, got "${d.when_context}"`);
   }
 
   // Verify NO decisions from other milestones leak in
   for (const d of scopedDecisions) {
-    assertNoMatch(d.when_context, /M002|M003/, `decision ${d.id} should not contain M002 or M003`);
+    assert.doesNotMatch(d.when_context, /M002|M003/, `decision ${d.id} should not contain M002 or M003`);
   }
 
   // ── Verify correct scoping: requirements ──
   // S01 requirements: those assigned to S01 as primary_owner
   // S01 appears in positions 1,6,11,16,21 (5 assignments cycling, 21 reqs → indices 0,5,10,15,20)
-  assertTrue(scopedRequirements.length > 0, 'S01 requirements non-empty');
+  assert.ok(scopedRequirements.length > 0, 'S01 requirements non-empty');
   for (const r of scopedRequirements) {
-    assertTrue(
+    assert.ok(
       r.primary_owner.includes('S01') || r.supporting_slices.includes('S01'),
       `requirement ${r.id} should be owned by or support S01`,
     );
@@ -206,13 +206,13 @@ console.log('\n=== token-savings: plan-slice prompt ≥30% character savings ===
 
   // Verify specific expected IDs are present
   const scopedDecisionIds = scopedDecisions.map(d => d.id);
-  assertTrue(scopedDecisionIds.includes('D001'), 'M001 scoped decisions includes D001');
-  assertTrue(scopedDecisionIds.includes('D004'), 'M001 scoped decisions includes D004');
-  assertTrue(!scopedDecisionIds.includes('D002'), 'M001 scoped decisions excludes D002 (M002)');
-  assertTrue(!scopedDecisionIds.includes('D003'), 'M001 scoped decisions excludes D003 (M003)');
+  assert.ok(scopedDecisionIds.includes('D001'), 'M001 scoped decisions includes D001');
+  assert.ok(scopedDecisionIds.includes('D004'), 'M001 scoped decisions includes D004');
+  assert.ok(!scopedDecisionIds.includes('D002'), 'M001 scoped decisions excludes D002 (M002)');
+  assert.ok(!scopedDecisionIds.includes('D003'), 'M001 scoped decisions excludes D003 (M003)');
 
   const scopedReqIds = scopedRequirements.map(r => r.id);
-  assertTrue(scopedReqIds.includes('R001'), 'S01 scoped requirements includes R001');
+  assert.ok(scopedReqIds.includes('R001'), 'S01 scoped requirements includes R001');
 
   closeDatabase();
   rmSync(base, { recursive: true, force: true });
@@ -246,9 +246,9 @@ console.log('\n=== token-savings: research-milestone prompt shows meaningful sav
   const decisionsSavings = ((fullDecisionsContent.length - dbDecisionsContent.length) / fullDecisionsContent.length) * 100;
   console.log(`  Decisions savings (M001): ${decisionsSavings.toFixed(1)}% (DB: ${dbDecisionsContent.length}, full: ${fullDecisionsContent.length})`);
 
-  assertTrue(decisionsSavings > 0, `decisions savings > 0% (actual: ${decisionsSavings.toFixed(1)}%)`);
-  assertTrue(scopedDecisions.length === 8, `M001 decisions: 8 of 24 total`);
-  assertTrue(allRequirements.length === REQUIREMENTS_COUNT, `all requirements returned: ${allRequirements.length}`);
+  assert.ok(decisionsSavings > 0, `decisions savings > 0% (actual: ${decisionsSavings.toFixed(1)}%)`);
+  assert.ok(scopedDecisions.length === 8, `M001 decisions: 8 of 24 total`);
+  assert.ok(allRequirements.length === REQUIREMENTS_COUNT, `all requirements returned: ${allRequirements.length}`);
 
   // Requirements: DB-formatted vs raw markdown — formatted output may differ in size
   // but decisions savings alone should make the composite meaningful
@@ -259,8 +259,8 @@ console.log('\n=== token-savings: research-milestone prompt shows meaningful sav
 
   // With 8/24 decisions = 66% reduction in decisions, even if requirements are equal,
   // the composite should show meaningful savings
-  assertTrue(compositeSavings > 10, `research-milestone shows >10% composite savings (actual: ${compositeSavings.toFixed(1)}%)`);
-  assertTrue(decisionsSavings >= 30, `decisions-only savings ≥30% for M001 scope (actual: ${decisionsSavings.toFixed(1)}%)`);
+  assert.ok(compositeSavings > 10, `research-milestone shows >10% composite savings (actual: ${compositeSavings.toFixed(1)}%)`);
+  assert.ok(decisionsSavings >= 30, `decisions-only savings ≥30% for M001 scope (actual: ${decisionsSavings.toFixed(1)}%)`);
 
   closeDatabase();
   rmSync(base, { recursive: true, force: true });
@@ -283,17 +283,17 @@ console.log('\n=== token-savings: quality — correct scoping, no cross-contamin
 
   // ── M002-scoped decisions should not contain M001/M003 items ──
   const m002Decisions = queryDecisions({ milestoneId: 'M002' });
-  assertTrue(m002Decisions.length === 8, `M002 decisions: expected 8, got ${m002Decisions.length}`);
+  assert.ok(m002Decisions.length === 8, `M002 decisions: expected 8, got ${m002Decisions.length}`);
   for (const d of m002Decisions) {
-    assertTrue(d.when_context.includes('M002'), `M002 decision ${d.id} has M002 in when_context`);
-    assertNoMatch(d.when_context, /M001|M003/, `M002 decision ${d.id} should not contain M001/M003`);
+    assert.ok(d.when_context.includes('M002'), `M002 decision ${d.id} has M002 in when_context`);
+    assert.doesNotMatch(d.when_context, /M001|M003/, `M002 decision ${d.id} should not contain M001/M003`);
   }
 
   // ── S04-scoped requirements should only include S04-related items ──
   const s04Requirements = queryRequirements({ sliceId: 'S04' });
-  assertTrue(s04Requirements.length > 0, 'S04 requirements non-empty');
+  assert.ok(s04Requirements.length > 0, 'S04 requirements non-empty');
   for (const r of s04Requirements) {
-    assertTrue(
+    assert.ok(
       r.primary_owner.includes('S04') || r.supporting_slices.includes('S04'),
       `S04 requirement ${r.id} should be owned by or support S04`,
     );
@@ -301,13 +301,13 @@ console.log('\n=== token-savings: quality — correct scoping, no cross-contamin
 
   // ── Verify formatted output is well-formed and non-empty ──
   const formattedDecisions = formatDecisionsForPrompt(m002Decisions);
-  assertTrue(formattedDecisions.length > 0, 'formatted M002 decisions is non-empty');
-  assertMatch(formattedDecisions, /\| D/, 'formatted decisions contains decision rows');
-  assertMatch(formattedDecisions, /\| # \|/, 'formatted decisions has table header');
+  assert.ok(formattedDecisions.length > 0, 'formatted M002 decisions is non-empty');
+  assert.match(formattedDecisions, /\| D/, 'formatted decisions contains decision rows');
+  assert.match(formattedDecisions, /\| # \|/, 'formatted decisions has table header');
 
   const formattedReqs = formatRequirementsForPrompt(s04Requirements);
-  assertTrue(formattedReqs.length > 0, 'formatted S04 requirements is non-empty');
-  assertMatch(formattedReqs, /### R\d+/, 'formatted requirements has requirement headings');
+  assert.ok(formattedReqs.length > 0, 'formatted S04 requirements is non-empty');
+  assert.match(formattedReqs, /### R\d+/, 'formatted requirements has requirement headings');
 
   // ── Verify all milestones have decisions and counts add up ──
   const m001Count = queryDecisions({ milestoneId: 'M001' }).length;
@@ -315,11 +315,11 @@ console.log('\n=== token-savings: quality — correct scoping, no cross-contamin
   const m003Count = queryDecisions({ milestoneId: 'M003' }).length;
   const allCount = queryDecisions().length;
 
-  assertTrue(m001Count === 8, `M001: 8 decisions (got ${m001Count})`);
-  assertTrue(m002Count === 8, `M002: 8 decisions (got ${m002Count})`);
-  assertTrue(m003Count === 8, `M003: 8 decisions (got ${m003Count})`);
-  assertTrue(allCount === DECISIONS_COUNT, `all: ${DECISIONS_COUNT} decisions (got ${allCount})`);
-  assertTrue(m001Count + m002Count + m003Count === allCount, 'milestone decision counts sum to total');
+  assert.ok(m001Count === 8, `M001: 8 decisions (got ${m001Count})`);
+  assert.ok(m002Count === 8, `M002: 8 decisions (got ${m002Count})`);
+  assert.ok(m003Count === 8, `M003: 8 decisions (got ${m003Count})`);
+  assert.ok(allCount === DECISIONS_COUNT, `all: ${DECISIONS_COUNT} decisions (got ${allCount})`);
+  assert.ok(m001Count + m002Count + m003Count === allCount, 'milestone decision counts sum to total');
 
   // ── Verify all slices have requirements ──
   const s01Reqs = queryRequirements({ sliceId: 'S01' });
@@ -328,11 +328,11 @@ console.log('\n=== token-savings: quality — correct scoping, no cross-contamin
   const s04Reqs = queryRequirements({ sliceId: 'S04' });
   const s05Reqs = queryRequirements({ sliceId: 'S05' });
 
-  assertTrue(s01Reqs.length > 0, 'S01 has requirements');
-  assertTrue(s02Reqs.length > 0, 'S02 has requirements');
-  assertTrue(s03Reqs.length > 0, 'S03 has requirements');
-  assertTrue(s04Reqs.length > 0, 'S04 has requirements');
-  assertTrue(s05Reqs.length > 0, 'S05 has requirements');
+  assert.ok(s01Reqs.length > 0, 'S01 has requirements');
+  assert.ok(s02Reqs.length > 0, 'S02 has requirements');
+  assert.ok(s03Reqs.length > 0, 'S03 has requirements');
+  assert.ok(s04Reqs.length > 0, 'S04 has requirements');
+  assert.ok(s05Reqs.length > 0, 'S05 has requirements');
 
   closeDatabase();
   rmSync(base, { recursive: true, force: true });
@@ -345,22 +345,20 @@ console.log('\n=== token-savings: quality — correct scoping, no cross-contamin
 console.log('\n=== token-savings: fixture data realism ===');
 {
   // Verify fixture generators produce sufficient volume
-  assertTrue(DECISIONS_COUNT >= 20, `decisions count ≥ 20 (actual: ${DECISIONS_COUNT})`);
-  assertTrue(REQUIREMENTS_COUNT >= 20, `requirements count ≥ 20 (actual: ${REQUIREMENTS_COUNT})`);
-  assertTrue(MILESTONES.length >= 3, `milestones ≥ 3 (actual: ${MILESTONES.length})`);
-  assertTrue(SLICE_ASSIGNMENTS.length >= 5, `slice assignments ≥ 5 (actual: ${SLICE_ASSIGNMENTS.length})`);
+  assert.ok(DECISIONS_COUNT >= 20, `decisions count ≥ 20 (actual: ${DECISIONS_COUNT})`);
+  assert.ok(REQUIREMENTS_COUNT >= 20, `requirements count ≥ 20 (actual: ${REQUIREMENTS_COUNT})`);
+  assert.ok(MILESTONES.length >= 3, `milestones ≥ 3 (actual: ${MILESTONES.length})`);
+  assert.ok(SLICE_ASSIGNMENTS.length >= 5, `slice assignments ≥ 5 (actual: ${SLICE_ASSIGNMENTS.length})`);
 
   // Verify markdown content is substantial
-  assertTrue(decisionsMarkdown.length > 1000, `decisions markdown > 1000 chars (actual: ${decisionsMarkdown.length})`);
-  assertTrue(requirementsMarkdown.length > 1000, `requirements markdown > 1000 chars (actual: ${requirementsMarkdown.length})`);
+  assert.ok(decisionsMarkdown.length > 1000, `decisions markdown > 1000 chars (actual: ${decisionsMarkdown.length})`);
+  assert.ok(requirementsMarkdown.length > 1000, `requirements markdown > 1000 chars (actual: ${requirementsMarkdown.length})`);
 
   // Verify content structure
-  assertMatch(decisionsMarkdown, /\| D001 \|/, 'decisions markdown has D001');
-  assertMatch(decisionsMarkdown, /\| D024 \|/, 'decisions markdown has D024');
-  assertMatch(requirementsMarkdown, /### R001/, 'requirements markdown has R001');
-  assertMatch(requirementsMarkdown, /### R021/, 'requirements markdown has R021');
+  assert.match(decisionsMarkdown, /\| D001 \|/, 'decisions markdown has D001');
+  assert.match(decisionsMarkdown, /\| D024 \|/, 'decisions markdown has D024');
+  assert.match(requirementsMarkdown, /### R001/, 'requirements markdown has R001');
+  assert.match(requirementsMarkdown, /### R021/, 'requirements markdown has R021');
 }
 
 // ─── Report ────────────────────────────────────────────────────────────────
-
-report();

package/src/resources/extensions/gsd/tests/tool-call-loop-guard.test.ts

@@ -3,7 +3,8 @@
 // Verifies that identical consecutive tool calls are detected and blocked
 // after exceeding the threshold, and that the guard resets properly.
 
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 import {
   checkToolCallLoop,
   resetToolCallLoopGuard,
@@ -11,7 +12,6 @@ import {
   getToolCallLoopCount,
 } from '../bootstrap/tool-call-loop-guard.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Allows first N calls, blocks after threshold
@@ -25,15 +25,15 @@ console.log('\n── Loop guard: blocks after threshold ──');
   // First 4 identical calls should be allowed (threshold is 4)
   for (let i = 1; i <= 4; i++) {
     const result = checkToolCallLoop('web_search', { query: 'same query' });
-    assertTrue(result.block === false, `Call ${i} should be allowed`);
-    assertEq(result.count, i, `Count should be ${i} after call ${i}`);
+    assert.ok(result.block === false, `Call ${i} should be allowed`);
+    assert.deepStrictEqual(result.count, i, `Count should be ${i} after call ${i}`);
   }
 
   // 5th identical call should be blocked
   const blocked = checkToolCallLoop('web_search', { query: 'same query' });
-  assertTrue(blocked.block === true, '5th identical call should be blocked');
-  assertTrue(blocked.reason!.includes('web_search'), 'Reason should mention tool name');
-  assertTrue(blocked.reason!.includes('5'), 'Reason should mention count');
+  assert.ok(blocked.block === true, '5th identical call should be blocked');
+  assert.ok(blocked.reason!.includes('web_search'), 'Reason should mention tool name');
+  assert.ok(blocked.reason!.includes('5'), 'Reason should mention count');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -48,17 +48,17 @@ console.log('\n── Loop guard: different calls reset streak ──');
   checkToolCallLoop('web_search', { query: 'query A' });
   checkToolCallLoop('web_search', { query: 'query A' });
   checkToolCallLoop('web_search', { query: 'query A' });
-  assertEq(getToolCallLoopCount(), 3, 'Count should be 3 after 3 identical calls');
+  assert.deepStrictEqual(getToolCallLoopCount(), 3, 'Count should be 3 after 3 identical calls');
 
   // A different call resets the streak
   const different = checkToolCallLoop('bash', { command: 'ls' });
-  assertTrue(different.block === false, 'Different tool call should be allowed');
-  assertEq(getToolCallLoopCount(), 1, 'Count should reset to 1 after different call');
+  assert.ok(different.block === false, 'Different tool call should be allowed');
+  assert.deepStrictEqual(getToolCallLoopCount(), 1, 'Count should reset to 1 after different call');
 
   // Same tool but different args also resets
   checkToolCallLoop('web_search', { query: 'query A' });
   checkToolCallLoop('web_search', { query: 'query B' }); // different args
-  assertEq(getToolCallLoopCount(), 1, 'Different args should reset count');
+  assert.deepStrictEqual(getToolCallLoopCount(), 1, 'Different args should reset count');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -72,15 +72,15 @@ console.log('\n── Loop guard: reset clears state ──');
   checkToolCallLoop('web_search', { query: 'q' });
   checkToolCallLoop('web_search', { query: 'q' });
   checkToolCallLoop('web_search', { query: 'q' });
-  assertEq(getToolCallLoopCount(), 3, 'Count should be 3 before reset');
+  assert.deepStrictEqual(getToolCallLoopCount(), 3, 'Count should be 3 before reset');
 
   resetToolCallLoopGuard();
-  assertEq(getToolCallLoopCount(), 0, 'Count should be 0 after reset');
+  assert.deepStrictEqual(getToolCallLoopCount(), 0, 'Count should be 0 after reset');
 
   // After reset, the same call starts fresh
   const result = checkToolCallLoop('web_search', { query: 'q' });
-  assertTrue(result.block === false, 'Call after reset should be allowed');
-  assertEq(getToolCallLoopCount(), 1, 'Count should be 1 after first call post-reset');
+  assert.ok(result.block === false, 'Call after reset should be allowed');
+  assert.deepStrictEqual(getToolCallLoopCount(), 1, 'Count should be 1 after first call post-reset');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -94,13 +94,13 @@ console.log('\n── Loop guard: disable allows everything ──');
 
   for (let i = 0; i < 10; i++) {
     const result = checkToolCallLoop('web_search', { query: 'same' });
-    assertTrue(result.block === false, `Call ${i + 1} should be allowed when disabled`);
+    assert.ok(result.block === false, `Call ${i + 1} should be allowed when disabled`);
   }
 
   // Re-enable via reset
   resetToolCallLoopGuard();
   checkToolCallLoop('web_search', { query: 'q' });
-  assertEq(getToolCallLoopCount(), 1, 'Guard should be active again after reset');
+  assert.deepStrictEqual(getToolCallLoopCount(), 1, 'Guard should be active again after reset');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -114,8 +114,8 @@ console.log('\n── Loop guard: arg order is normalized ──');
 
   checkToolCallLoop('web_search', { query: 'test', limit: 5 });
   const result = checkToolCallLoop('web_search', { limit: 5, query: 'test' }); // same args, different order
-  assertTrue(result.block === false, 'Same args in different order should count as consecutive');
-  assertEq(getToolCallLoopCount(), 2, 'Should detect as same call regardless of key order');
+  assert.ok(result.block === false, 'Same args in different order should count as consecutive');
+  assert.deepStrictEqual(getToolCallLoopCount(), 2, 'Should detect as same call regardless of key order');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -132,8 +132,8 @@ console.log('\n── Loop guard: nested args are not stripped ──');
     const result = checkToolCallLoop('ask_user_questions', {
       questions: [{ id: `q${i}`, question: `Question ${i}?` }],
     });
-    assertTrue(result.block === false, `Nested call ${i} with unique content should be allowed`);
-    assertEq(getToolCallLoopCount(), 1, `Each unique nested call should reset count to 1`);
+    assert.ok(result.block === false, `Nested call ${i} with unique content should be allowed`);
+    assert.deepStrictEqual(getToolCallLoopCount(), 1, `Each unique nested call should reset count to 1`);
   }
 
   // Truly identical nested calls should still be detected
@@ -146,7 +146,7 @@ console.log('\n── Loop guard: nested args are not stripped ──');
   const blocked = checkToolCallLoop('ask_user_questions', {
     questions: [{ id: 'same', question: 'Same?' }],
   });
-  assertTrue(blocked.block === true, 'Identical nested calls should still be blocked');
+  assert.ok(blocked.block === true, 'Identical nested calls should still be blocked');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -160,9 +160,7 @@ console.log('\n── Loop guard: nested key order is normalized ──');
 
   checkToolCallLoop('tool', { outer: { b: 2, a: 1 } });
   const result = checkToolCallLoop('tool', { outer: { a: 1, b: 2 } });
-  assertEq(getToolCallLoopCount(), 2, 'Same nested args in different key order should match');
+  assert.deepStrictEqual(getToolCallLoopCount(), 2, 'Same nested args in different key order should match');
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-
-report();