gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/overrides.test.ts

@@ -1,14 +1,15 @@
 // GSD Extension - Override Tests
 // Tests for parseOverrides, appendOverride, loadActiveOverrides, formatOverridesSection, resolveAllOverrides
 
-import { describe, test, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { createTestContext } from './test-helpers.ts';
 import { parseOverrides, appendOverride, loadActiveOverrides, formatOverridesSection, resolveAllOverrides } from '../files.ts';
 import type { Override } from '../files.ts';
 
+const { assertEq, assertTrue, assertMatch, assertNoMatch, report } = createTestContext();
+
 const tempDirs: string[] = [];
 
 function makeTempDir(prefix: string): string {
@@ -25,100 +26,106 @@ function cleanup(): void {
   tempDirs.length = 0;
 }
 
-describe('overrides', () => {
-  afterEach(() => cleanup());
-
-  test('parseOverrides: empty content', () => {
-    const result = parseOverrides(""); assert.deepStrictEqual(result.length, 0, "empty content returns no overrides");
-  });
-
-  test('parseOverrides: single active override', () => {
-    const content = `# GSD Overrides\n\nUser-issued overrides that supersede plan document content.\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** active\n**Applied-at:** M001/S02/T03\n\n---\n`;
-    const result = parseOverrides(content);
-    assert.deepStrictEqual(result.length, 1, "parses one override");
-    assert.deepStrictEqual(result[0].timestamp, "2026-03-14T10:00:00.000Z", "correct timestamp");
-    assert.deepStrictEqual(result[0].change, "Use Postgres instead of SQLite", "correct change");
-    assert.deepStrictEqual(result[0].scope, "active", "correct scope");
-    assert.deepStrictEqual(result[0].appliedAt, "M001/S02/T03", "correct appliedAt");
-  });
-
-  test('parseOverrides: multiple overrides, mixed scopes', () => {
-    const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** resolved\n**Applied-at:** M001/S02/T03\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Use JWT instead of session cookies\n**Scope:** active\n**Applied-at:** M001/S03/T01\n\n---\n`;
-    const result = parseOverrides(content);
-    assert.deepStrictEqual(result.length, 2, "parses two overrides");
-    assert.deepStrictEqual(result[0].scope, "resolved", "first is resolved");
-    assert.deepStrictEqual(result[1].scope, "active", "second is active");
-    assert.deepStrictEqual(result[1].change, "Use JWT instead of session cookies", "second change text");
-  });
-
-  test('appendOverride: creates new file', async () => {
-    const tmp = makeTempDir("append-new");
-    await appendOverride(tmp, "Use Postgres", "M001/S01/T01");
-    const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
-    assert.ok(content.includes("# GSD Overrides"), "has header");
-    assert.ok(content.includes("**Change:** Use Postgres"), "has change");
-    assert.ok(content.includes("**Scope:** active"), "has active scope");
-    assert.ok(content.includes("**Applied-at:** M001/S01/T01"), "has appliedAt");
-  });
-
-  test('appendOverride: appends to existing file', async () => {
-    const tmp = makeTempDir("append-existing");
-    await appendOverride(tmp, "First override", "M001/S01/T01");
-    await appendOverride(tmp, "Second override", "M001/S02/T02");
-    const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
-    assert.ok(content.includes("**Change:** First override"), "has first override");
-    assert.ok(content.includes("**Change:** Second override"), "has second override");
-    const parsed = parseOverrides(content);
-    assert.deepStrictEqual(parsed.length, 2, "two overrides in file");
-  });
-
-  test('loadActiveOverrides: no file', async () => {
-    const tmp = makeTempDir("load-no-file");
-    const result = await loadActiveOverrides(tmp);
-    assert.deepStrictEqual(result.length, 0, "returns empty when no file");
-  });
-
-  test('loadActiveOverrides: filters to active only', async () => {
-    const tmp = makeTempDir("load-filter");
-    const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Resolved change\n**Scope:** resolved\n**Applied-at:** M001/S01/T01\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Active change\n**Scope:** active\n**Applied-at:** M001/S02/T01\n\n---\n`;
-    writeFileSync(join(tmp, ".gsd", "OVERRIDES.md"), content, "utf-8");
-    const result = await loadActiveOverrides(tmp);
-    assert.deepStrictEqual(result.length, 1, "only one active override");
-    assert.deepStrictEqual(result[0].change, "Active change", "correct active change");
-  });
-
-  test('formatOverridesSection: empty array', () => {
-    const result = formatOverridesSection([]); assert.deepStrictEqual(result, "", "empty overrides returns empty string");
-  });
-
-  test('formatOverridesSection: formats section', () => {
-    const overrides: Override[] = [
-      { timestamp: "2026-03-14T10:00:00.000Z", change: "Use Postgres", scope: "active", appliedAt: "M001/S01/T01" },
-    ];
-    const result = formatOverridesSection(overrides);
-    assert.ok(result.includes("## Active Overrides (supersede plan content)"), "has header");
-    assert.ok(result.includes("**Use Postgres**"), "has change text");
-    assert.ok(result.includes("supersede any conflicting content"), "has instruction");
-  });
-
-  test('resolveAllOverrides: marks all as resolved', async () => {
-    const tmp = makeTempDir("resolve-all");
-    await appendOverride(tmp, "First", "M001/S01/T01");
-    await appendOverride(tmp, "Second", "M001/S02/T01");
-    let active = await loadActiveOverrides(tmp);
-    assert.deepStrictEqual(active.length, 2, "two active before resolve");
-    await resolveAllOverrides(tmp);
-    active = await loadActiveOverrides(tmp);
-    assert.deepStrictEqual(active.length, 0, "no active after resolve");
-    const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
-    const allOverrides = parseOverrides(content);
-    assert.deepStrictEqual(allOverrides.length, 2, "still two overrides total");
-    assert.ok(allOverrides.every(o => o.scope === "resolved"), "all resolved");
-  });
-
-  test('resolveAllOverrides: no file — no error', async () => {
-    const tmp = makeTempDir("resolve-no-file");
-    await resolveAllOverrides(tmp);
-    assert.ok(true, "resolveAllOverrides with no file does not throw");
-  });
-});
+console.log('\n=== parseOverrides: empty content ===');
+{ const result = parseOverrides(""); assertEq(result.length, 0, "empty content returns no overrides"); }
+
+console.log('\n=== parseOverrides: single active override ===');
+{
+  const content = `# GSD Overrides\n\nUser-issued overrides that supersede plan document content.\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** active\n**Applied-at:** M001/S02/T03\n\n---\n`;
+  const result = parseOverrides(content);
+  assertEq(result.length, 1, "parses one override");
+  assertEq(result[0].timestamp, "2026-03-14T10:00:00.000Z", "correct timestamp");
+  assertEq(result[0].change, "Use Postgres instead of SQLite", "correct change");
+  assertEq(result[0].scope, "active", "correct scope");
+  assertEq(result[0].appliedAt, "M001/S02/T03", "correct appliedAt");
+}
+
+console.log('\n=== parseOverrides: multiple overrides, mixed scopes ===');
+{
+  const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Use Postgres instead of SQLite\n**Scope:** resolved\n**Applied-at:** M001/S02/T03\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Use JWT instead of session cookies\n**Scope:** active\n**Applied-at:** M001/S03/T01\n\n---\n`;
+  const result = parseOverrides(content);
+  assertEq(result.length, 2, "parses two overrides");
+  assertEq(result[0].scope, "resolved", "first is resolved");
+  assertEq(result[1].scope, "active", "second is active");
+  assertEq(result[1].change, "Use JWT instead of session cookies", "second change text");
+}
+
+console.log('\n=== appendOverride: creates new file ===');
+{
+  const tmp = makeTempDir("append-new");
+  await appendOverride(tmp, "Use Postgres", "M001/S01/T01");
+  const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
+  assertTrue(content.includes("# GSD Overrides"), "has header");
+  assertTrue(content.includes("**Change:** Use Postgres"), "has change");
+  assertTrue(content.includes("**Scope:** active"), "has active scope");
+  assertTrue(content.includes("**Applied-at:** M001/S01/T01"), "has appliedAt");
+}
+
+console.log('\n=== appendOverride: appends to existing file ===');
+{
+  const tmp = makeTempDir("append-existing");
+  await appendOverride(tmp, "First override", "M001/S01/T01");
+  await appendOverride(tmp, "Second override", "M001/S02/T02");
+  const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
+  assertTrue(content.includes("**Change:** First override"), "has first override");
+  assertTrue(content.includes("**Change:** Second override"), "has second override");
+  const parsed = parseOverrides(content);
+  assertEq(parsed.length, 2, "two overrides in file");
+}
+
+console.log('\n=== loadActiveOverrides: no file ===');
+{
+  const tmp = makeTempDir("load-no-file");
+  const result = await loadActiveOverrides(tmp);
+  assertEq(result.length, 0, "returns empty when no file");
+}
+
+console.log('\n=== loadActiveOverrides: filters to active only ===');
+{
+  const tmp = makeTempDir("load-filter");
+  const content = `# GSD Overrides\n\n---\n\n## Override: 2026-03-14T10:00:00.000Z\n\n**Change:** Resolved change\n**Scope:** resolved\n**Applied-at:** M001/S01/T01\n\n---\n\n## Override: 2026-03-14T11:00:00.000Z\n\n**Change:** Active change\n**Scope:** active\n**Applied-at:** M001/S02/T01\n\n---\n`;
+  writeFileSync(join(tmp, ".gsd", "OVERRIDES.md"), content, "utf-8");
+  const result = await loadActiveOverrides(tmp);
+  assertEq(result.length, 1, "only one active override");
+  assertEq(result[0].change, "Active change", "correct active change");
+}
+
+console.log('\n=== formatOverridesSection: empty array ===');
+{ const result = formatOverridesSection([]); assertEq(result, "", "empty overrides returns empty string"); }
+
+console.log('\n=== formatOverridesSection: formats section ===');
+{
+  const overrides: Override[] = [
+    { timestamp: "2026-03-14T10:00:00.000Z", change: "Use Postgres", scope: "active", appliedAt: "M001/S01/T01" },
+  ];
+  const result = formatOverridesSection(overrides);
+  assertTrue(result.includes("## Active Overrides (supersede plan content)"), "has header");
+  assertTrue(result.includes("**Use Postgres**"), "has change text");
+  assertTrue(result.includes("supersede any conflicting content"), "has instruction");
+}
+
+console.log('\n=== resolveAllOverrides: marks all as resolved ===');
+{
+  const tmp = makeTempDir("resolve-all");
+  await appendOverride(tmp, "First", "M001/S01/T01");
+  await appendOverride(tmp, "Second", "M001/S02/T01");
+  let active = await loadActiveOverrides(tmp);
+  assertEq(active.length, 2, "two active before resolve");
+  await resolveAllOverrides(tmp);
+  active = await loadActiveOverrides(tmp);
+  assertEq(active.length, 0, "no active after resolve");
+  const content = readFileSync(join(tmp, ".gsd", "OVERRIDES.md"), "utf-8");
+  const allOverrides = parseOverrides(content);
+  assertEq(allOverrides.length, 2, "still two overrides total");
+  assertTrue(allOverrides.every(o => o.scope === "resolved"), "all resolved");
+}
+
+console.log('\n=== resolveAllOverrides: no file — no error ===');
+{
+  const tmp = makeTempDir("resolve-no-file");
+  await resolveAllOverrides(tmp);
+  assertTrue(true, "resolveAllOverrides with no file does not throw");
+}
+
+cleanup();
+report();

package/src/resources/extensions/gsd/tests/parallel-crash-recovery.test.ts

@@ -5,8 +5,6 @@
  * restored after a coordinator crash, with PID liveness filtering.
  */
 
-import { describe, test } from 'node:test';
-import assert from 'node:assert/strict';
 import {
   mkdtempSync,
   mkdirSync,
@@ -26,6 +24,10 @@ import {
   type PersistedState,
 } from "../parallel-orchestrator.ts";
 import { writeSessionStatus, readAllSessionStatuses, removeSessionStatus } from "../session-status-io.ts";
+import { createTestContext } from './test-helpers.ts';
+
+const { assertEq, assertTrue, report } = createTestContext();
+
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
 function makeTempDir(): string {
@@ -55,9 +57,8 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
 // ─── Tests ────────────────────────────────────────────────────────────────────
 
-
-describe('parallel-crash-recovery', () => {
-test('Test 1: persistState writes valid JSON', () => {
+// Test 1: persistState writes valid JSON
+{
   const basePath = makeTempDir();
   try {
     // We can't call persistState directly without internal state set up,
@@ -81,27 +82,29 @@ test('Test 1: persistState writes valid JSON', () => {
 
     const raw = readFileSync(stateFilePath(basePath), "utf-8");
     const parsed = JSON.parse(raw) as PersistedState;
-    assert.deepStrictEqual(parsed.active, true, "persistState: active field preserved");
-    assert.deepStrictEqual(parsed.workers.length, 1, "persistState: worker count preserved");
-    assert.deepStrictEqual(parsed.workers[0].milestoneId, "M001", "persistState: milestoneId preserved");
-    assert.deepStrictEqual(parsed.workers[0].cost, 0.15, "persistState: cost preserved");
-    assert.deepStrictEqual(parsed.totalCost, 0.15, "persistState: totalCost preserved");
+    assertEq(parsed.active, true, "persistState: active field preserved");
+    assertEq(parsed.workers.length, 1, "persistState: worker count preserved");
+    assertEq(parsed.workers[0].milestoneId, "M001", "persistState: milestoneId preserved");
+    assertEq(parsed.workers[0].cost, 0.15, "persistState: cost preserved");
+    assertEq(parsed.totalCost, 0.15, "persistState: totalCost preserved");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-});
+}
 
-test('Test 2: restoreState returns null for missing file', () => {
+// Test 2: restoreState returns null for missing file
+{
   const basePath = makeTempDir();
   try {
     const result = restoreState(basePath);
-    assert.deepStrictEqual(result, null, "restoreState: returns null when no state file");
+    assertEq(result, null, "restoreState: returns null when no state file");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-});
+}
 
-test('Test 3: restoreState filters dead PIDs', () => {
+// Test 3: restoreState filters dead PIDs
+{
   const basePath = makeTempDir();
   try {
     // PID 99999999 is almost certainly not alive
@@ -133,14 +136,15 @@ test('Test 3: restoreState filters dead PIDs', () => {
 
     const result = restoreState(basePath);
     // Both PIDs are dead, so result should be null and file should be cleaned up
-    assert.deepStrictEqual(result, null, "restoreState: returns null when all PIDs dead");
-    assert.ok(!existsSync(stateFilePath(basePath)), "restoreState: cleans up state file when all dead");
+    assertEq(result, null, "restoreState: returns null when all PIDs dead");
+    assertTrue(!existsSync(stateFilePath(basePath)), "restoreState: cleans up state file when all dead");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-});
+}
 
-test('Test 4: restoreState keeps alive PIDs', () => {
+// Test 4: restoreState keeps alive PIDs
+{
   const basePath = makeTempDir();
   try {
     // Use current process PID (definitely alive)
@@ -172,17 +176,18 @@ test('Test 4: restoreState keeps alive PIDs', () => {
     writeStateFile(basePath, state);
 
     const result = restoreState(basePath);
-    assert.ok(result !== null, "restoreState: returns state when alive PID exists");
-    assert.deepStrictEqual(result!.workers.length, 1, "restoreState: filters out dead PID");
-    assert.deepStrictEqual(result!.workers[0].milestoneId, "M001", "restoreState: keeps alive worker");
-    assert.deepStrictEqual(result!.workers[0].pid, process.pid, "restoreState: preserves PID");
-    assert.deepStrictEqual(result!.workers[0].completedUnits, 5, "restoreState: preserves progress");
+    assertTrue(result !== null, "restoreState: returns state when alive PID exists");
+    assertEq(result!.workers.length, 1, "restoreState: filters out dead PID");
+    assertEq(result!.workers[0].milestoneId, "M001", "restoreState: keeps alive worker");
+    assertEq(result!.workers[0].pid, process.pid, "restoreState: preserves PID");
+    assertEq(result!.workers[0].completedUnits, 5, "restoreState: preserves progress");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-});
+}
 
-test('Test 5: restoreState skips stopped/error workers even with alive PIDs', () => {
+// Test 5: restoreState skips stopped/error workers even with alive PIDs
+{
   const basePath = makeTempDir();
   try {
     const state = makePersistedState({
@@ -202,13 +207,14 @@ test('Test 5: restoreState skips stopped/error workers even with alive PIDs', ()
     writeStateFile(basePath, state);
 
     const result = restoreState(basePath);
-    assert.deepStrictEqual(result, null, "restoreState: skips stopped workers");
+    assertEq(result, null, "restoreState: skips stopped workers");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-});
+}
 
-test('Test 6: orphan detection finds stale sessions', () => {
+// Test 6: orphan detection finds stale sessions
+{
   const basePath = makeTempDir();
   try {
     // Write a session status with a dead PID
@@ -240,7 +246,7 @@ test('Test 6: orphan detection finds stale sessions', () => {
 
     // Read all sessions — both should exist initially
     const before = readAllSessionStatuses(basePath);
-    assert.deepStrictEqual(before.length, 2, "orphan: both sessions exist before detection");
+    assertEq(before.length, 2, "orphan: both sessions exist before detection");
 
     // Now simulate orphan detection logic (same as prepareParallelStart)
     const sessions = readAllSessionStatuses(basePath);
@@ -259,33 +265,34 @@ test('Test 6: orphan detection finds stale sessions', () => {
       }
     }
 
-    assert.ok(orphans.length === 2, "orphan: detected both sessions");
+    assertTrue(orphans.length === 2, "orphan: detected both sessions");
     const deadOrphan = orphans.find(o => o.milestoneId === "M001");
-    assert.ok(deadOrphan !== undefined && !deadOrphan.alive, "orphan: M001 detected as dead");
+    assertTrue(deadOrphan !== undefined && !deadOrphan.alive, "orphan: M001 detected as dead");
     const aliveOrphan = orphans.find(o => o.milestoneId === "M002");
-    assert.ok(aliveOrphan !== undefined && aliveOrphan.alive, "orphan: M002 detected as alive");
+    assertTrue(aliveOrphan !== undefined && aliveOrphan.alive, "orphan: M002 detected as alive");
 
     // Dead session should be cleaned up
     const after = readAllSessionStatuses(basePath);
-    assert.deepStrictEqual(after.length, 1, "orphan: dead session cleaned up");
-    assert.deepStrictEqual(after[0].milestoneId, "M002", "orphan: alive session remains");
+    assertEq(after.length, 1, "orphan: dead session cleaned up");
+    assertEq(after[0].milestoneId, "M002", "orphan: alive session remains");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-});
+}
 
-test('Test 7: restoreState handles corrupt JSON gracefully', () => {
+// Test 7: restoreState handles corrupt JSON gracefully
+{
   const basePath = makeTempDir();
   try {
     writeFileSync(stateFilePath(basePath), "{ not valid json !!!", "utf-8");
     const result = restoreState(basePath);
-    assert.deepStrictEqual(result, null, "restoreState: returns null for corrupt JSON");
+    assertEq(result, null, "restoreState: returns null for corrupt JSON");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-});
+}
 
 // Clean up module state
 resetOrchestrator();
 
-});
+report();

package/src/resources/extensions/gsd/tests/parallel-worker-monitoring.test.ts

@@ -10,11 +10,12 @@
  *   6. completedUnits counter increments on assistant message_end
  */
 
-import assert from 'node:assert/strict';
 import { describe, it, after } from "node:test";
 import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { createTestContext } from "./test-helpers.ts";
+
 // We test processWorkerLine indirectly via the module's exported state.
 // To test the internal function, we use the exported accessors.
 import {
@@ -26,6 +27,8 @@ import {
   refreshWorkerStatuses,
 } from "../parallel-orchestrator.ts";
 
+const { assertEq, assertTrue, report } = createTestContext();
+
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
 /** Create a minimal message_end NDJSON line with cost data. */
@@ -49,7 +52,7 @@ function makeMessageEndLine(cost: number, role = "assistant"): string {
 describe("parallel-worker-monitoring", () => {
   after(() => {
     resetOrchestrator();
-
+    report();
   });
 
   // Note: processWorkerLine is not exported, so we test the observable effects
@@ -58,39 +61,39 @@ describe("parallel-worker-monitoring", () => {
 
   it("isBudgetExceeded returns false when no state exists", () => {
     resetOrchestrator();
-    assert.ok(!isBudgetExceeded(), "no state = not exceeded");
+    assertTrue(!isBudgetExceeded(), "no state = not exceeded");
   });
 
   it("isBudgetExceeded returns false when no ceiling configured", () => {
     resetOrchestrator();
     // Can't directly set state without startParallel, so test the accessor
-    assert.ok(!isBudgetExceeded(), "no ceiling = not exceeded");
+    assertTrue(!isBudgetExceeded(), "no ceiling = not exceeded");
   });
 
   it("getAggregateCost returns 0 when no state exists", () => {
     resetOrchestrator();
-    assert.deepStrictEqual(getAggregateCost(), 0, "no state = zero cost");
+    assertEq(getAggregateCost(), 0, "no state = zero cost");
   });
 
   it("isParallelActive returns false after reset", () => {
     resetOrchestrator();
-    assert.ok(!isParallelActive(), "reset = not active");
+    assertTrue(!isParallelActive(), "reset = not active");
   });
 
   it("getWorkerStatuses returns empty array when no state", () => {
     resetOrchestrator();
-    assert.deepStrictEqual(getWorkerStatuses().length, 0, "no state = empty workers");
+    assertEq(getWorkerStatuses().length, 0, "no state = empty workers");
   });
 
   it("NDJSON message_end format matches expected structure", () => {
     // Verify the NDJSON line format we expect from workers
     const line = makeMessageEndLine(0.05);
     const parsed = JSON.parse(line);
-    assert.deepStrictEqual(parsed.type, "message_end", "type is message_end");
-    assert.deepStrictEqual(parsed.message.role, "assistant", "role is assistant");
-    assert.deepStrictEqual(parsed.message.usage.cost.total, 0.05, "cost.total is 0.05");
-    assert.ok(typeof parsed.message.usage.input === "number", "input is number");
-    assert.ok(typeof parsed.message.usage.output === "number", "output is number");
+    assertEq(parsed.type, "message_end", "type is message_end");
+    assertEq(parsed.message.role, "assistant", "role is assistant");
+    assertEq(parsed.message.usage.cost.total, 0.05, "cost.total is 0.05");
+    assertTrue(typeof parsed.message.usage.input === "number", "input is number");
+    assertTrue(typeof parsed.message.usage.output === "number", "output is number");
   });
 
   it("malformed JSON does not throw (tested via parse safety)", () => {
@@ -108,7 +111,7 @@ describe("parallel-worker-monitoring", () => {
         JSON.parse(line);
       } catch {
         // Expected — processWorkerLine catches this silently
-        assert.ok(true, `malformed line "${line.slice(0, 20)}" handled`);
+        assertTrue(true, `malformed line "${line.slice(0, 20)}" handled`);
       }
     }
   });
@@ -119,25 +122,25 @@ describe("parallel-worker-monitoring", () => {
     let total = 0;
     for (const c of costs) total += c;
     // Floating point: round to 2 decimal places for comparison
-    assert.deepStrictEqual(Math.round(total * 100) / 100, 0.28, "cost sum is correct");
+    assertEq(Math.round(total * 100) / 100, 0.28, "cost sum is correct");
   });
 
   it("budget ceiling comparison works with typical values", () => {
     // Test the ceiling check pattern
     const ceiling = 5.0;
-    assert.ok(0 < ceiling, "0 is under ceiling");
-    assert.ok(4.99 < ceiling, "4.99 is under ceiling");
-    assert.ok(!(5.0 < ceiling), "5.0 is at ceiling");
-    assert.ok(!(5.01 < ceiling), "5.01 is over ceiling");
+    assertTrue(0 < ceiling, "0 is under ceiling");
+    assertTrue(4.99 < ceiling, "4.99 is under ceiling");
+    assertTrue(!(5.0 < ceiling), "5.0 is at ceiling");
+    assertTrue(!(5.01 < ceiling), "5.01 is over ceiling");
   });
 
   it("worker spawn args include --mode json", () => {
     // Verify the spawn command includes JSON mode for NDJSON output.
     // We can't easily test the actual spawn, but we verify the args pattern.
     const expectedArgs = ["--mode", "json", "--print", "/gsd auto"];
-    assert.ok(expectedArgs.includes("--mode"), "args include --mode");
-    assert.ok(expectedArgs.includes("json"), "args include json");
-    assert.ok(expectedArgs.indexOf("--mode") < expectedArgs.indexOf("json"),
+    assertTrue(expectedArgs.includes("--mode"), "args include --mode");
+    assertTrue(expectedArgs.includes("json"), "args include json");
+    assertTrue(expectedArgs.indexOf("--mode") < expectedArgs.indexOf("json"),
       "--mode comes before json");
   });
 
@@ -165,8 +168,8 @@ describe("parallel-worker-monitoring", () => {
       }, null, 2));
       refreshWorkerStatuses(base, { restoreIfNeeded: true });
       const workers = getWorkerStatuses();
-      assert.deepStrictEqual(workers.length, 1, "restored one worker");
-      assert.deepStrictEqual(workers[0].milestoneId, "M001", "worker restored from persisted state");
+      assertEq(workers.length, 1, "restored one worker");
+      assertEq(workers[0].milestoneId, "M001", "worker restored from persisted state");
     } finally {
       resetOrchestrator();
       rmSync(base, { recursive: true, force: true });
@@ -190,8 +193,8 @@ describe("parallel-worker-monitoring", () => {
       }, null, 2));
       refreshWorkerStatuses(base, { restoreIfNeeded: true });
       const workers = getWorkerStatuses();
-      assert.deepStrictEqual(workers[0].state, "running", "live session status restored");
-      assert.deepStrictEqual(workers[0].completedUnits, 3, "completed units restored from status file");
+      assertEq(workers[0].state, "running", "live session status restored");
+      assertEq(workers[0].completedUnits, 3, "completed units restored from status file");
     } finally {
       resetOrchestrator();
       rmSync(base, { recursive: true, force: true });