gsd-pi 2.44.0-dev.62b5d6c → 2.44.0-dev.73f2fd5

package/src/resources/extensions/gsd/tests/terminated-transient.test.ts

@@ -0,0 +1,49 @@
+/**
+ * terminated-transient.test.ts — Regression test for #2309.
+ *
+ * classifyProviderError should treat 'terminated' errors (process killed,
+ * connection reset) as transient with auto-resume, not permanent.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { classifyProviderError } from "../provider-error-pause.ts";
+
+test("#2309: 'terminated' errors should be classified as transient", () => {
+  const result = classifyProviderError("terminated");
+  assert.equal(result.isTransient, true, "'terminated' should be transient");
+  assert.equal(result.isRateLimit, false, "'terminated' is not a rate limit");
+  assert.ok(result.suggestedDelayMs > 0, "'terminated' should have a retry delay");
+});
+
+test("#2309: 'connection reset' errors should be classified as transient", () => {
+  const result = classifyProviderError("connection reset by peer");
+  assert.equal(result.isTransient, true, "'connection reset' should be transient");
+});
+
+test("#2309: 'other side closed' errors should be classified as transient", () => {
+  const result = classifyProviderError("other side closed the connection");
+  assert.equal(result.isTransient, true, "'other side closed' should be transient");
+});
+
+test("#2309: 'fetch failed' errors should be classified as transient", () => {
+  const result = classifyProviderError("fetch failed: network error");
+  assert.equal(result.isTransient, true, "'fetch failed' should be transient");
+});
+
+test("#2309: 'connection refused' errors should be classified as transient", () => {
+  const result = classifyProviderError("ECONNREFUSED: connection refused");
+  assert.equal(result.isTransient, true, "'connection refused' should be transient");
+});
+
+test("#2309: permanent errors are still permanent", () => {
+  const authResult = classifyProviderError("unauthorized: invalid API key");
+  assert.equal(authResult.isTransient, false, "auth errors should stay permanent");
+  assert.equal(authResult.suggestedDelayMs, 0, "permanent errors have no delay");
+});
+
+test("#2309: rate limits are still transient", () => {
+  const rlResult = classifyProviderError("rate limit exceeded (429)");
+  assert.equal(rlResult.isTransient, true, "rate limits are still transient");
+  assert.equal(rlResult.isRateLimit, true, "rate limits are flagged as rate limits");
+});

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();

package/src/resources/extensions/gsd/tests/tool-naming.test.ts

@@ -4,10 +4,10 @@
 // AND under a backward-compatible alias name.
 // The alias must share the exact same execute function reference as the canonical tool.
 
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 import { registerDbTools } from '../bootstrap/db-tools.ts';
 
-const { assertEq, assertTrue, report } = createTestContext();
 
 // ─── Mock PI ──────────────────────────────────────────────────────────────────
 
@@ -34,6 +34,7 @@ const RENAME_MAP: Array<{ canonical: string; alias: string }> = [
   { canonical: "gsd_replan_slice", alias: "gsd_slice_replan" },
   { canonical: "gsd_reassess_roadmap", alias: "gsd_roadmap_reassess" },
   { canonical: "gsd_complete_milestone", alias: "gsd_milestone_complete" },
+  { canonical: "gsd_validate_milestone", alias: "gsd_milestone_validate" },
 ];
 
 // ─── Registration count ──────────────────────────────────────────────────────
@@ -43,7 +44,7 @@ console.log('\n── Tool naming: registration count ──');
 const pi = makeMockPi();
 registerDbTools(pi);
 
-assertEq(pi.tools.length, 24, 'Should register exactly 24 tools (12 canonical + 12 aliases)');
+assert.deepStrictEqual(pi.tools.length, 26, 'Should register exactly 26 tools (13 canonical + 13 aliases)');
 
 // ─── Both names exist for each pair ──────────────────────────────────────────
 
@@ -53,8 +54,8 @@ for (const { canonical, alias } of RENAME_MAP) {
   const canonicalTool = pi.tools.find((t: any) => t.name === canonical);
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
-  assertTrue(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
-  assertTrue(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
+  assert.ok(canonicalTool !== undefined, `Canonical tool "${canonical}" should be registered`);
+  assert.ok(aliasTool !== undefined, `Alias tool "${alias}" should be registered`);
 }
 
 // ─── Execute function identity ───────────────────────────────────────────────
@@ -66,7 +67,7 @@ for (const { canonical, alias } of RENAME_MAP) {
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
   if (canonicalTool && aliasTool) {
-    assertTrue(
+    assert.ok(
       canonicalTool.execute === aliasTool.execute,
       `"${canonical}" and "${alias}" should share the same execute function reference`,
     );
@@ -81,7 +82,7 @@ for (const { canonical, alias } of RENAME_MAP) {
   const aliasTool = pi.tools.find((t: any) => t.name === alias);
 
   if (aliasTool) {
-    assertTrue(
+    assert.ok(
       aliasTool.description.includes(`alias for ${canonical}`),
       `Alias "${alias}" description should include "alias for ${canonical}"`,
     );
@@ -97,7 +98,7 @@ for (const { canonical } of RENAME_MAP) {
 
   if (canonicalTool) {
     const guidelinesText = canonicalTool.promptGuidelines.join(' ');
-    assertTrue(
+    assert.ok(
       guidelinesText.includes(canonical),
       `Canonical tool "${canonical}" promptGuidelines should reference its own name`,
     );
@@ -113,7 +114,7 @@ for (const { canonical, alias } of RENAME_MAP) {
 
   if (aliasTool) {
     const guidelinesText = aliasTool.promptGuidelines.join(' ');
-    assertTrue(
+    assert.ok(
       guidelinesText.includes(`Alias for ${canonical}`),
       `Alias "${alias}" promptGuidelines should say "Alias for ${canonical}"`,
     );
@@ -121,5 +122,3 @@ for (const { canonical, alias } of RENAME_MAP) {
 }
 
 // ═══════════════════════════════════════════════════════════════════════════
-
-report();