gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/unique-milestone-ids.test.ts

@@ -22,72 +22,72 @@ import {
 
 import { renderPreferencesForSystemPrompt } from '../preferences.ts';
 import type { GSDPreferences } from '../preferences.ts';
-import { createTestContext } from './test-helpers.ts';
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 
 
-const { assertEq, assertTrue, assertMatch, report } = createTestContext();
 // ─── Tests ─────────────────────────────────────────────────────────────────
 
-async function main(): Promise<void> {
+describe('unique-milestone-ids', async () => {
   console.log('unique-milestone-ids tests');
 
   // (a) MILESTONE_ID_RE
   {
     console.log('  (a) MILESTONE_ID_RE');
     // Should match
-    assertTrue(MILESTONE_ID_RE.test('M001'), 'matches M001');
-    assertTrue(MILESTONE_ID_RE.test('M999'), 'matches M999');
-    assertTrue(MILESTONE_ID_RE.test('M001-abc123'), 'matches M001-abc123');
-    assertTrue(MILESTONE_ID_RE.test('M042-z9a8b7'), 'matches M042-z9a8b7');
+    assert.ok(MILESTONE_ID_RE.test('M001'), 'matches M001');
+    assert.ok(MILESTONE_ID_RE.test('M999'), 'matches M999');
+    assert.ok(MILESTONE_ID_RE.test('M001-abc123'), 'matches M001-abc123');
+    assert.ok(MILESTONE_ID_RE.test('M042-z9a8b7'), 'matches M042-z9a8b7');
 
     // Should reject
-    assertTrue(!MILESTONE_ID_RE.test('M1'), 'rejects M1 (too few digits)');
-    assertTrue(!MILESTONE_ID_RE.test('M0001'), 'rejects M0001 (too many digits)');
-    assertTrue(!MILESTONE_ID_RE.test('M001-ABCDEF'), 'rejects M001-ABCDEF (uppercase prefix)');
-    assertTrue(!MILESTONE_ID_RE.test('M001-short'), 'rejects M001-short (5-char prefix)');
-    assertTrue(!MILESTONE_ID_RE.test('M001-toolong1'), 'rejects M001-toolong1 (>6-char prefix)');
-    assertTrue(!MILESTONE_ID_RE.test('IM001'), 'rejects IM001 (prefix before M)');
-    assertTrue(!MILESTONE_ID_RE.test(''), 'rejects empty string');
-    assertTrue(!MILESTONE_ID_RE.test('M001extra'), 'rejects M001extra (trailing chars)');
-    assertTrue(!MILESTONE_ID_RE.test('notes'), 'rejects non-milestone string');
+    assert.ok(!MILESTONE_ID_RE.test('M1'), 'rejects M1 (too few digits)');
+    assert.ok(!MILESTONE_ID_RE.test('M0001'), 'rejects M0001 (too many digits)');
+    assert.ok(!MILESTONE_ID_RE.test('M001-ABCDEF'), 'rejects M001-ABCDEF (uppercase prefix)');
+    assert.ok(!MILESTONE_ID_RE.test('M001-short'), 'rejects M001-short (5-char prefix)');
+    assert.ok(!MILESTONE_ID_RE.test('M001-toolong1'), 'rejects M001-toolong1 (>6-char prefix)');
+    assert.ok(!MILESTONE_ID_RE.test('IM001'), 'rejects IM001 (prefix before M)');
+    assert.ok(!MILESTONE_ID_RE.test(''), 'rejects empty string');
+    assert.ok(!MILESTONE_ID_RE.test('M001extra'), 'rejects M001extra (trailing chars)');
+    assert.ok(!MILESTONE_ID_RE.test('notes'), 'rejects non-milestone string');
   }
 
   // (b) extractMilestoneSeq
   {
     console.log('  (b) extractMilestoneSeq');
     // Old format
-    assertEq(extractMilestoneSeq('M001'), 1, 'M001 → 1');
-    assertEq(extractMilestoneSeq('M042'), 42, 'M042 → 42');
-    assertEq(extractMilestoneSeq('M999'), 999, 'M999 → 999');
+    assert.deepStrictEqual(extractMilestoneSeq('M001'), 1, 'M001 → 1');
+    assert.deepStrictEqual(extractMilestoneSeq('M042'), 42, 'M042 → 42');
+    assert.deepStrictEqual(extractMilestoneSeq('M999'), 999, 'M999 → 999');
 
     // Unique format
-    assertEq(extractMilestoneSeq('M001-abc123'), 1, 'M001-abc123 → 1');
-    assertEq(extractMilestoneSeq('M042-z9a8b7'), 42, 'M042-z9a8b7 → 42');
+    assert.deepStrictEqual(extractMilestoneSeq('M001-abc123'), 1, 'M001-abc123 → 1');
+    assert.deepStrictEqual(extractMilestoneSeq('M042-z9a8b7'), 42, 'M042-z9a8b7 → 42');
 
     // Invalid → 0
-    assertEq(extractMilestoneSeq(''), 0, 'empty → 0');
-    assertEq(extractMilestoneSeq('notes'), 0, 'notes → 0');
-    assertEq(extractMilestoneSeq('M1'), 0, 'M1 → 0');
-    assertEq(extractMilestoneSeq('.DS_Store'), 0, '.DS_Store → 0');
-    assertEq(extractMilestoneSeq('M-ABC-001'), 0, 'M-ABC-001 (old format) → 0');
+    assert.deepStrictEqual(extractMilestoneSeq(''), 0, 'empty → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('notes'), 0, 'notes → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('M1'), 0, 'M1 → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('.DS_Store'), 0, '.DS_Store → 0');
+    assert.deepStrictEqual(extractMilestoneSeq('M-ABC-001'), 0, 'M-ABC-001 (old format) → 0');
   }
 
   // (c) parseMilestoneId
   {
     console.log('  (c) parseMilestoneId');
     // Old format — no suffix
-    assertEq(parseMilestoneId('M001'), { num: 1 }, 'M001 → { num: 1 }');
-    assertEq(parseMilestoneId('M042'), { num: 42 }, 'M042 → { num: 42 }');
+    assert.deepStrictEqual(parseMilestoneId('M001'), { num: 1 }, 'M001 → { num: 1 }');
+    assert.deepStrictEqual(parseMilestoneId('M042'), { num: 42 }, 'M042 → { num: 42 }');
 
     // Unique format — with suffix
-    assertEq(parseMilestoneId('M001-abc123'), { suffix: 'abc123', num: 1 }, 'M001-abc123 → { suffix, num }');
-    assertEq(parseMilestoneId('M042-z9a8b7'), { suffix: 'z9a8b7', num: 42 }, 'M042-z9a8b7 → { suffix, num }');
+    assert.deepStrictEqual(parseMilestoneId('M001-abc123'), { suffix: 'abc123', num: 1 }, 'M001-abc123 → { suffix, num }');
+    assert.deepStrictEqual(parseMilestoneId('M042-z9a8b7'), { suffix: 'z9a8b7', num: 42 }, 'M042-z9a8b7 → { suffix, num }');
 
     // Invalid → { num: 0 }
-    assertEq(parseMilestoneId(''), { num: 0 }, 'empty → { num: 0 }');
-    assertEq(parseMilestoneId('notes'), { num: 0 }, 'notes → { num: 0 }');
-    assertEq(parseMilestoneId('M001-ABCDEF'), { num: 0 }, 'uppercase suffix → { num: 0 }');
-    assertEq(parseMilestoneId('M1'), { num: 0 }, 'M1 → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId(''), { num: 0 }, 'empty → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId('notes'), { num: 0 }, 'notes → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId('M001-ABCDEF'), { num: 0 }, 'uppercase suffix → { num: 0 }');
+    assert.deepStrictEqual(parseMilestoneId('M1'), { num: 0 }, 'M1 → { num: 0 }');
   }
 
   // (d) milestoneIdSort
@@ -95,81 +95,81 @@ async function main(): Promise<void> {
     console.log('  (d) milestoneIdSort');
     const mixed = ['M003-abc123', 'M001', 'M002-z9a8b7'];
     const sorted = [...mixed].sort(milestoneIdSort);
-    assertEq(sorted, ['M001', 'M002-z9a8b7', 'M003-abc123'], 'sorts mixed IDs by sequence number');
+    assert.deepStrictEqual(sorted, ['M001', 'M002-z9a8b7', 'M003-abc123'], 'sorts mixed IDs by sequence number');
 
     // All old format
     const oldOnly = ['M003', 'M001', 'M002'];
-    assertEq([...oldOnly].sort(milestoneIdSort), ['M001', 'M002', 'M003'], 'sorts old-format IDs');
+    assert.deepStrictEqual([...oldOnly].sort(milestoneIdSort), ['M001', 'M002', 'M003'], 'sorts old-format IDs');
 
     // Invalid entries sort to front (seq 0)
     const withInvalid = ['M002', 'notes', 'M001'];
-    assertEq([...withInvalid].sort(milestoneIdSort), ['notes', 'M001', 'M002'], 'invalid entries (seq 0) sort first');
+    assert.deepStrictEqual([...withInvalid].sort(milestoneIdSort), ['notes', 'M001', 'M002'], 'invalid entries (seq 0) sort first');
   }
 
   // (e) generateMilestoneSuffix
   {
     console.log('  (e) generateMilestoneSuffix');
     const suffix1 = generateMilestoneSuffix();
-    assertEq(suffix1.length, 6, 'suffix length is 6');
-    assertMatch(suffix1, /^[a-z0-9]{6}$/, 'suffix matches [a-z0-9]{6}');
+    assert.deepStrictEqual(suffix1.length, 6, 'suffix length is 6');
+    assert.match(suffix1, /^[a-z0-9]{6}$/, 'suffix matches [a-z0-9]{6}');
 
     const suffix2 = generateMilestoneSuffix();
-    assertEq(suffix2.length, 6, 'second suffix length is 6');
-    assertMatch(suffix2, /^[a-z0-9]{6}$/, 'second suffix matches [a-z0-9]{6}');
+    assert.deepStrictEqual(suffix2.length, 6, 'second suffix length is 6');
+    assert.match(suffix2, /^[a-z0-9]{6}$/, 'second suffix matches [a-z0-9]{6}');
 
     // Two calls should produce different results (36^6 = ~2.2B possibilities)
-    assertTrue(suffix1 !== suffix2, 'two calls produce different suffixes');
+    assert.ok(suffix1 !== suffix2, 'two calls produce different suffixes');
   }
 
   // (f) nextMilestoneId
   {
     console.log('  (f) nextMilestoneId');
     // uniqueEnabled=false (default) → old format
-    assertEq(nextMilestoneId([]), 'M001', 'empty + uniqueEnabled=false → M001');
-    assertEq(nextMilestoneId(['M001', 'M002']), 'M003', 'sequential + uniqueEnabled=false → M003');
-    assertEq(nextMilestoneId(['M001', 'M002'], false), 'M003', 'explicit false → M003');
+    assert.deepStrictEqual(nextMilestoneId([]), 'M001', 'empty + uniqueEnabled=false → M001');
+    assert.deepStrictEqual(nextMilestoneId(['M001', 'M002']), 'M003', 'sequential + uniqueEnabled=false → M003');
+    assert.deepStrictEqual(nextMilestoneId(['M001', 'M002'], false), 'M003', 'explicit false → M003');
 
     // uniqueEnabled=true → unique format
     const newId = nextMilestoneId([], true);
-    assertMatch(newId, MILESTONE_ID_RE, 'uniqueEnabled=true produces valid ID');
-    assertTrue(newId.startsWith('M001-'), 'uniqueEnabled=true starts with M001-');
-    assertMatch(newId, /^M001-[a-z0-9]{6}$/, 'empty + uniqueEnabled=true → M001-{rand6}');
+    assert.match(newId, MILESTONE_ID_RE, 'uniqueEnabled=true produces valid ID');
+    assert.ok(newId.startsWith('M001-'), 'uniqueEnabled=true starts with M001-');
+    assert.match(newId, /^M001-[a-z0-9]{6}$/, 'empty + uniqueEnabled=true → M001-{rand6}');
 
     // Mixed array with uniqueEnabled=true
     const mixedIds = ['M001', 'M003-abc123', 'M002'];
     const nextNew = nextMilestoneId(mixedIds, true);
-    assertMatch(nextNew, MILESTONE_ID_RE, 'mixed array + uniqueEnabled=true → valid ID');
-    assertMatch(nextNew, /^M004-[a-z0-9]{6}$/, 'mixed array max=3 → M004-{rand6}');
+    assert.match(nextNew, MILESTONE_ID_RE, 'mixed array + uniqueEnabled=true → valid ID');
+    assert.match(nextNew, /^M004-[a-z0-9]{6}$/, 'mixed array max=3 → M004-{rand6}');
 
     // Mixed array with uniqueEnabled=false
-    assertEq(nextMilestoneId(mixedIds, false), 'M004', 'mixed array + uniqueEnabled=false → M004');
+    assert.deepStrictEqual(nextMilestoneId(mixedIds, false), 'M004', 'mixed array + uniqueEnabled=false → M004');
 
     // Correct sequential number from mixed arrays
     const mixedIds2 = ['M005-xyz999', 'M002'];
-    assertEq(nextMilestoneId(mixedIds2, false), 'M006', 'mixed max=5 → M006');
+    assert.deepStrictEqual(nextMilestoneId(mixedIds2, false), 'M006', 'mixed max=5 → M006');
     const nextNew2 = nextMilestoneId(mixedIds2, true);
-    assertMatch(nextNew2, /^M006-[a-z0-9]{6}$/, 'mixed max=5 + unique → M006-{rand6}');
+    assert.match(nextNew2, /^M006-[a-z0-9]{6}$/, 'mixed max=5 + unique → M006-{rand6}');
   }
 
   // (g) maxMilestoneNum
   {
     console.log('  (g) maxMilestoneNum');
     // Empty
-    assertEq(maxMilestoneNum([]), 0, 'empty → 0');
+    assert.deepStrictEqual(maxMilestoneNum([]), 0, 'empty → 0');
 
     // Old format only
-    assertEq(maxMilestoneNum(['M001', 'M002', 'M003']), 3, 'old format only → 3');
+    assert.deepStrictEqual(maxMilestoneNum(['M001', 'M002', 'M003']), 3, 'old format only → 3');
 
     // Unique format only — must not return NaN
-    assertEq(maxMilestoneNum(['M001-abc123', 'M002-def456']), 2, 'unique format only → 2');
-    assertTrue(!Number.isNaN(maxMilestoneNum(['M001-abc123'])), 'unique format does not return NaN');
+    assert.deepStrictEqual(maxMilestoneNum(['M001-abc123', 'M002-def456']), 2, 'unique format only → 2');
+    assert.ok(!Number.isNaN(maxMilestoneNum(['M001-abc123'])), 'unique format does not return NaN');
 
     // Mixed formats
-    assertEq(maxMilestoneNum(['M001', 'M003-abc123', 'M002']), 3, 'mixed → 3');
+    assert.deepStrictEqual(maxMilestoneNum(['M001', 'M003-abc123', 'M002']), 3, 'mixed → 3');
 
     // Non-matching entries ignored
-    assertEq(maxMilestoneNum(['M001', 'notes', '.DS_Store', 'M003']), 3, 'non-matching ignored → 3');
-    assertEq(maxMilestoneNum(['notes', '.DS_Store']), 0, 'all non-matching → 0');
+    assert.deepStrictEqual(maxMilestoneNum(['M001', 'notes', '.DS_Store', 'M003']), 3, 'non-matching ignored → 3');
+    assert.deepStrictEqual(maxMilestoneNum(['notes', '.DS_Store']), 0, 'all non-matching → 0');
   }
 
   // (h) Preferences round-trip via renderPreferencesForSystemPrompt
@@ -179,41 +179,25 @@ async function main(): Promise<void> {
     // validate { unique_milestone_ids: true } → field preserved (no validation error)
     const prefsTrue: GSDPreferences = { unique_milestone_ids: true };
     const renderedTrue = renderPreferencesForSystemPrompt(prefsTrue);
-    assertTrue(!renderedTrue.includes('some preference values were ignored'), 'unique_milestone_ids: true validates without error');
+    assert.ok(!renderedTrue.includes('some preference values were ignored'), 'unique_milestone_ids: true validates without error');
 
     // validate { unique_milestone_ids: undefined } → field absent (no error)
     const prefsUndefined: GSDPreferences = {};
     const renderedUndefined = renderPreferencesForSystemPrompt(prefsUndefined);
-    assertTrue(!renderedUndefined.includes('some preference values were ignored'), 'undefined unique_milestone_ids validates without error');
+    assert.ok(!renderedUndefined.includes('some preference values were ignored'), 'undefined unique_milestone_ids validates without error');
 
     // validate { unique_milestone_ids: false } → also valid
     const prefsFalse: GSDPreferences = { unique_milestone_ids: false };
     const renderedFalse = renderPreferencesForSystemPrompt(prefsFalse);
-    assertTrue(!renderedFalse.includes('some preference values were ignored'), 'unique_milestone_ids: false validates without error');
+    assert.ok(!renderedFalse.includes('some preference values were ignored'), 'unique_milestone_ids: false validates without error');
 
     // validate coercion: truthy non-boolean → coerced to boolean (no crash)
     const prefsCoerced: GSDPreferences = { unique_milestone_ids: 1 as unknown as boolean };
     const renderedCoerced = renderPreferencesForSystemPrompt(prefsCoerced);
-    assertTrue(!renderedCoerced.includes('some preference values were ignored'), 'truthy non-boolean coerces without validation error');
+    assert.ok(!renderedCoerced.includes('some preference values were ignored'), 'truthy non-boolean coerces without validation error');
 
     // GSDPreferences interface accepts the field (compile-time check — if this compiles, it works)
     const prefs: GSDPreferences = { unique_milestone_ids: true, version: 1 };
-    assertTrue(prefs.unique_milestone_ids === true, 'GSDPreferences interface accepts unique_milestone_ids');
+    assert.ok(prefs.unique_milestone_ids === true, 'GSDPreferences interface accepts unique_milestone_ids');
   }
-
-  report();
-}
-
-// When run via vitest, wrap in test(); when run via tsx, call directly.
-const isVitest = typeof globalThis !== 'undefined' && (globalThis as any).__vitest_worker__?.config?.defines != null && 'vitest' in (globalThis as any).__vitest_worker__.config.defines || process.env.VITEST;
-if (isVitest) {
-  const { test } = await import('node:test');
-  test('unique-milestone-ids: all ID primitives handle both formats', async () => {
-    await main();
-  });
-} else {
-  main().catch((error) => {
-    console.error(error);
-    process.exit(1);
-  });
-}
+});

package/src/resources/extensions/gsd/tests/unit-runtime.test.ts

@@ -9,9 +9,9 @@ import {
   writeUnitRuntimeRecord,
 } from "../unit-runtime.ts";
 import { clearPathCache } from '../paths.ts';
-import { createTestContext } from './test-helpers.ts';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
 
-const { assertEq, assertTrue, report } = createTestContext();
 const base = mkdtempSync(join(tmpdir(), "gsd-unit-runtime-test-"));
 const tasksDir = join(base, ".gsd", "milestones", "M100", "slices", "S02", "tasks");
 mkdirSync(tasksDir, { recursive: true });
@@ -25,22 +25,22 @@ writeFileSync(
 console.log("\n=== runtime record write/read/update ===");
 {
   const first = writeUnitRuntimeRecord(base, "execute-task", "M100/S02/T09", 1000, { phase: "dispatched" });
-  assertEq(first.phase, "dispatched", "initial phase");
+  assert.deepStrictEqual(first.phase, "dispatched", "initial phase");
   const second = writeUnitRuntimeRecord(base, "execute-task", "M100/S02/T09", 1000, { phase: "wrapup-warning-sent", wrapupWarningSent: true });
-  assertEq(second.wrapupWarningSent, true, "warning persisted");
+  assert.deepStrictEqual(second.wrapupWarningSent, true, "warning persisted");
   const loaded = readUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
-  assertTrue(loaded !== null, "record readable");
-  assertEq(loaded!.phase, "wrapup-warning-sent", "updated phase readable");
+  assert.ok(loaded !== null, "record readable");
+  assert.deepStrictEqual(loaded!.phase, "wrapup-warning-sent", "updated phase readable");
 }
 
 console.log("\n=== execute-task durability inspection ===");
 {
   let status = await inspectExecuteTaskDurability(base, "M100/S02/T09");
-  assertTrue(status !== null, "status exists");
-  assertEq(status!.summaryExists, false, "summary initially missing");
-  assertEq(status!.taskChecked, false, "task initially unchecked");
-  assertEq(status!.nextActionAdvanced, false, "next action initially stale");
-  assertTrue(/summary missing/i.test(formatExecuteTaskRecoveryStatus(status!)), "diagnostic mentions summary");
+  assert.ok(status !== null, "status exists");
+  assert.deepStrictEqual(status!.summaryExists, false, "summary initially missing");
+  assert.deepStrictEqual(status!.taskChecked, false, "task initially unchecked");
+  assert.deepStrictEqual(status!.nextActionAdvanced, false, "next action initially stale");
+  assert.ok(/summary missing/i.test(formatExecuteTaskRecoveryStatus(status!)), "diagnostic mentions summary");
 
   writeFileSync(join(tasksDir, "T09-SUMMARY.md"), "# done\n", "utf-8");
   writeFileSync(
@@ -52,17 +52,17 @@ console.log("\n=== execute-task durability inspection ===");
   clearPathCache();
 
   status = await inspectExecuteTaskDurability(base, "M100/S02/T09");
-  assertEq(status!.summaryExists, true, "summary found after write");
-  assertEq(status!.taskChecked, true, "task checked after update");
-  assertEq(status!.nextActionAdvanced, true, "next action advanced after update");
-  assertEq(formatExecuteTaskRecoveryStatus(status!), "all durable task artifacts present", "clean diagnostic when complete");
+  assert.deepStrictEqual(status!.summaryExists, true, "summary found after write");
+  assert.deepStrictEqual(status!.taskChecked, true, "task checked after update");
+  assert.deepStrictEqual(status!.nextActionAdvanced, true, "next action advanced after update");
+  assert.deepStrictEqual(formatExecuteTaskRecoveryStatus(status!), "all durable task artifacts present", "clean diagnostic when complete");
 }
 
 console.log("\n=== runtime record cleanup ===");
 {
   clearUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
   const loaded = readUnitRuntimeRecord(base, "execute-task", "M100/S02/T09");
-  assertEq(loaded, null, "record removed");
+  assert.deepStrictEqual(loaded, null, "record removed");
 }
 
 console.log("\n=== hook unit type sanitization (slash in unitType) ===");
@@ -70,23 +70,23 @@ console.log("\n=== hook unit type sanitization (slash in unitType) ===");
   // Hook units have unitType like "hook/code-review" with a slash
   // This should NOT create a subdirectory - the slash must be sanitized
   const hookRecord = writeUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10", 2000, { phase: "dispatched" });
-  assertEq(hookRecord.unitType, "hook/code-review", "unitType preserved in record");
-  assertEq(hookRecord.unitId, "M100/S02/T10", "unitId preserved in record");
+  assert.deepStrictEqual(hookRecord.unitType, "hook/code-review", "unitType preserved in record");
+  assert.deepStrictEqual(hookRecord.unitId, "M100/S02/T10", "unitId preserved in record");
   
   const loaded = readUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10");
-  assertTrue(loaded !== null, "hook record readable");
-  assertEq(loaded!.phase, "dispatched", "hook phase correct");
+  assert.ok(loaded !== null, "hook record readable");
+  assert.deepStrictEqual(loaded!.phase, "dispatched", "hook phase correct");
   
   // Verify the file is in the units dir, not in a subdirectory
   const unitsDir = join(base, ".gsd", "runtime", "units");
   const files = readdirSync(unitsDir);
   const hookFile = files.find((f: string) => f.includes("hook-code-review"));
-  assertTrue(hookFile !== undefined, "hook file exists with sanitized name");
-  assertTrue(!files.some((f: string) => f === "hook"), "no 'hook' subdirectory created");
+  assert.ok(hookFile !== undefined, "hook file exists with sanitized name");
+  assert.ok(!files.some((f: string) => f === "hook"), "no 'hook' subdirectory created");
   
   clearUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10");
   const cleared = readUnitRuntimeRecord(base, "hook/code-review", "M100/S02/T10");
-  assertEq(cleared, null, "hook record removed");
+  assert.deepStrictEqual(cleared, null, "hook record removed");
 }
 
 // ─── Must-have durability integration tests ───────────────────────────────
@@ -121,13 +121,13 @@ console.log("\n=== must-haves: all mentioned in summary ===");
   writeFileSync(join(mhBase, ".gsd", "STATE.md"), "## Next Action\nExecute T02 for S01: next thing\n", "utf-8");
 
   const status = await inspectExecuteTaskDurability(mhBase, "M200/S01/T01");
-  assertTrue(status !== null, "mh-all: status exists");
-  assertEq(status!.mustHaveCount, 3, "mh-all: mustHaveCount is 3");
-  assertEq(status!.mustHavesMentionedInSummary, 3, "mh-all: all 3 must-haves mentioned");
-  assertEq(status!.summaryExists, true, "mh-all: summary exists");
-  assertEq(status!.taskChecked, true, "mh-all: task checked");
+  assert.ok(status !== null, "mh-all: status exists");
+  assert.deepStrictEqual(status!.mustHaveCount, 3, "mh-all: mustHaveCount is 3");
+  assert.deepStrictEqual(status!.mustHavesMentionedInSummary, 3, "mh-all: all 3 must-haves mentioned");
+  assert.deepStrictEqual(status!.summaryExists, true, "mh-all: summary exists");
+  assert.deepStrictEqual(status!.taskChecked, true, "mh-all: task checked");
   const diag = formatExecuteTaskRecoveryStatus(status!);
-  assertEq(diag, "all durable task artifacts present", "mh-all: diagnostic is clean when all must-haves met");
+  assert.deepStrictEqual(diag, "all durable task artifacts present", "mh-all: diagnostic is clean when all must-haves met");
 }
 
 console.log("\n=== must-haves: partially mentioned in summary ===");
@@ -156,12 +156,12 @@ console.log("\n=== must-haves: partially mentioned in summary ===");
 
   clearPathCache();
   const status = await inspectExecuteTaskDurability(mhBase, "M200/S02/T01");
-  assertTrue(status !== null, "mh-partial: status exists");
-  assertEq(status!.mustHaveCount, 3, "mh-partial: mustHaveCount is 3");
-  assertEq(status!.mustHavesMentionedInSummary, 1, "mh-partial: only 1 must-have mentioned");
+  assert.ok(status !== null, "mh-partial: status exists");
+  assert.deepStrictEqual(status!.mustHaveCount, 3, "mh-partial: mustHaveCount is 3");
+  assert.deepStrictEqual(status!.mustHavesMentionedInSummary, 1, "mh-partial: only 1 must-have mentioned");
   const diag = formatExecuteTaskRecoveryStatus(status!);
-  assertTrue(diag.includes("must-have gap"), "mh-partial: diagnostic includes 'must-have gap'");
-  assertTrue(diag.includes("1 of 3"), "mh-partial: diagnostic includes '1 of 3'");
+  assert.ok(diag.includes("must-have gap"), "mh-partial: diagnostic includes 'must-have gap'");
+  assert.ok(diag.includes("1 of 3"), "mh-partial: diagnostic includes '1 of 3'");
 }
 
 console.log("\n=== must-haves: no task plan file ===");
@@ -184,9 +184,9 @@ console.log("\n=== must-haves: no task plan file ===");
 
   clearPathCache();
   const status = await inspectExecuteTaskDurability(mhBase, "M200/S03/T01");
-  assertTrue(status !== null, "mh-noplan: status exists");
-  assertEq(status!.mustHaveCount, 0, "mh-noplan: mustHaveCount is 0 when no task plan");
-  assertEq(status!.mustHavesMentionedInSummary, 0, "mh-noplan: mustHavesMentionedInSummary is 0");
+  assert.ok(status !== null, "mh-noplan: status exists");
+  assert.deepStrictEqual(status!.mustHaveCount, 0, "mh-noplan: mustHaveCount is 0 when no task plan");
+  assert.deepStrictEqual(status!.mustHavesMentionedInSummary, 0, "mh-noplan: mustHavesMentionedInSummary is 0");
 }
 
 console.log("\n=== must-haves: present but no summary file ===");
@@ -209,10 +209,10 @@ console.log("\n=== must-haves: present but no summary file ===");
 
   clearPathCache();
   const status = await inspectExecuteTaskDurability(mhBase, "M200/S04/T01");
-  assertTrue(status !== null, "mh-nosummary: status exists");
-  assertEq(status!.mustHaveCount, 2, "mh-nosummary: mustHaveCount is 2");
-  assertEq(status!.mustHavesMentionedInSummary, 0, "mh-nosummary: mustHavesMentionedInSummary is 0 with no summary");
-  assertEq(status!.summaryExists, false, "mh-nosummary: summary doesn't exist");
+  assert.ok(status !== null, "mh-nosummary: status exists");
+  assert.deepStrictEqual(status!.mustHaveCount, 2, "mh-nosummary: mustHaveCount is 2");
+  assert.deepStrictEqual(status!.mustHavesMentionedInSummary, 0, "mh-nosummary: mustHavesMentionedInSummary is 0 with no summary");
+  assert.deepStrictEqual(status!.summaryExists, false, "mh-nosummary: summary doesn't exist");
 }
 
 console.log("\n=== must-haves: substring matching (no backtick tokens) ===");
@@ -241,18 +241,17 @@ console.log("\n=== must-haves: substring matching (no backtick tokens) ===");
 
   clearPathCache();
   const status = await inspectExecuteTaskDurability(mhBase, "M200/S05/T01");
-  assertTrue(status !== null, "mh-substr: status exists");
-  assertEq(status!.mustHaveCount, 3, "mh-substr: mustHaveCount is 3");
+  assert.ok(status !== null, "mh-substr: status exists");
+  assert.deepStrictEqual(status!.mustHaveCount, 3, "mh-substr: mustHaveCount is 3");
   // "heuristic" appears in summary for item 1, "diagnostic" for item 2, 
   // "assertions" appears in summary? No — let's check
   // Item 3: "All assertions pass" — words: "assertions", "pass" (<4 chars excluded)
   // summary doesn't contain "assertions" → not matched
-  assertEq(status!.mustHavesMentionedInSummary, 2, "mh-substr: 2 of 3 matched via substring");
+  assert.deepStrictEqual(status!.mustHavesMentionedInSummary, 2, "mh-substr: 2 of 3 matched via substring");
   const diag = formatExecuteTaskRecoveryStatus(status!);
-  assertTrue(diag.includes("must-have gap"), "mh-substr: diagnostic includes gap info");
-  assertTrue(diag.includes("2 of 3"), "mh-substr: diagnostic includes '2 of 3'");
+  assert.ok(diag.includes("must-have gap"), "mh-substr: diagnostic includes gap info");
+  assert.ok(diag.includes("2 of 3"), "mh-substr: diagnostic includes '2 of 3'");
 }
 
 rmSync(mhBase, { recursive: true, force: true });
 rmSync(base, { recursive: true, force: true });
-report();

package/src/resources/extensions/gsd/tests/validate-milestone.test.ts

@@ -375,7 +375,7 @@ test("buildLoopRemediationSteps returns steps for validate-milestone", () => {
     assert.ok(result);
     assert.ok(result!.includes("VALIDATION"));
     assert.ok(result!.includes("verdict: pass"));
-    assert.ok(result!.includes("gsd doctor"));
+    assert.ok(result!.includes("gsd recover"));
   } finally {
     cleanup(base);
   }

package/src/resources/extensions/gsd/tests/verification-evidence.test.ts

@@ -240,148 +240,6 @@ test("verification-evidence: formatEvidenceTable uses ✅/❌ emoji for pass/fai
   assert.ok(table.includes("❌ fail"), "failing check should have ❌ fail");
 });
 
-// ─── Validator Rule Tests (T03) ──────────────────────────────────────────────
-
-import { validateTaskSummaryContent } from "../observability-validator.ts";
-
-const MINIMAL_SUMMARY_WITH_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-| # | Command | Exit Code | Verdict | Duration |
-|---|---------|-----------|---------|----------|
-| 1 | npm run typecheck | 0 | ✅ pass | 2.3s |
-`;
-
-const MINIMAL_SUMMARY_NO_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-`;
-
-const MINIMAL_SUMMARY_PLACEHOLDER_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-{{evidence_table}}
-`;
-
-const MINIMAL_SUMMARY_NO_CHECKS_EVIDENCE = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-_No verification checks discovered._
-`;
-
-test("verification-evidence: validator accepts summary with real evidence table", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_WITH_EVIDENCE);
-  const evidenceIssues = issues.filter(
-    (i) => i.ruleId === "evidence_block_missing" || i.ruleId === "evidence_block_placeholder",
-  );
-  assert.equal(evidenceIssues.length, 0, "no evidence warnings for real table");
-});
-
-test("verification-evidence: validator warns when evidence section is missing", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_NO_EVIDENCE);
-  const match = issues.find((i) => i.ruleId === "evidence_block_missing");
-  assert.ok(match, "should produce evidence_block_missing warning");
-  assert.equal(match!.severity, "warning");
-  assert.equal(match!.scope, "task-summary");
-});
-
-test("verification-evidence: validator warns when evidence section has only placeholder text", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_PLACEHOLDER_EVIDENCE);
-  const match = issues.find((i) => i.ruleId === "evidence_block_placeholder");
-  assert.ok(match, "should produce evidence_block_placeholder warning");
-  assert.equal(match!.severity, "warning");
-});
-
-test("verification-evidence: validator accepts 'no checks discovered' as valid content", () => {
-  const issues = validateTaskSummaryContent("T03-SUMMARY.md", MINIMAL_SUMMARY_NO_CHECKS_EVIDENCE);
-  const evidenceIssues = issues.filter(
-    (i) => i.ruleId === "evidence_block_missing" || i.ruleId === "evidence_block_placeholder",
-  );
-  assert.equal(evidenceIssues.length, 0, "no evidence warnings for 'no checks discovered'");
-});
-
-// ─── Integration Test: Full Chain (T03) ──────────────────────────────────────
-
-test("verification-evidence: integration — VerificationResult → JSON → table → validator accepts", () => {
-  const tmp = makeTempDir("ve-integration");
-  try {
-    // 1. Create a VerificationResult with 2 checks (1 pass, 1 fail)
-    const result = makeResult({
-      passed: false,
-      checks: [
-        { command: "npm run typecheck", exitCode: 0, stdout: "ok", stderr: "", durationMs: 1500 },
-        { command: "npm run test:unit", exitCode: 1, stdout: "", stderr: "1 failed", durationMs: 3200 },
-      ],
-      discoverySource: "package-json",
-    });
-
-    // 2. Write JSON to temp dir and read it back
-    writeVerificationJSON(result, tmp, "T03");
-    const jsonPath = join(tmp, "T03-VERIFY.json");
-    assert.ok(existsSync(jsonPath), "JSON file should exist");
-
-    const json = JSON.parse(readFileSync(jsonPath, "utf-8"));
-    assert.equal(json.schemaVersion, 1, "schemaVersion should be 1");
-    assert.equal(json.passed, false, "passed should be false");
-    assert.equal(json.checks.length, 2, "should have 2 checks");
-    assert.equal(json.checks[0].verdict, "pass", "first check should pass");
-    assert.equal(json.checks[1].verdict, "fail", "second check should fail");
-
-    // 3. Generate evidence table and embed in a mock summary
-    const table = formatEvidenceTable(result);
-    assert.ok(table.includes("npm run typecheck"), "table should contain first command");
-    assert.ok(table.includes("npm run test:unit"), "table should contain second command");
-
-    const fullSummary = `---
-observability_surfaces:
-  - gate-output
----
-# T03 Summary
-
-## Diagnostics
-Run \`npm test\` to verify.
-
-## Verification Evidence
-${table}
-`;
-
-    // 4. Validate — no evidence warnings
-    const issues = validateTaskSummaryContent("T03-SUMMARY.md", fullSummary);
-    const evidenceIssues = issues.filter(
-      (i) => i.ruleId === "evidence_block_missing" || i.ruleId === "evidence_block_placeholder",
-    );
-    assert.equal(evidenceIssues.length, 0, "validator should accept real evidence from formatEvidenceTable");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
-});
-
 // ─── Retry Evidence Field Tests (S03/T01) ─────────────────────────────────────
 
 test("verification-evidence: writeVerificationJSON with retryAttempt and maxRetries includes them in output", () => {