gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -1,15 +1,14 @@
 // 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 {
@@ -26,106 +25,100 @@ function cleanup(): void {
   tempDirs.length = 0;
 }
 
-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();
+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");
+  });
+});

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

@@ -5,6 +5,8 @@
  * restored after a coordinator crash, with PID liveness filtering.
  */
 
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
 import {
   mkdtempSync,
   mkdirSync,
@@ -24,10 +26,6 @@ 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 {
@@ -57,8 +55,9 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
 // ─── Tests ────────────────────────────────────────────────────────────────────
 
-// Test 1: persistState writes valid JSON
-{
+
+describe('parallel-crash-recovery', () => {
+test('Test 1: persistState writes valid JSON', () => {
   const basePath = makeTempDir();
   try {
     // We can't call persistState directly without internal state set up,
@@ -82,29 +81,27 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
     const raw = readFileSync(stateFilePath(basePath), "utf-8");
     const parsed = JSON.parse(raw) as PersistedState;
-    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");
+    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");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 2: restoreState returns null for missing file
-{
+test('Test 2: restoreState returns null for missing file', () => {
   const basePath = makeTempDir();
   try {
     const result = restoreState(basePath);
-    assertEq(result, null, "restoreState: returns null when no state file");
+    assert.deepStrictEqual(result, null, "restoreState: returns null when no state file");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 3: restoreState filters dead PIDs
-{
+test('Test 3: restoreState filters dead PIDs', () => {
   const basePath = makeTempDir();
   try {
     // PID 99999999 is almost certainly not alive
@@ -136,15 +133,14 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
     const result = restoreState(basePath);
     // Both PIDs are dead, so result should be null and file should be cleaned up
-    assertEq(result, null, "restoreState: returns null when all PIDs dead");
-    assertTrue(!existsSync(stateFilePath(basePath)), "restoreState: cleans up state file when all dead");
+    assert.deepStrictEqual(result, null, "restoreState: returns null when all PIDs dead");
+    assert.ok(!existsSync(stateFilePath(basePath)), "restoreState: cleans up state file when all dead");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 4: restoreState keeps alive PIDs
-{
+test('Test 4: restoreState keeps alive PIDs', () => {
   const basePath = makeTempDir();
   try {
     // Use current process PID (definitely alive)
@@ -176,18 +172,17 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
     writeStateFile(basePath, state);
 
     const result = restoreState(basePath);
-    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");
+    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");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 5: restoreState skips stopped/error workers even with alive PIDs
-{
+test('Test 5: restoreState skips stopped/error workers even with alive PIDs', () => {
   const basePath = makeTempDir();
   try {
     const state = makePersistedState({
@@ -207,14 +202,13 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
     writeStateFile(basePath, state);
 
     const result = restoreState(basePath);
-    assertEq(result, null, "restoreState: skips stopped workers");
+    assert.deepStrictEqual(result, null, "restoreState: skips stopped workers");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 6: orphan detection finds stale sessions
-{
+test('Test 6: orphan detection finds stale sessions', () => {
   const basePath = makeTempDir();
   try {
     // Write a session status with a dead PID
@@ -246,7 +240,7 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
 
     // Read all sessions — both should exist initially
     const before = readAllSessionStatuses(basePath);
-    assertEq(before.length, 2, "orphan: both sessions exist before detection");
+    assert.deepStrictEqual(before.length, 2, "orphan: both sessions exist before detection");
 
     // Now simulate orphan detection logic (same as prepareParallelStart)
     const sessions = readAllSessionStatuses(basePath);
@@ -265,34 +259,33 @@ function makePersistedState(overrides: Partial<PersistedState> = {}): PersistedS
       }
     }
 
-    assertTrue(orphans.length === 2, "orphan: detected both sessions");
+    assert.ok(orphans.length === 2, "orphan: detected both sessions");
     const deadOrphan = orphans.find(o => o.milestoneId === "M001");
-    assertTrue(deadOrphan !== undefined && !deadOrphan.alive, "orphan: M001 detected as dead");
+    assert.ok(deadOrphan !== undefined && !deadOrphan.alive, "orphan: M001 detected as dead");
     const aliveOrphan = orphans.find(o => o.milestoneId === "M002");
-    assertTrue(aliveOrphan !== undefined && aliveOrphan.alive, "orphan: M002 detected as alive");
+    assert.ok(aliveOrphan !== undefined && aliveOrphan.alive, "orphan: M002 detected as alive");
 
     // Dead session should be cleaned up
     const after = readAllSessionStatuses(basePath);
-    assertEq(after.length, 1, "orphan: dead session cleaned up");
-    assertEq(after[0].milestoneId, "M002", "orphan: alive session remains");
+    assert.deepStrictEqual(after.length, 1, "orphan: dead session cleaned up");
+    assert.deepStrictEqual(after[0].milestoneId, "M002", "orphan: alive session remains");
   } finally {
     rmSync(basePath, { recursive: true, force: true });
   }
-}
+});
 
-// Test 7: restoreState handles corrupt JSON gracefully
-{
+test('Test 7: restoreState handles corrupt JSON gracefully', () => {
   const basePath = makeTempDir();
   try {
     writeFileSync(stateFilePath(basePath), "{ not valid json !!!", "utf-8");
     const result = restoreState(basePath);
-    assertEq(result, null, "restoreState: returns null for corrupt JSON");
+    assert.deepStrictEqual(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,12 +10,11 @@
  *   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 {
@@ -27,8 +26,6 @@ import {
   refreshWorkerStatuses,
 } from "../parallel-orchestrator.ts";
 
-const { assertEq, assertTrue, report } = createTestContext();
-
 // ─── Helpers ──────────────────────────────────────────────────────────────
 
 /** Create a minimal message_end NDJSON line with cost data. */
@@ -52,7 +49,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
@@ -61,39 +58,39 @@ describe("parallel-worker-monitoring", () => {
 
   it("isBudgetExceeded returns false when no state exists", () => {
     resetOrchestrator();
-    assertTrue(!isBudgetExceeded(), "no state = not exceeded");
+    assert.ok(!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
-    assertTrue(!isBudgetExceeded(), "no ceiling = not exceeded");
+    assert.ok(!isBudgetExceeded(), "no ceiling = not exceeded");
   });
 
   it("getAggregateCost returns 0 when no state exists", () => {
     resetOrchestrator();
-    assertEq(getAggregateCost(), 0, "no state = zero cost");
+    assert.deepStrictEqual(getAggregateCost(), 0, "no state = zero cost");
   });
 
   it("isParallelActive returns false after reset", () => {
     resetOrchestrator();
-    assertTrue(!isParallelActive(), "reset = not active");
+    assert.ok(!isParallelActive(), "reset = not active");
   });
 
   it("getWorkerStatuses returns empty array when no state", () => {
     resetOrchestrator();
-    assertEq(getWorkerStatuses().length, 0, "no state = empty workers");
+    assert.deepStrictEqual(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);
-    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");
+    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");
   });
 
   it("malformed JSON does not throw (tested via parse safety)", () => {
@@ -111,7 +108,7 @@ describe("parallel-worker-monitoring", () => {
         JSON.parse(line);
       } catch {
         // Expected — processWorkerLine catches this silently
-        assertTrue(true, `malformed line "${line.slice(0, 20)}" handled`);
+        assert.ok(true, `malformed line "${line.slice(0, 20)}" handled`);
       }
     }
   });
@@ -122,25 +119,25 @@ describe("parallel-worker-monitoring", () => {
     let total = 0;
     for (const c of costs) total += c;
     // Floating point: round to 2 decimal places for comparison
-    assertEq(Math.round(total * 100) / 100, 0.28, "cost sum is correct");
+    assert.deepStrictEqual(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;
-    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");
+    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");
   });
 
   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"];
-    assertTrue(expectedArgs.includes("--mode"), "args include --mode");
-    assertTrue(expectedArgs.includes("json"), "args include json");
-    assertTrue(expectedArgs.indexOf("--mode") < expectedArgs.indexOf("json"),
+    assert.ok(expectedArgs.includes("--mode"), "args include --mode");
+    assert.ok(expectedArgs.includes("json"), "args include json");
+    assert.ok(expectedArgs.indexOf("--mode") < expectedArgs.indexOf("json"),
       "--mode comes before json");
   });
 
@@ -168,8 +165,8 @@ describe("parallel-worker-monitoring", () => {
       }, null, 2));
       refreshWorkerStatuses(base, { restoreIfNeeded: true });
       const workers = getWorkerStatuses();
-      assertEq(workers.length, 1, "restored one worker");
-      assertEq(workers[0].milestoneId, "M001", "worker restored from persisted state");
+      assert.deepStrictEqual(workers.length, 1, "restored one worker");
+      assert.deepStrictEqual(workers[0].milestoneId, "M001", "worker restored from persisted state");
     } finally {
       resetOrchestrator();
       rmSync(base, { recursive: true, force: true });
@@ -193,8 +190,8 @@ describe("parallel-worker-monitoring", () => {
       }, null, 2));
       refreshWorkerStatuses(base, { restoreIfNeeded: true });
       const workers = getWorkerStatuses();
-      assertEq(workers[0].state, "running", "live session status restored");
-      assertEq(workers[0].completedUnits, 3, "completed units restored from status file");
+      assert.deepStrictEqual(workers[0].state, "running", "live session status restored");
+      assert.deepStrictEqual(workers[0].completedUnits, 3, "completed units restored from status file");
     } finally {
       resetOrchestrator();
       rmSync(base, { recursive: true, force: true });