gsd-pi 2.44.0 → 2.45.0

package/src/resources/extensions/gsd/tests/continue-here.test.ts

@@ -162,7 +162,7 @@ describe("continue-here", () => {
   });
 
   describe("continueHereFired runtime record field", () => {
-    it("AutoUnitRuntimeRecord includes continueHereFired with default false", async () => {
+    it("AutoUnitRuntimeRecord includes continueHereFired with default false", async (t) => {
       // Import writeUnitRuntimeRecord to verify the field is present and defaults
       const { writeUnitRuntimeRecord, readUnitRuntimeRecord, clearUnitRuntimeRecord } = await import("../unit-runtime.js");
       const fs = await import("node:fs");
@@ -171,87 +171,83 @@ describe("continue-here", () => {
 
       // Use a temp directory as basePath
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "continue-here-test-"));
-      try {
-        const record = writeUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02", Date.now(), {
-          phase: "dispatched",
-          wrapupWarningSent: false,
-        });
-
-        assert.equal(record.continueHereFired, false, "default continueHereFired should be false");
-
-        // Verify it persists to disk
-        const read = readUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02");
-        assert.ok(read, "record should be readable");
-        assert.equal(read!.continueHereFired, false);
-
-        // Update to true
-        const updated = writeUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02", Date.now(), {
-          continueHereFired: true,
-        });
-        assert.equal(updated.continueHereFired, true, "updated continueHereFired should be true");
-
-        // Verify persistence
-        const readUpdated = readUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02");
-        assert.equal(readUpdated!.continueHereFired, true, "persisted continueHereFired should be true");
-
-        // Clean up
-        clearUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02");
-      } finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      }
+      t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+      const record = writeUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02", Date.now(), {
+        phase: "dispatched",
+        wrapupWarningSent: false,
+      });
+
+      assert.equal(record.continueHereFired, false, "default continueHereFired should be false");
+
+      // Verify it persists to disk
+      const read = readUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02");
+      assert.ok(read, "record should be readable");
+      assert.equal(read!.continueHereFired, false);
+
+      // Update to true
+      const updated = writeUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02", Date.now(), {
+        continueHereFired: true,
+      });
+      assert.equal(updated.continueHereFired, true, "updated continueHereFired should be true");
+
+      // Verify persistence
+      const readUpdated = readUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02");
+      assert.equal(readUpdated!.continueHereFired, true, "persisted continueHereFired should be true");
+
+      // Clean up
+      clearUnitRuntimeRecord(tmpDir, "execute-task", "M007/S02/T02");
     });
   });
 
   describe("context-pressure monitor integration", () => {
-    it("should fire wrap-up when context >= threshold and mark continueHereFired", async () => {
+    it("should fire wrap-up when context >= threshold and mark continueHereFired", async (t) => {
       const { writeUnitRuntimeRecord, readUnitRuntimeRecord, clearUnitRuntimeRecord } = await import("../unit-runtime.js");
       const fs = await import("node:fs");
       const path = await import("node:path");
       const os = await import("node:os");
 
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "continue-here-monitor-"));
-      try {
-        // Simulate the monitor's one-shot logic:
-        // 1. Write initial runtime record (continueHereFired=false)
-        const startedAt = Date.now();
-        writeUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01", startedAt, {
-          phase: "dispatched",
-          wrapupWarningSent: false,
-        });
-
-        const budget = computeBudgets(128_000);
-        const threshold = budget.continueThresholdPercent;
-
-        // Simulate the monitor poll: context at 75% (above threshold)
-        const contextPercent = 75;
-        const runtime = readUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01");
-        assert.ok(runtime, "runtime record should exist");
-        assert.equal(runtime!.continueHereFired, false, "initially false");
-
-        // Check: should fire
-        const shouldFire = !runtime!.continueHereFired
-          && contextPercent >= threshold;
-        assert.ok(shouldFire, "should fire when context >= threshold and not yet fired");
-
-        // Mark as fired (what the monitor does)
-        writeUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01", startedAt, {
-          continueHereFired: true,
-        });
-
-        // Verify one-shot: second poll should NOT fire
-        const runtime2 = readUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01");
-        assert.ok(runtime2, "runtime record should still exist");
-        assert.equal(runtime2!.continueHereFired, true, "should be marked as fired");
-
-        const shouldFireAgain = !runtime2!.continueHereFired
-          && contextPercent >= threshold;
-        assert.equal(shouldFireAgain, false, "must not fire again — one-shot guard");
-
-        // Clean up
-        clearUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01");
-      } finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-      }
+      t.after(() => fs.rmSync(tmpDir, { recursive: true, force: true }));
+
+      // Simulate the monitor's one-shot logic:
+      // 1. Write initial runtime record (continueHereFired=false)
+      const startedAt = Date.now();
+      writeUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01", startedAt, {
+        phase: "dispatched",
+        wrapupWarningSent: false,
+      });
+
+      const budget = computeBudgets(128_000);
+      const threshold = budget.continueThresholdPercent;
+
+      // Simulate the monitor poll: context at 75% (above threshold)
+      const contextPercent = 75;
+      const runtime = readUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01");
+      assert.ok(runtime, "runtime record should exist");
+      assert.equal(runtime!.continueHereFired, false, "initially false");
+
+      // Check: should fire
+      const shouldFire = !runtime!.continueHereFired
+        && contextPercent >= threshold;
+      assert.ok(shouldFire, "should fire when context >= threshold and not yet fired");
+
+      // Mark as fired (what the monitor does)
+      writeUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01", startedAt, {
+        continueHereFired: true,
+      });
+
+      // Verify one-shot: second poll should NOT fire
+      const runtime2 = readUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01");
+      assert.ok(runtime2, "runtime record should still exist");
+      assert.equal(runtime2!.continueHereFired, true, "should be marked as fired");
+
+      const shouldFireAgain = !runtime2!.continueHereFired
+        && contextPercent >= threshold;
+      assert.equal(shouldFireAgain, false, "must not fire again — one-shot guard");
+
+      // Clean up
+      clearUnitRuntimeRecord(tmpDir, "execute-task", "M001/S01/T01");
     });
 
     it("should not fire when context is below threshold", () => {

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

@@ -7,11 +7,12 @@
  * That failure confirms the test runs against real code. (T01 state)
  */
 
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
 import {
   type SliceAggregate,
   formatCostProjection,
 } from "../metrics.js";
-import { createTestContext } from './test-helpers.ts';
 
 // ─── Test helpers ─────────────────────────────────────────────────────────────
 
@@ -25,110 +26,95 @@ function makeSliceAggregate(sliceId: string, cost: number): SliceAggregate {
   };
 }
 
-const { assertEq, assertTrue, report } = createTestContext();
 // ─── formatCostProjection ─────────────────────────────────────────────────────
 
-console.log("\n=== formatCostProjection ===");
-
-// 1. Zero completed slices → empty result
-{
-  const result = formatCostProjection([], 3);
-  assertEq(result.length, 0, "zero slices → empty array");
-}
-
-// 2. One slice → suppressed (need ≥2 to project reliably)
-{
-  const result = formatCostProjection([makeSliceAggregate("M001/S01", 0.10)], 3);
-  assertEq(result.length, 0, "one slice → suppressed (no projection shown)");
-}
-
-// 3. Two slices → projection shown (result.length > 0)
-{
-  const slices = [
-    makeSliceAggregate("M001/S01", 0.10),
-    makeSliceAggregate("M001/S02", 0.10),
-  ];
-  const result = formatCostProjection(slices, 5);
-  assertTrue(result.length > 0, "two slices → projection shown");
-}
-
-// 4. Two-slice result: result[0] contains "$" (cost is formatted)
-{
-  const slices = [
-    makeSliceAggregate("M001/S01", 0.10),
-    makeSliceAggregate("M001/S02", 0.10),
-  ];
-  const result = formatCostProjection(slices, 5);
-  assertTrue(result.length > 0 && result[0].includes("$"), "projection line contains \"$\"");
-}
-
-// 5. Budget ceiling hit: total $0.20 >= ceiling $0.05 → line contains "ceiling"
-{
-  const slices = [
-    makeSliceAggregate("M001/S01", 0.10),
-    makeSliceAggregate("M001/S02", 0.10),
-  ];
-  const result = formatCostProjection(slices, 5, 0.05);
-  const hasCeilingLine = result.some(
-    line => line.toLowerCase().includes("ceiling")
-  );
-  assertTrue(hasCeilingLine, "ceiling warning appears when total ($0.20) >= ceiling ($0.05)");
-}
-
-// 6. Budget ceiling not hit: total $0.20 < ceiling $100.00 → no ceiling line
-{
-  const slices = [
-    makeSliceAggregate("M001/S01", 0.10),
-    makeSliceAggregate("M001/S02", 0.10),
-  ];
-  const result = formatCostProjection(slices, 5, 100.00);
-  const hasCeilingLine = result.some(
-    line => line.toLowerCase().includes("ceiling")
-  );
-  assertTrue(!hasCeilingLine, "no ceiling warning when total ($0.20) < ceiling ($100.00)");
-}
-
-// 7. No ceiling arg → no ceiling line
-{
-  const slices = [
-    makeSliceAggregate("M001/S01", 0.10),
-    makeSliceAggregate("M001/S02", 0.10),
-  ];
-  const result = formatCostProjection(slices, 5);
-  const hasCeilingLine = result.some(
-    line => line.toLowerCase().includes("ceiling")
-  );
-  assertTrue(!hasCeilingLine, "no ceiling warning when no ceiling is set");
-}
-
-// 8. Rounding: avg $0.10 × 5 remaining = $0.50 → result[0] contains "$0.50"
-{
-  const slices = [
-    makeSliceAggregate("M001/S01", 0.10),
-    makeSliceAggregate("M001/S02", 0.10),
-  ];
-  const result = formatCostProjection(slices, 5);
-  const hasRoundedCost = result.some(line => line.includes("$0.50"));
-  assertTrue(hasRoundedCost, "projected cost $0.50 (avg $0.10 × 5 remaining) appears in output");
-}
-
-// 9. Bare milestone entries excluded from average:
-//    makeSliceAggregate('M001', 5.00) has no "/" in sliceId → excluded from avg calc.
-//    Only M001/S01 ($0.10) and M001/S02 ($0.10) count → avg $0.10 × 3 remaining = $0.30
-{
-  const slices = [
-    makeSliceAggregate("M001", 5.00),        // bare milestone — must be excluded
-    makeSliceAggregate("M001/S01", 0.10),
-    makeSliceAggregate("M001/S02", 0.10),
-  ];
-  const result = formatCostProjection(slices, 3);
-  const hasCorrectProjection = result.some(line => line.includes("$0.30"));
-  assertTrue(
-    hasCorrectProjection,
-    "bare milestone entry excluded from avg: projection shows $0.30 (avg $0.10 × 3), not $1.83 (including $5.00 entry)"
-  );
-}
-
-// ─── Summary ──────────────────────────────────────────────────────────────────
-
-report();
+describe("formatCostProjection", () => {
+
+  test("zero completed slices → empty result", () => {
+    const result = formatCostProjection([], 3);
+    assert.strictEqual(result.length, 0, "zero slices → empty array");
+  });
+
+  test("one slice → suppressed (need ≥2 to project reliably)", () => {
+    const result = formatCostProjection([makeSliceAggregate("M001/S01", 0.10)], 3);
+    assert.strictEqual(result.length, 0, "one slice → suppressed (no projection shown)");
+  });
+
+  test("two slices → projection shown", () => {
+    const slices = [
+      makeSliceAggregate("M001/S01", 0.10),
+      makeSliceAggregate("M001/S02", 0.10),
+    ];
+    const result = formatCostProjection(slices, 5);
+    assert.ok(result.length > 0, "two slices → projection shown");
+  });
+
+  test("two-slice result contains $ (cost is formatted)", () => {
+    const slices = [
+      makeSliceAggregate("M001/S01", 0.10),
+      makeSliceAggregate("M001/S02", 0.10),
+    ];
+    const result = formatCostProjection(slices, 5);
+    assert.ok(result.length > 0 && result[0].includes("$"), "projection line contains \"$\"");
+  });
+
+  test("budget ceiling hit: total >= ceiling → line contains ceiling", () => {
+    const slices = [
+      makeSliceAggregate("M001/S01", 0.10),
+      makeSliceAggregate("M001/S02", 0.10),
+    ];
+    const result = formatCostProjection(slices, 5, 0.05);
+    const hasCeilingLine = result.some(
+      line => line.toLowerCase().includes("ceiling")
+    );
+    assert.ok(hasCeilingLine, "ceiling warning appears when total ($0.20) >= ceiling ($0.05)");
+  });
+
+  test("budget ceiling not hit: total < ceiling → no ceiling line", () => {
+    const slices = [
+      makeSliceAggregate("M001/S01", 0.10),
+      makeSliceAggregate("M001/S02", 0.10),
+    ];
+    const result = formatCostProjection(slices, 5, 100.00);
+    const hasCeilingLine = result.some(
+      line => line.toLowerCase().includes("ceiling")
+    );
+    assert.ok(!hasCeilingLine, "no ceiling warning when total ($0.20) < ceiling ($100.00)");
+  });
+
+  test("no ceiling arg → no ceiling line", () => {
+    const slices = [
+      makeSliceAggregate("M001/S01", 0.10),
+      makeSliceAggregate("M001/S02", 0.10),
+    ];
+    const result = formatCostProjection(slices, 5);
+    const hasCeilingLine = result.some(
+      line => line.toLowerCase().includes("ceiling")
+    );
+    assert.ok(!hasCeilingLine, "no ceiling warning when no ceiling is set");
+  });
+
+  test("rounding: avg $0.10 × 5 remaining = $0.50", () => {
+    const slices = [
+      makeSliceAggregate("M001/S01", 0.10),
+      makeSliceAggregate("M001/S02", 0.10),
+    ];
+    const result = formatCostProjection(slices, 5);
+    const hasRoundedCost = result.some(line => line.includes("$0.50"));
+    assert.ok(hasRoundedCost, "projected cost $0.50 (avg $0.10 × 5 remaining) appears in output");
+  });
+
+  test("bare milestone entries excluded from average", () => {
+    const slices = [
+      makeSliceAggregate("M001", 5.00),        // bare milestone — must be excluded
+      makeSliceAggregate("M001/S01", 0.10),
+      makeSliceAggregate("M001/S02", 0.10),
+    ];
+    const result = formatCostProjection(slices, 3);
+    const hasCorrectProjection = result.some(line => line.includes("$0.30"));
+    assert.ok(
+      hasCorrectProjection,
+      "bare milestone entry excluded from avg: projection shows $0.30 (avg $0.10 × 3), not $1.83 (including $5.00 entry)"
+    );
+  });
+});

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

@@ -26,53 +26,45 @@ function cleanup(base: string): void {
 
 // ─── writeLock / readCrashLock ────────────────────────────────────────────
 
-test("writeLock creates lock file and readCrashLock reads it", () => {
+test("writeLock creates lock file and readCrashLock reads it", (t) => {
   const base = makeTmpBase();
-  try {
-    writeLock(base, "execute-task", "M001/S01/T01", 3, "/tmp/session.jsonl");
-    const lock = readCrashLock(base);
-    assert.ok(lock, "lock should exist");
-    assert.equal(lock!.unitType, "execute-task");
-    assert.equal(lock!.unitId, "M001/S01/T01");
-    assert.equal(lock!.completedUnits, 3);
-    assert.equal(lock!.sessionFile, "/tmp/session.jsonl");
-    assert.equal(lock!.pid, process.pid);
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  writeLock(base, "execute-task", "M001/S01/T01", 3, "/tmp/session.jsonl");
+  const lock = readCrashLock(base);
+  assert.ok(lock, "lock should exist");
+  assert.equal(lock!.unitType, "execute-task");
+  assert.equal(lock!.unitId, "M001/S01/T01");
+  assert.equal(lock!.completedUnits, 3);
+  assert.equal(lock!.sessionFile, "/tmp/session.jsonl");
+  assert.equal(lock!.pid, process.pid);
 });
 
-test("readCrashLock returns null when no lock exists", () => {
+test("readCrashLock returns null when no lock exists", (t) => {
   const base = makeTmpBase();
-  try {
-    const lock = readCrashLock(base);
-    assert.equal(lock, null);
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  const lock = readCrashLock(base);
+  assert.equal(lock, null);
 });
 
 // ─── clearLock ────────────────────────────────────────────────────────────
 
-test("clearLock removes existing lock file", () => {
+test("clearLock removes existing lock file", (t) => {
   const base = makeTmpBase();
-  try {
-    writeLock(base, "plan-slice", "M001/S01", 0);
-    assert.ok(readCrashLock(base), "lock should exist before clear");
-    clearLock(base);
-    assert.equal(readCrashLock(base), null, "lock should be gone after clear");
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  writeLock(base, "plan-slice", "M001/S01", 0);
+  assert.ok(readCrashLock(base), "lock should exist before clear");
+  clearLock(base);
+  assert.equal(readCrashLock(base), null, "lock should be gone after clear");
 });
 
-test("clearLock is safe when no lock exists", () => {
+test("clearLock is safe when no lock exists", (t) => {
   const base = makeTmpBase();
-  try {
-    assert.doesNotThrow(() => clearLock(base));
-  } finally {
-    cleanup(base);
-  }
+  t.after(() => cleanup(base));
+
+  assert.doesNotThrow(() => clearLock(base));
 });
 
 // ─── isLockProcessAlive ──────────────────────────────────────────────────