gsd-pi 2.44.0-dev.848dd4c → 2.44.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 (t) => {
+    it("AutoUnitRuntimeRecord includes continueHereFired with default false", async () => {
       // 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,83 +171,87 @@ describe("continue-here", () => {
 
       // Use a temp directory as basePath
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "continue-here-test-"));
-      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");
+      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 });
+      }
     });
   });
 
   describe("context-pressure monitor integration", () => {
-    it("should fire wrap-up when context >= threshold and mark continueHereFired", async (t) => {
+    it("should fire wrap-up when context >= threshold and mark continueHereFired", async () => {
       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-"));
-      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");
+      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 });
+      }
     });
 
     it("should not fire when context is below threshold", () => {

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

@@ -7,12 +7,11 @@
  * 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 ─────────────────────────────────────────────────────────────
 
@@ -26,95 +25,110 @@ function makeSliceAggregate(sliceId: string, cost: number): SliceAggregate {
   };
 }
 
+const { assertEq, assertTrue, report } = createTestContext();
 // ─── formatCostProjection ─────────────────────────────────────────────────────
 
-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)"
-    );
-  });
-});
+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();

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

@@ -26,45 +26,53 @@ function cleanup(base: string): void {
 
 // ─── writeLock / readCrashLock ────────────────────────────────────────────
 
-test("writeLock creates lock file and readCrashLock reads it", (t) => {
+test("writeLock creates lock file and readCrashLock reads it", () => {
   const base = makeTmpBase();
-  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);
+  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);
+  }
 });
 
-test("readCrashLock returns null when no lock exists", (t) => {
+test("readCrashLock returns null when no lock exists", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  const lock = readCrashLock(base);
-  assert.equal(lock, null);
+  try {
+    const lock = readCrashLock(base);
+    assert.equal(lock, null);
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── clearLock ────────────────────────────────────────────────────────────
 
-test("clearLock removes existing lock file", (t) => {
+test("clearLock removes existing lock file", () => {
   const base = makeTmpBase();
-  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");
+  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);
+  }
 });
 
-test("clearLock is safe when no lock exists", (t) => {
+test("clearLock is safe when no lock exists", () => {
   const base = makeTmpBase();
-  t.after(() => cleanup(base));
-
-  assert.doesNotThrow(() => clearLock(base));
+  try {
+    assert.doesNotThrow(() => clearLock(base));
+  } finally {
+    cleanup(base);
+  }
 });
 
 // ─── isLockProcessAlive ──────────────────────────────────────────────────