whale-code 6.5.10 → 6.6.0

package/dist/shared/agent-core-loop-detector.test.js

@@ -1,195 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { LoopDetector, AGENT_DEFAULTS } from "./agent-core.js";
-
-// ============================================================================
-// LoopDetector — recordCall, trackRead, recordResult
-// ============================================================================
-
-describe("LoopDetector", () => {
-  let detector;
-  beforeEach(() => {
-    detector = new LoopDetector();
-  });
-  describe("recordCall — identical call detection", () => {
-    it("allows first call", () => {
-      const result = detector.recordCall("read_file", {
-        path: "/foo"
-      });
-      expect(result.blocked).toBe(false);
-    });
-    it("allows calls below the identical limit", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopIdenticalCallLimit - 1; i++) {
-        const result = detector.recordCall("read_file", {
-          path: "/foo"
-        });
-        expect(result.blocked).toBe(false);
-      }
-    });
-    it("blocks after IDENTICAL_CALL_LIMIT identical calls", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopIdenticalCallLimit; i++) {
-        detector.recordCall("some_tool", {
-          key: "value"
-        });
-      }
-      const result = detector.recordCall("some_tool", {
-        key: "value"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("identical call");
-    });
-    it("does not block calls with different inputs", () => {
-      for (let i = 0; i < 10; i++) {
-        const result = detector.recordCall("read_file", {
-          path: `/file-${i}`
-        });
-        expect(result.blocked).toBe(false);
-      }
-    });
-  });
-  describe("trackRead", () => {
-    it("allows up to FILE_READ_LIMIT reads of the same file", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopFileReadLimit; i++) {
-        const result = detector.trackRead("/same/file.ts");
-        expect(result.blocked).toBe(false);
-      }
-    });
-    it("blocks after FILE_READ_LIMIT reads of the same file", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopFileReadLimit; i++) {
-        detector.trackRead("/same/file.ts");
-      }
-      const result = detector.trackRead("/same/file.ts");
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("already read");
-    });
-    it("tracks different files independently", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopFileReadLimit; i++) {
-        detector.trackRead("/file-a.ts");
-        detector.trackRead("/file-b.ts");
-      }
-      const resultA = detector.trackRead("/file-a.ts");
-      expect(resultA.blocked).toBe(true);
-      const resultB = detector.trackRead("/file-b.ts");
-      expect(resultB.blocked).toBe(true);
-    });
-    it("clears file read counts on full reset", () => {
-      for (let i = 0; i <= AGENT_DEFAULTS.loopFileReadLimit; i++) {
-        detector.trackRead("/file.ts");
-      }
-      detector.reset();
-      const result = detector.trackRead("/file.ts");
-      expect(result.blocked).toBe(false);
-    });
-    it("does NOT clear file read counts on resetTurn", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopFileReadLimit; i++) {
-        detector.trackRead("/file.ts");
-      }
-      detector.resetTurn();
-      const result = detector.trackRead("/file.ts");
-      expect(result.blocked).toBe(true);
-    });
-  });
-  describe("recordCall does NOT contain read_file logic", () => {
-    it("blocks read_file at IDENTICAL_CALL_LIMIT not FILE_READ_LIMIT", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopIdenticalCallLimit; i++) {
-        const result = detector.recordCall("read_file", {
-          path: "/same"
-        });
-        expect(result.blocked).toBe(false);
-      }
-      const result = detector.recordCall("read_file", {
-        path: "/same"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("identical call");
-    });
-  });
-  describe("recordResult — consecutive error tracking", () => {
-    it("blocks after CONSECUTIVE_ERROR_LIMIT consecutive errors for same tool", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveErrorLimit; i++) {
-        detector.recordCall("bash", {
-          command: "fail"
-        });
-        detector.recordResult("bash", false);
-      }
-      const result = detector.recordCall("bash", {
-        command: "different"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("failed");
-      expect(result.reason).toContain("consecutively");
-    });
-    it("resets consecutive errors on success", () => {
-      detector.recordCall("bash", {
-        command: "fail"
-      });
-      detector.recordResult("bash", false);
-      detector.recordCall("bash", {
-        command: "fail2"
-      });
-      detector.recordResult("bash", false);
-      detector.recordCall("bash", {
-        command: "ok"
-      });
-      detector.recordResult("bash", true);
-      detector.recordCall("bash", {
-        command: "fail3"
-      });
-      detector.recordResult("bash", false);
-      const result = detector.recordCall("bash", {
-        command: "new"
-      });
-      expect(result.blocked).toBe(false);
-    });
-  });
-  describe("recordResult — turn error limit", () => {
-    it("blocks after TURN_ERROR_LIMIT errors in a single turn", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopTurnErrorLimit; i++) {
-        detector.recordCall(`tool${i}`, {
-          arg: i
-        });
-        detector.recordResult(`tool${i}`, false);
-      }
-      const result = detector.recordCall("another_tool", {
-        arg: "x"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("errors this turn");
-    });
-  });
-  describe("recordResult — failed strategy tracking", () => {
-    it("blocks exact same call that previously failed", () => {
-      detector.recordCall("edit_file", {
-        path: "/x",
-        content: "y"
-      });
-      detector.recordResult("edit_file", false, {
-        path: "/x",
-        content: "y"
-      });
-      detector.resetTurn();
-      const result = detector.recordCall("edit_file", {
-        path: "/x",
-        content: "y"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("failed in a previous turn");
-    });
-  });
-  describe("session error tracking", () => {
-    it("blocks tool after SESSION_TOOL_ERROR_LIMIT failures", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopSessionToolErrorLimit; i++) {
-        detector.recordCall("bad_tool", {
-          attempt: i
-        });
-        detector.recordResult("bad_tool", false);
-        detector.resetTurn();
-      }
-      const result = detector.recordCall("bad_tool", {
-        attempt: "final"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("failed");
-      expect(result.reason).toContain("times this session");
-    });
-  });
-});

package/dist/shared/agent-core-loop-errors.test.js

@@ -1,258 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { LoopDetector, AGENT_DEFAULTS } from "./agent-core.js";
-
-// ============================================================================
-// LoopDetector — recordResult, endTurn, session errors, transient errors
-// ============================================================================
-
-describe("LoopDetector (errors and turns)", () => {
-  let detector;
-  beforeEach(() => {
-    detector = new LoopDetector();
-  });
-  describe("recordResult -- consecutive error tracking", () => {
-    it("blocks after CONSECUTIVE_ERROR_LIMIT consecutive errors for same tool", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveErrorLimit; i++) {
-        detector.recordCall("bash", {
-          command: "fail"
-        });
-        detector.recordResult("bash", false);
-      }
-      const result = detector.recordCall("bash", {
-        command: "different"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("failed");
-      expect(result.reason).toContain("consecutively");
-    });
-    it("resets consecutive errors on success", () => {
-      // Fail twice
-      detector.recordCall("bash", {
-        command: "fail"
-      });
-      detector.recordResult("bash", false);
-      detector.recordCall("bash", {
-        command: "fail2"
-      });
-      detector.recordResult("bash", false);
-
-      // Succeed once -- resets counter
-      detector.recordCall("bash", {
-        command: "ok"
-      });
-      detector.recordResult("bash", true);
-
-      // Should be able to fail again without being blocked
-      detector.recordCall("bash", {
-        command: "fail3"
-      });
-      detector.recordResult("bash", false);
-      const result = detector.recordCall("bash", {
-        command: "new"
-      });
-      expect(result.blocked).toBe(false);
-    });
-  });
-  describe("recordResult -- turn error limit", () => {
-    it("blocks after TURN_ERROR_LIMIT errors in a single turn", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopTurnErrorLimit; i++) {
-        detector.recordCall(`tool${i}`, {
-          arg: i
-        });
-        detector.recordResult(`tool${i}`, false);
-      }
-      const result = detector.recordCall("another_tool", {
-        arg: "x"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("errors this turn");
-    });
-  });
-  describe("recordResult -- failed strategy tracking", () => {
-    it("blocks exact same call that previously failed", () => {
-      detector.recordCall("edit_file", {
-        path: "/x",
-        content: "y"
-      });
-      detector.recordResult("edit_file", false, {
-        path: "/x",
-        content: "y"
-      });
-
-      // Reset turn to simulate new turn
-      detector.resetTurn();
-      const result = detector.recordCall("edit_file", {
-        path: "/x",
-        content: "y"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("failed in a previous turn");
-    });
-  });
-  describe("session error tracking", () => {
-    it("blocks tool after SESSION_TOOL_ERROR_LIMIT failures", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopSessionToolErrorLimit; i++) {
-        detector.recordCall("bad_tool", {
-          attempt: i
-        });
-        detector.recordResult("bad_tool", false);
-        detector.resetTurn(); // reset turn errors to avoid turn limit
-      }
-      const result = detector.recordCall("bad_tool", {
-        attempt: "final"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("failed");
-      expect(result.reason).toContain("times this session");
-    });
-  });
-  describe("endTurn -- bail detection", () => {
-    it("does not bail after successful turns", () => {
-      for (let i = 0; i < 5; i++) {
-        detector.recordCall("tool", {
-          i
-        });
-        detector.recordResult("tool", true);
-        const bail = detector.endTurn();
-        expect(bail.shouldBail).toBe(false);
-        detector.resetTurn();
-      }
-    });
-    it("bails after CONSECUTIVE_FAILED_TURN_LIMIT failed turns", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit; i++) {
-        detector.recordCall("tool", {
-          i
-        });
-        detector.recordResult("tool", false);
-        const bail = detector.endTurn();
-        if (i < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit - 1) {
-          expect(bail.shouldBail).toBe(false);
-        } else {
-          expect(bail.shouldBail).toBe(true);
-          expect(bail.message).toContain("consecutive turns");
-        }
-        detector.resetTurn();
-      }
-    });
-    it("resets consecutive failed turns on a successful turn", () => {
-      // 2 failed turns
-      for (let i = 0; i < 2; i++) {
-        detector.recordCall("tool", {
-          i
-        });
-        detector.recordResult("tool", false);
-        detector.endTurn();
-        detector.resetTurn();
-      }
-
-      // 1 successful turn
-      detector.recordCall("tool", {
-        ok: true
-      });
-      detector.recordResult("tool", true);
-      detector.endTurn();
-      detector.resetTurn();
-
-      // More failed turns should not trigger bail yet
-      detector.recordCall("tool", {
-        fail: true
-      });
-      detector.recordResult("tool", false);
-      const bail = detector.endTurn();
-      expect(bail.shouldBail).toBe(false);
-    });
-  });
-  describe("endTurn -- caps consecutiveErrors to prevent parallel batch deadlock", () => {
-    it("caps consecutiveErrors at (limit - 1) so tool gets one retry next turn", () => {
-      // Simulate 7 parallel failures from one batch (the TOCTOU race scenario)
-      for (let i = 0; i < 7; i++) {
-        detector.recordCall("read_file", {
-          path: `/file-${i}`
-        });
-        detector.recordResult("read_file", false);
-      }
-
-      // At this point, consecutiveErrors["read_file"] = 7 which exceeds the limit of 3.
-      // The tool would be permanently blocked without the cap fix.
-      const bail = detector.endTurn();
-      expect(bail.shouldBail).toBe(false); // only 1 failed turn, not 3
-
-      // After endTurn caps consecutiveErrors, the tool should be retryable
-      detector.resetTurn();
-      const result = detector.recordCall("read_file", {
-        path: "/new-path"
-      });
-      expect(result.blocked).toBe(false); // tool gets one more chance
-    });
-    it("does NOT cap consecutiveErrors when at the bail-out threshold", () => {
-      // Simulate 3 consecutive failed turns to hit the bail-out limit
-      for (let turn = 0; turn < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit; turn++) {
-        detector.recordCall("tool", {
-          turn
-        });
-        detector.recordResult("tool", false);
-        detector.endTurn();
-        detector.resetTurn();
-      }
-
-      // After bail-out, consecutive errors are NOT capped -- tool stays blocked
-      const result = detector.recordCall("tool", {
-        retry: true
-      });
-      expect(result.blocked).toBe(true);
-    });
-  });
-  describe("transient errors", () => {
-    it("does not add transient failures to failedStrategies", () => {
-      detector.recordCall("task_output", {
-        task_id: "abc"
-      });
-      detector.recordResult("task_output", false, {
-        task_id: "abc"
-      }, true);
-      const stats = detector.getSessionStats();
-      expect(stats.totalErrors).toBe(1);
-      expect(stats.failedStrategies).toBe(0);
-
-      // Same call should NOT be blocked on retry
-      detector.resetTurn();
-      const check = detector.recordCall("task_output", {
-        task_id: "abc"
-      });
-      expect(check.blocked).toBe(false);
-    });
-    it("adds non-transient failures to failedStrategies (default)", () => {
-      detector.recordCall("edit_file", {
-        path: "/x"
-      });
-      detector.recordResult("edit_file", false, {
-        path: "/x"
-      });
-      const stats = detector.getSessionStats();
-      expect(stats.failedStrategies).toBe(1);
-
-      // Same call should be blocked
-      detector.resetTurn();
-      const check = detector.recordCall("edit_file", {
-        path: "/x"
-      });
-      expect(check.blocked).toBe(true);
-    });
-    it("still counts transient errors toward consecutive/turn limits", () => {
-      for (let i = 0; i < AGENT_DEFAULTS.loopConsecutiveErrorLimit; i++) {
-        detector.recordCall("task_output", {
-          task_id: "abc"
-        });
-        detector.recordResult("task_output", false, {
-          task_id: "abc"
-        }, true);
-      }
-
-      // Should be blocked by consecutiveErrorLimit even though transient
-      const check = detector.recordCall("task_output", {
-        task_id: "abc"
-      });
-      expect(check.blocked).toBe(true);
-    });
-  });
-});

package/dist/shared/agent-core-pricing.test.js

@@ -1,191 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { estimateCostUsd, MODEL_PRICING, emitCostWarningIfNeeded, djb2Hash } from "./agent-core.js";
-
-// ============================================================================
-// estimateCostUsd
-// ============================================================================
-
-describe("estimateCostUsd", () => {
-  it("calculates cost for claude-opus-4-6", () => {
-    // 1M input tokens at $5/M + 1M output tokens at $25/M = $30
-    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-opus-4-6");
-    expect(cost).toBeCloseTo(30.0);
-  });
-  it("calculates cost for claude-sonnet-4-6", () => {
-    // 1M input at $3/M + 1M output at $15/M = $18
-    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-sonnet-4-6");
-    expect(cost).toBeCloseTo(18.0);
-  });
-  it("calculates cost for claude-haiku-4-5", () => {
-    // 1M input at $1/M + 1M output at $5/M = $6
-    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-haiku-4-5");
-    expect(cost).toBeCloseTo(6.0);
-  });
-  it("includes thinking tokens in cost", () => {
-    // Opus: 0 input + 0 output + 1M thinking at $25/M = $25
-    const cost = estimateCostUsd(0, 0, "claude-opus-4-6", 1_000_000);
-    expect(cost).toBeCloseTo(25.0);
-  });
-  it("handles zero tokens", () => {
-    expect(estimateCostUsd(0, 0, "claude-opus-4-6")).toBe(0);
-  });
-  it("falls back to sonnet pricing for unknown models", () => {
-    // Unknown model falls back to sonnet pricing: 1M input at $3/M + 1M output at $15/M
-    const cost = estimateCostUsd(1_000_000, 1_000_000, "claude-unknown-model");
-    expect(cost).toBeCloseTo(18.0);
-  });
-  it("handles partial model name matching", () => {
-    // "claude-opus-4-6" is contained in "claude-opus-4-6-20260101"
-    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6-20260101");
-    // model.includes(k) checks if the passed model includes the pricing key: $5/M input
-    expect(cost).toBeCloseTo(5.0);
-  });
-  it("calculates fractional token costs correctly", () => {
-    // 500 input tokens for opus: 500/1M * $5 = $0.0025
-    const cost = estimateCostUsd(500, 0, "claude-opus-4-6");
-    expect(cost).toBeCloseTo(0.0025);
-  });
-
-  // ---------- Cache-aware pricing ----------
-
-  it("applies Anthropic 90% cache read discount", () => {
-    // Opus: 1M input at $5/M = $5, but 500K are cache reads -> save 500K/1M * $5 * 0.9 = $2.25
-    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 500_000, 0);
-    expect(cost).toBeCloseTo(5.0 - 2.25); // $2.75
-  });
-  it("applies Anthropic 25% cache creation surcharge", () => {
-    // Opus: 1M input at $5/M = $5 + 200K creation -> 200K/1M * $5 * 0.25 = $0.25
-    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 0, 200_000);
-    expect(cost).toBeCloseTo(5.25);
-  });
-  it("applies both Anthropic cache read and creation adjustments", () => {
-    // Opus: 1M input at $5/M = $5
-    // 800K cache reads -> save 800K/1M * $5 * 0.9 = $3.60
-    // 100K cache creation -> add 100K/1M * $5 * 0.25 = $0.125
-    // Total: $5 - $3.60 + $0.125 = $1.525
-    const cost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 800_000, 100_000);
-    expect(cost).toBeCloseTo(1.525);
-  });
-  it("applies OpenAI 50% cache read discount", () => {
-    // Unknown OpenAI model falls back to sonnet pricing ($3/M input)
-    const baseCost = estimateCostUsd(1_000_000, 0, "gpt-5");
-    const cachedCost = estimateCostUsd(1_000_000, 0, "gpt-5", 0, 500_000, 0);
-    expect(cachedCost).toBeLessThan(baseCost);
-    const savings = baseCost - cachedCost;
-    const expectedSavings = 500_000 / 1_000_000 * MODEL_PRICING["claude-sonnet-4-6"].input * 0.5;
-    expect(savings).toBeCloseTo(expectedSavings);
-  });
-  it("applies Gemini 75% cache read discount", () => {
-    const baseCost = estimateCostUsd(1_000_000, 0, "gemini-3-pro-preview");
-    const cachedCost = estimateCostUsd(1_000_000, 0, "gemini-3-pro-preview", 0, 500_000, 0);
-    expect(cachedCost).toBeLessThan(baseCost);
-    const savings = baseCost - cachedCost;
-    const expectedSavings = 500_000 / 1_000_000 * MODEL_PRICING["claude-sonnet-4-6"].input * 0.75;
-    expect(savings).toBeCloseTo(expectedSavings);
-  });
-  it("does not apply cache discount when cache tokens are zero", () => {
-    const noCacheCost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6");
-    const zeroCacheCost = estimateCostUsd(1_000_000, 0, "claude-opus-4-6", 0, 0, 0);
-    expect(zeroCacheCost).toBe(noCacheCost);
-  });
-  it("applies Bedrock cache pricing same as Anthropic", () => {
-    // Bedrock uses same 90% cache read discount
-    const baseCost = estimateCostUsd(1_000_000, 0, "us.anthropic.claude-sonnet-4-6-v1:0");
-    const cachedCost = estimateCostUsd(1_000_000, 0, "us.anthropic.claude-sonnet-4-6-v1:0", 0, 500_000, 0);
-    expect(cachedCost).toBeLessThan(baseCost);
-  });
-});
-
-// ============================================================================
-// MODEL_PRICING
-// ============================================================================
-
-describe("MODEL_PRICING", () => {
-  it("has pricing for all three expected models", () => {
-    expect(MODEL_PRICING).toHaveProperty("claude-sonnet-4-6");
-    expect(MODEL_PRICING).toHaveProperty("claude-opus-4-6");
-    expect(MODEL_PRICING).toHaveProperty("claude-haiku-4-5");
-  });
-  it("has entries for multiple models", () => {
-    expect(Object.keys(MODEL_PRICING).length).toBeGreaterThanOrEqual(3);
-  });
-  it("opus is more expensive than sonnet", () => {
-    expect(MODEL_PRICING["claude-opus-4-6"].input).toBeGreaterThan(MODEL_PRICING["claude-sonnet-4-6"].input);
-    expect(MODEL_PRICING["claude-opus-4-6"].output).toBeGreaterThan(MODEL_PRICING["claude-sonnet-4-6"].output);
-  });
-  it("sonnet is more expensive than haiku", () => {
-    expect(MODEL_PRICING["claude-sonnet-4-6"].input).toBeGreaterThan(MODEL_PRICING["claude-haiku-4-5"].input);
-  });
-  it("Claude 4.x models have thinking pricing", () => {
-    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
-      if (key.startsWith("claude-") && !key.includes("3-5-") && !key.includes("3-haiku")) {
-        expect(pricing.thinking).toBeDefined();
-        expect(pricing.thinking).toBeGreaterThan(0);
-      }
-    }
-  });
-  it("thinking rate matches output rate for Claude 4.x models", () => {
-    for (const [key, pricing] of Object.entries(MODEL_PRICING)) {
-      if (key.startsWith("claude-") && !key.includes("3-5-") && !key.includes("3-haiku")) {
-        expect(pricing.thinking).toBe(pricing.output);
-      }
-    }
-  });
-});
-
-// ============================================================================
-// emitCostWarningIfNeeded
-// ============================================================================
-
-describe("emitCostWarningIfNeeded", () => {
-  it("emits at 25% threshold", () => {
-    const warnings = new Set();
-    const texts = [];
-    emitCostWarningIfNeeded(1.3, 5.0, warnings, t => texts.push(t));
-    expect(warnings.has(25)).toBe(true);
-    expect(texts).toHaveLength(1);
-    expect(texts[0]).toContain("25%");
-  });
-  it("emits all 3 thresholds at once when cost is high", () => {
-    const warnings = new Set();
-    const texts = [];
-    emitCostWarningIfNeeded(4.0, 5.0, warnings, t => texts.push(t));
-    expect(warnings.size).toBe(3);
-    expect(texts).toHaveLength(3);
-  });
-  it("is idempotent -- does not re-emit already-emitted warnings", () => {
-    const warnings = new Set([25]);
-    const texts = [];
-    emitCostWarningIfNeeded(1.5, 5.0, warnings, t => texts.push(t));
-    expect(texts).toHaveLength(0);
-  });
-  it("does nothing when maxCostUsd is Infinity", () => {
-    const warnings = new Set();
-    const texts = [];
-    emitCostWarningIfNeeded(100, Infinity, warnings, t => texts.push(t));
-    expect(texts).toHaveLength(0);
-  });
-  it("includes 'Wrap up soon.' only at 75%", () => {
-    const warnings = new Set();
-    const texts = [];
-    emitCostWarningIfNeeded(4.0, 5.0, warnings, t => texts.push(t));
-    // 25% and 50% should NOT contain "Wrap up"
-    expect(texts[0]).not.toContain("Wrap up");
-    expect(texts[1]).not.toContain("Wrap up");
-    // 75% SHOULD contain "Wrap up"
-    expect(texts[2]).toContain("Wrap up soon.");
-  });
-});
-
-// ============================================================================
-// djb2Hash
-// ============================================================================
-
-describe("djb2Hash", () => {
-  it("is deterministic", () => {
-    expect(djb2Hash("hello world")).toBe(djb2Hash("hello world"));
-  });
-  it("produces different hashes for different inputs", () => {
-    expect(djb2Hash("input-a")).not.toBe(djb2Hash("input-b"));
-  });
-});