gsd-pi 2.33.1 → 2.34.0-dev.bbb5216

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

@@ -1,285 +0,0 @@
-/**
- * Tests for the continue-here context-pressure monitor.
- *
- * Verifies:
- * - Threshold comparison: fires when percent >= continueThresholdPercent
- * - Null/undefined safety: no fire on missing or null context usage
- * - One-shot guard: fires exactly once even if percent stays high
- * - Cleanup: interval is cleared after fire and in clearUnitTimeout()
- * - End-to-end pipeline: different model sizes produce correct budgets
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-
-import { computeBudgets } from "../context-budget.js";
-
-// ─── Pure threshold / pipeline tests ──────────────────────────────────────────
-// These test the budget engine outputs that the continue-here monitor relies on.
-
-describe("continue-here", () => {
-  describe("threshold comparison", () => {
-    it("fires when percent >= continueThresholdPercent (70%)", () => {
-      const budget = computeBudgets(128_000);
-      const threshold = budget.continueThresholdPercent;
-      assert.equal(threshold, 70);
-
-      // Simulate check: 70% should fire
-      assert.ok(70 >= threshold, "exactly at threshold should fire");
-      // 71% should fire
-      assert.ok(71 >= threshold, "above threshold should fire");
-      // 100% should fire
-      assert.ok(100 >= threshold, "at maximum should fire");
-    });
-
-    it("does not fire below continueThresholdPercent", () => {
-      const budget = computeBudgets(128_000);
-      const threshold = budget.continueThresholdPercent;
-
-      // 69% should not fire
-      assert.ok(69 < threshold, "below threshold should not fire");
-      // 0% should not fire
-      assert.ok(0 < threshold, "zero usage should not fire");
-      // 50% should not fire
-      assert.ok(50 < threshold, "half usage should not fire");
-    });
-  });
-
-  describe("null/undefined safety", () => {
-    it("no fire when getContextUsage returns undefined", () => {
-      const budget = computeBudgets(128_000);
-      const threshold = budget.continueThresholdPercent;
-
-      // Simulate the guard: usage is undefined → skip
-      const usage = undefined as { percent: number | null } | undefined;
-      const shouldFire = usage != null && usage.percent != null && usage.percent >= threshold;
-      assert.equal(shouldFire, false, "undefined usage must not fire");
-    });
-
-    it("no fire when percent is null", () => {
-      const budget = computeBudgets(128_000);
-      const threshold = budget.continueThresholdPercent;
-
-      // Simulate the guard: percent is null → skip
-      const usage: { percent: number | null } | undefined = { percent: null };
-      const shouldFire = usage != null && usage.percent != null && usage.percent >= threshold;
-      assert.equal(shouldFire, false, "null percent must not fire");
-    });
-  });
-
-  describe("one-shot guard", () => {
-    it("fires exactly once even when percent stays above threshold", () => {
-      const budget = computeBudgets(128_000);
-      const threshold = budget.continueThresholdPercent;
-
-      // Simulate repeated polls with percent above threshold
-      let fired = false;
-      let fireCount = 0;
-      const usagePercents = [75, 80, 85, 90, 95];
-
-      for (const percent of usagePercents) {
-        if (fired) continue; // one-shot guard
-        if (percent >= threshold) {
-          fired = true;
-          fireCount++;
-        }
-      }
-
-      assert.equal(fireCount, 1, "must fire exactly once");
-      assert.equal(fired, true);
-    });
-  });
-
-  describe("end-to-end pipeline across model sizes", () => {
-    const modelSizes = [
-      { name: "128K", contextWindow: 128_000 },
-      { name: "200K", contextWindow: 200_000 },
-      { name: "1M", contextWindow: 1_000_000 },
-    ];
-
-    it("all model sizes produce continueThresholdPercent of 70", () => {
-      for (const { name, contextWindow } of modelSizes) {
-        const budget = computeBudgets(contextWindow);
-        assert.equal(
-          budget.continueThresholdPercent,
-          70,
-          `${name} model should have 70% threshold`,
-        );
-      }
-    });
-
-    it("larger models produce larger verificationBudgetChars", () => {
-      const budgets = modelSizes.map(({ contextWindow }) => computeBudgets(contextWindow));
-
-      // 128K < 200K < 1M
-      assert.ok(
-        budgets[0].verificationBudgetChars < budgets[1].verificationBudgetChars,
-        "128K verification budget should be smaller than 200K",
-      );
-      assert.ok(
-        budgets[1].verificationBudgetChars < budgets[2].verificationBudgetChars,
-        "200K verification budget should be smaller than 1M",
-      );
-    });
-
-    it("larger models produce larger inlineContextBudgetChars", () => {
-      const budgets = modelSizes.map(({ contextWindow }) => computeBudgets(contextWindow));
-
-      assert.ok(
-        budgets[0].inlineContextBudgetChars < budgets[1].inlineContextBudgetChars,
-        "128K inline budget should be smaller than 200K",
-      );
-      assert.ok(
-        budgets[1].inlineContextBudgetChars < budgets[2].inlineContextBudgetChars,
-        "200K inline budget should be smaller than 1M",
-      );
-    });
-
-    it("task count range scales with context window", () => {
-      const b128 = computeBudgets(128_000);
-      const b200 = computeBudgets(200_000);
-      const b1m = computeBudgets(1_000_000);
-
-      // All have min=2
-      assert.equal(b128.taskCountRange.min, 2);
-      assert.equal(b200.taskCountRange.min, 2);
-      assert.equal(b1m.taskCountRange.min, 2);
-
-      // Max tasks scale: 128K→5, 200K→6, 1M→8
-      assert.equal(b128.taskCountRange.max, 5, "128K max tasks");
-      assert.equal(b200.taskCountRange.max, 6, "200K max tasks");
-      assert.equal(b1m.taskCountRange.max, 8, "1M max tasks");
-    });
-
-    it("produces deterministic verificationBudgetChars values", () => {
-      // 128K: 128000 * 4 * 0.10 = 51200
-      assert.equal(computeBudgets(128_000).verificationBudgetChars, 51_200);
-      // 200K: 200000 * 4 * 0.10 = 80000
-      assert.equal(computeBudgets(200_000).verificationBudgetChars, 80_000);
-      // 1M: 1000000 * 4 * 0.10 = 400000
-      assert.equal(computeBudgets(1_000_000).verificationBudgetChars, 400_000);
-    });
-  });
-
-  describe("continueHereFired runtime record field", () => {
-    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");
-      const path = await import("node:path");
-      const os = await import("node:os");
-
-      // 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 });
-      }
-    });
-  });
-
-  describe("context-pressure monitor integration", () => {
-    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-"));
-      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", () => {
-      const budget = computeBudgets(200_000);
-      const threshold = budget.continueThresholdPercent;
-
-      // Simulate monitor poll with context at 50%
-      const contextPercent = 50;
-      const continueHereFired = false;
-      const shouldFire = !continueHereFired && contextPercent >= threshold;
-      assert.equal(shouldFire, false, "50% should not trigger continue-here");
-    });
-
-    it("should not fire when contextUsage is null/undefined", () => {
-      const budget = computeBudgets(128_000);
-      const threshold = budget.continueThresholdPercent;
-
-      // Simulate the full guard chain from the monitor
-      const usageUndefined = undefined as { percent: number | null } | undefined;
-      const shouldFire1 = usageUndefined != null
-        && usageUndefined.percent != null
-        && usageUndefined.percent >= threshold;
-      assert.equal(shouldFire1, false, "undefined usage must not fire");
-
-      const usageNullPercent: { percent: number | null } = { percent: null };
-      const shouldFire2 = usageNullPercent.percent != null
-        && usageNullPercent.percent >= threshold;
-      assert.equal(shouldFire2, false, "null percent must not fire");
-    });
-  });
-});

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

@@ -1,134 +0,0 @@
-/**
- * Contract tests for `formatCostProjection`.
- * Tests the pure function — no file I/O, no extension context.
- *
- * This test intentionally fails at import time (or on first assertion)
- * because `formatCostProjection` does not yet exist in metrics.ts.
- * That failure confirms the test runs against real code. (T01 state)
- */
-
-import {
-  type SliceAggregate,
-  formatCostProjection,
-} from "../metrics.js";
-import { createTestContext } from './test-helpers.ts';
-
-// ─── Test helpers ─────────────────────────────────────────────────────────────
-
-function makeSliceAggregate(sliceId: string, cost: number): SliceAggregate {
-  return {
-    sliceId,
-    units: 1,
-    tokens: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
-    cost,
-    duration: 1000,
-  };
-}
-
-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();

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

@@ -1,134 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdirSync, existsSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { randomUUID } from "node:crypto";
-
-import {
-  writeLock,
-  clearLock,
-  readCrashLock,
-  isLockProcessAlive,
-  formatCrashInfo,
-  type LockData,
-} from "../crash-recovery.ts";
-
-function makeTmpBase(): string {
-  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
-  mkdirSync(join(base, ".gsd"), { recursive: true });
-  return base;
-}
-
-function cleanup(base: string): void {
-  try { rmSync(base, { recursive: true, force: true }); } catch { /* */ }
-}
-
-// ─── writeLock / readCrashLock ────────────────────────────────────────────
-
-test("writeLock creates lock file and readCrashLock reads it", () => {
-  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);
-  }
-});
-
-test("readCrashLock returns null when no lock exists", () => {
-  const base = makeTmpBase();
-  try {
-    const lock = readCrashLock(base);
-    assert.equal(lock, null);
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ─── clearLock ────────────────────────────────────────────────────────────
-
-test("clearLock removes existing lock file", () => {
-  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);
-  }
-});
-
-test("clearLock is safe when no lock exists", () => {
-  const base = makeTmpBase();
-  try {
-    assert.doesNotThrow(() => clearLock(base));
-  } finally {
-    cleanup(base);
-  }
-});
-
-// ─── isLockProcessAlive ──────────────────────────────────────────────────
-
-test("isLockProcessAlive returns true for current process (different pid)", () => {
-  // Our own PID is explicitly excluded (recycled PID guard)
-  const lock: LockData = {
-    pid: process.pid,
-    startedAt: new Date().toISOString(),
-    unitType: "execute-task",
-    unitId: "M001/S01/T01",
-    unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
-  };
-  assert.equal(isLockProcessAlive(lock), false, "own PID should return false");
-});
-
-test("isLockProcessAlive returns false for dead PID", () => {
-  const lock: LockData = {
-    pid: 999999999, // almost certainly not running
-    startedAt: new Date().toISOString(),
-    unitType: "execute-task",
-    unitId: "M001/S01/T01",
-    unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
-  };
-  assert.equal(isLockProcessAlive(lock), false);
-});
-
-test("isLockProcessAlive returns false for invalid PIDs", () => {
-  const base: Omit<LockData, "pid"> = {
-    startedAt: new Date().toISOString(),
-    unitType: "x",
-    unitId: "x",
-    unitStartedAt: new Date().toISOString(),
-    completedUnits: 0,
-  };
-  assert.equal(isLockProcessAlive({ ...base, pid: 0 } as LockData), false);
-  assert.equal(isLockProcessAlive({ ...base, pid: -1 } as LockData), false);
-  assert.equal(isLockProcessAlive({ ...base, pid: 1.5 } as LockData), false);
-});
-
-// ─── formatCrashInfo ─────────────────────────────────────────────────────
-
-test("formatCrashInfo includes unit type, id, and PID", () => {
-  const lock: LockData = {
-    pid: 12345,
-    startedAt: "2025-01-01T00:00:00.000Z",
-    unitType: "complete-slice",
-    unitId: "M002/S03",
-    unitStartedAt: "2025-01-01T00:01:00.000Z",
-    completedUnits: 7,
-  };
-  const info = formatCrashInfo(lock);
-  assert.ok(info.includes("complete-slice"));
-  assert.ok(info.includes("M002/S03"));
-  assert.ok(info.includes("12345"));
-  assert.ok(info.includes("7"));
-});