whale-code 6.5.11 → 6.6.0

package/dist/shared/agent-core-context-thinking.test.js

@@ -1,293 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getContextManagement, getMaxOutputTokens, addPromptCaching, getThinkingConfig, resolveToolChoice, demoteSubagentModel } from "./agent-core.js";
-
-// ============================================================================
-// getContextManagement
-// ============================================================================
-
-describe("getContextManagement", () => {
-  it("returns compact + clear betas for opus-4-6", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    expect(result.betas).toContain("context-management-2025-06-27");
-    expect(result.betas).toContain("compact-2026-01-12");
-    expect(result.betas).toHaveLength(2);
-  });
-  it("includes compact edit at 167K for opus-4-6", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    const compactEdit = result.config.edits.find(e => e.type === "compact_20260112");
-    expect(compactEdit).toBeDefined();
-    expect(compactEdit.trigger).toEqual({
-      type: "input_tokens",
-      value: 167_000
-    });
-  });
-  it("includes clear_tool_uses edit at 100K for opus-4-6", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    const clearEdit = result.config.edits.find(e => e.type === "clear_tool_uses_20250919");
-    expect(clearEdit).toBeDefined();
-    expect(clearEdit.trigger).toEqual({
-      type: "input_tokens",
-      value: 100_000
-    });
-    expect(clearEdit.keep).toEqual({
-      type: "tool_uses",
-      value: 3
-    });
-  });
-  it("returns compact + clear betas for sonnet-4-6", () => {
-    const result = getContextManagement("claude-sonnet-4-6");
-    expect(result.betas).toContain("context-management-2025-06-27");
-    expect(result.betas).toContain("compact-2026-01-12");
-    expect(result.betas).toHaveLength(2);
-  });
-  it("includes compact edit for sonnet-4-6 (supports compaction)", () => {
-    const result = getContextManagement("claude-sonnet-4-6");
-    const compactEdit = result.config.edits.find(e => e.type === "compact_20260112");
-    expect(compactEdit).toBeDefined();
-  });
-  it("includes clear_thinking + clear_tool_uses for non-opus models", () => {
-    const result = getContextManagement("claude-haiku-4-5-20251001");
-    expect(result.config.edits).toHaveLength(2);
-    expect(result.config.edits[0].type).toBe("clear_thinking_20251015");
-    expect(result.config.edits[1].type).toBe("clear_tool_uses_20250919");
-  });
-  it("opus-4-6 has 3 edits (clear_thinking + compact + clear_tool_uses)", () => {
-    const result = getContextManagement("claude-opus-4-6");
-    expect(result.config.edits).toHaveLength(3);
-    expect(result.config.edits[0].type).toBe("clear_thinking_20251015");
-    expect(result.config.edits[1].type).toBe("compact_20260112");
-    expect(result.config.edits[1].pause_after_compaction).toBe(true);
-    expect(result.config.edits[2].type).toBe("clear_tool_uses_20250919");
-  });
-  it("sonnet-4-6 gets compaction like opus-4-6", () => {
-    const result = getContextManagement("claude-sonnet-4-6");
-    expect(result.config.edits).toHaveLength(3);
-    expect(result.config.edits[1].type).toBe("compact_20260112");
-    expect(result.betas).toContain("compact-2026-01-12");
-  });
-});
-
-// ============================================================================
-// getMaxOutputTokens
-// ============================================================================
-
-describe("getMaxOutputTokens", () => {
-  it("returns correct default for each Claude model", () => {
-    // Without agentMax, getMaxOutputTokens returns min(DEFAULT_OUTPUT_TOKENS, modelMax)
-    expect(getMaxOutputTokens("claude-opus-4-6")).toBe(32000);
-    expect(getMaxOutputTokens("claude-sonnet-4-6")).toBe(32000);
-    expect(getMaxOutputTokens("claude-haiku-4-5-20251001")).toBe(32000);
-  });
-  it("returns 32000 as default for unknown models", () => {
-    expect(getMaxOutputTokens("some-unknown-model")).toBe(32000);
-  });
-  it("respects agentMax when lower than model max", () => {
-    expect(getMaxOutputTokens("claude-opus-4-6", 8192)).toBe(8192);
-  });
-  it("caps agentMax at model max", () => {
-    expect(getMaxOutputTokens("claude-opus-4-6", 200000)).toBe(128000);
-  });
-  it("returns default when agentMax is 0 (falsy)", () => {
-    // agentMax=0 is falsy, so falls through to min(DEFAULT_OUTPUT_TOKENS, modelMax)
-    expect(getMaxOutputTokens("claude-opus-4-6", 0)).toBe(32000);
-  });
-});
-
-// ============================================================================
-// addPromptCaching
-// ============================================================================
-
-describe("addPromptCaching", () => {
-  it("adds cache_control to last tool", () => {
-    const tools = [{
-      name: "tool1"
-    }, {
-      name: "tool2"
-    }];
-    const messages = [{
-      role: "user",
-      content: "hello"
-    }];
-    const result = addPromptCaching(tools, messages);
-    expect(result.tools[0]).not.toHaveProperty("cache_control");
-    expect(result.tools[1]).toHaveProperty("cache_control", {
-      type: "ephemeral"
-    });
-  });
-  it("handles empty tools array", () => {
-    const result = addPromptCaching([], [{
-      role: "user",
-      content: "hi"
-    }]);
-    expect(result.tools).toHaveLength(0);
-  });
-  it("adds cache_control to second-to-last message (string content)", () => {
-    const messages = [{
-      role: "user",
-      content: "first"
-    }, {
-      role: "assistant",
-      content: "response"
-    }, {
-      role: "user",
-      content: "second"
-    }];
-    const result = addPromptCaching([], messages);
-    // Second-to-last message (index 1) should be converted to array with cache_control
-    const cached = result.messages[1];
-    expect(Array.isArray(cached.content)).toBe(true);
-    expect(cached.content[0]).toEqual({
-      type: "text",
-      text: "response",
-      cache_control: {
-        type: "ephemeral"
-      }
-    });
-  });
-  it("adds cache_control to last block of second-to-last message (array content)", () => {
-    const messages = [{
-      role: "user",
-      content: [{
-        type: "text",
-        text: "a"
-      }, {
-        type: "text",
-        text: "b"
-      }]
-    }, {
-      role: "assistant",
-      content: "response"
-    }];
-    const result = addPromptCaching([], messages);
-    const cached = result.messages[0];
-    expect(cached.content[0]).not.toHaveProperty("cache_control");
-    expect(cached.content[1]).toHaveProperty("cache_control", {
-      type: "ephemeral"
-    });
-  });
-  it("does not modify messages with fewer than 2 entries", () => {
-    const messages = [{
-      role: "user",
-      content: "only one"
-    }];
-    const result = addPromptCaching([], messages);
-    expect(result.messages[0]).toEqual({
-      role: "user",
-      content: "only one"
-    });
-  });
-  it("does not mutate original arrays", () => {
-    const tools = [{
-      name: "t1"
-    }];
-    const messages = [{
-      role: "user",
-      content: "hi"
-    }];
-    addPromptCaching(tools, messages);
-    expect(tools[0]).not.toHaveProperty("cache_control");
-    expect(messages[0]).toEqual({
-      role: "user",
-      content: "hi"
-    });
-  });
-});
-
-// ============================================================================
-// getThinkingConfig
-// ============================================================================
-
-describe("getThinkingConfig", () => {
-  it("returns disabled when not enabled", () => {
-    const result = getThinkingConfig("claude-opus-4-6", false);
-    expect(result.thinking.type).toBe("disabled");
-    expect(result.beta).toBe("");
-  });
-  it("returns adaptive thinking for opus-4-6", () => {
-    const result = getThinkingConfig("claude-opus-4-6", true);
-    expect(result.thinking.type).toBe("adaptive");
-    expect(result.thinking.budget_tokens).toBeUndefined();
-    expect(result.beta).toBe("adaptive-thinking-2026-01-28");
-  });
-  it("returns adaptive thinking for sonnet-4-6", () => {
-    const result = getThinkingConfig("claude-sonnet-4-6", true);
-    expect(result.thinking.type).toBe("adaptive");
-    expect(result.thinking.budget_tokens).toBeUndefined();
-    expect(result.beta).toBe("adaptive-thinking-2026-01-28");
-  });
-  it("returns fixed budget thinking for haiku", () => {
-    const result = getThinkingConfig("claude-haiku-4-5-20251001", true);
-    expect(result.thinking.type).toBe("enabled");
-    expect(result.thinking.budget_tokens).toBe(31_999);
-  });
-});
-
-// ============================================================================
-// resolveToolChoice -- alternating pattern detection
-// ============================================================================
-
-describe("resolveToolChoice -- alternating pattern", () => {
-  it("detects ABABAB pattern and returns 'none'", () => {
-    const result = resolveToolChoice({
-      turnCount: 7,
-      recentToolUses: ["read_file", "edit_file", "read_file", "edit_file", "read_file", "edit_file"],
-      availableToolNames: ["read_file", "edit_file"],
-      userMessage: ""
-    });
-    expect(result).toBe("none");
-  });
-  it("does not trigger on non-alternating patterns", () => {
-    const result = resolveToolChoice({
-      turnCount: 7,
-      recentToolUses: ["read_file", "edit_file", "bash", "edit_file", "read_file", "edit_file"],
-      availableToolNames: ["read_file", "edit_file", "bash"],
-      userMessage: ""
-    });
-    expect(result).toBe("auto");
-  });
-  it("does not trigger with fewer than 6 elements", () => {
-    const result = resolveToolChoice({
-      turnCount: 5,
-      recentToolUses: ["read_file", "edit_file", "read_file", "edit_file", "read_file"],
-      availableToolNames: ["read_file", "edit_file"],
-      userMessage: ""
-    });
-    expect(result).toBe("auto");
-  });
-});
-
-// ============================================================================
-// demoteSubagentModel
-// ============================================================================
-
-describe("demoteSubagentModel", () => {
-  it("returns haiku for explore type regardless of request", () => {
-    expect(demoteSubagentModel("opus", "explore")).toBe("haiku");
-    expect(demoteSubagentModel("sonnet", "explore")).toBe("haiku");
-  });
-  it("returns haiku for research type regardless of request", () => {
-    expect(demoteSubagentModel("opus", "research")).toBe("haiku");
-    expect(demoteSubagentModel("sonnet", "research")).toBe("haiku");
-  });
-  it("inherits opus for general-purpose type (Claude Code parity)", () => {
-    expect(demoteSubagentModel("opus", "general-purpose")).toBe("opus");
-  });
-  it("inherits sonnet for general-purpose type", () => {
-    expect(demoteSubagentModel("sonnet", "general-purpose")).toBe("sonnet");
-  });
-  it("defaults general-purpose to sonnet when no model requested", () => {
-    expect(demoteSubagentModel(undefined, "general-purpose")).toBe("sonnet");
-  });
-  it("inherits opus for plan type", () => {
-    expect(demoteSubagentModel("opus", "plan")).toBe("opus");
-  });
-  it("keeps sonnet for plan type", () => {
-    expect(demoteSubagentModel("sonnet", "plan")).toBe("sonnet");
-  });
-  it("demotes opus to sonnet for unknown types", () => {
-    expect(demoteSubagentModel("opus")).toBe("sonnet");
-  });
-  it("returns haiku when no model and no type", () => {
-    expect(demoteSubagentModel(undefined)).toBe("haiku");
-  });
-});

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

@@ -1,174 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { LoopDetector, AGENT_DEFAULTS } from "./agent-core.js";
-
-// ============================================================================
-// LoopDetector — recordCall, trackRead, constructor config, reset
-// ============================================================================
-
-describe("LoopDetector (calls and reads)", () => {
-  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", () => {
-      // FILE_READ_LIMIT=3, IDENTICAL_CALL_LIMIT=4
-      // Without hardcoded read_file logic, recordCall should block at 4, not 3
-      for (let i = 0; i < AGENT_DEFAULTS.loopIdenticalCallLimit; i++) {
-        const result = detector.recordCall("read_file", {
-          path: "/same"
-        });
-        expect(result.blocked).toBe(false);
-      }
-      // 5th identical call should be blocked by identical-call detection
-      const result = detector.recordCall("read_file", {
-        path: "/same"
-      });
-      expect(result.blocked).toBe(true);
-      expect(result.reason).toContain("identical call");
-    });
-  });
-  describe("constructor -- accepts config overrides", () => {
-    it("uses custom thresholds from config", () => {
-      const custom = new LoopDetector({
-        consecutiveErrorLimit: 10,
-        turnErrorLimit: 20,
-        // raise turn limit so it doesn't interfere
-        fileReadLimit: 5
-      });
-
-      // Should allow up to 5 reads (not the default 3)
-      for (let i = 0; i < 5; i++) {
-        expect(custom.trackRead("/file.ts").blocked).toBe(false);
-      }
-      expect(custom.trackRead("/file.ts").blocked).toBe(true);
-
-      // Should allow up to 9 consecutive errors (not the default 3)
-      for (let i = 0; i < 9; i++) {
-        custom.recordCall("tool", {
-          i
-        });
-        custom.recordResult("tool", false);
-      }
-      const result = custom.recordCall("tool", {
-        attempt: "10th"
-      });
-      expect(result.blocked).toBe(false); // still under 10
-    });
-  });
-  describe("reset", () => {
-    it("clears all state", () => {
-      // Build up state
-      for (let i = 0; i < 5; i++) {
-        detector.recordCall("tool", {
-          i
-        });
-        detector.recordResult("tool", false, {
-          i
-        });
-      }
-      detector.reset();
-      const stats = detector.getSessionStats();
-      expect(stats.totalErrors).toBe(0);
-      expect(stats.failedStrategies).toBe(0);
-      expect(stats.consecutiveFailedTurns).toBe(0);
-    });
-  });
-  describe("getSessionStats", () => {
-    it("tracks error counts", () => {
-      detector.recordCall("a", {
-        x: 1
-      });
-      detector.recordResult("a", false, {
-        x: 1
-      });
-      detector.recordCall("b", {
-        y: 2
-      });
-      detector.recordResult("b", false, {
-        y: 2
-      });
-      const stats = detector.getSessionStats();
-      expect(stats.totalErrors).toBe(2);
-      expect(stats.failedStrategies).toBe(2);
-    });
-  });
-});

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

@@ -1,201 +0,0 @@
-import { describe, it, expect, beforeEach } from "vitest";
-import { LoopDetector, AGENT_DEFAULTS } from "./agent-core.js";
-
-// ============================================================================
-// LoopDetector — endTurn bail detection, config overrides, reset, transient errors
-// ============================================================================
-
-describe("LoopDetector", () => {
-  let detector;
-  beforeEach(() => {
-    detector = new LoopDetector();
-  });
-  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", () => {
-      for (let i = 0; i < 2; i++) {
-        detector.recordCall("tool", {
-          i
-        });
-        detector.recordResult("tool", false);
-        detector.endTurn();
-        detector.resetTurn();
-      }
-      detector.recordCall("tool", {
-        ok: true
-      });
-      detector.recordResult("tool", true);
-      detector.endTurn();
-      detector.resetTurn();
-      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", () => {
-      for (let i = 0; i < 7; i++) {
-        detector.recordCall("read_file", {
-          path: `/file-${i}`
-        });
-        detector.recordResult("read_file", false);
-      }
-      const bail = detector.endTurn();
-      expect(bail.shouldBail).toBe(false);
-      detector.resetTurn();
-      const result = detector.recordCall("read_file", {
-        path: "/new-path"
-      });
-      expect(result.blocked).toBe(false);
-    });
-    it("does NOT cap consecutiveErrors when at the bail-out threshold", () => {
-      for (let turn = 0; turn < AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit; turn++) {
-        detector.recordCall("tool", {
-          turn
-        });
-        detector.recordResult("tool", false);
-        detector.endTurn();
-        detector.resetTurn();
-      }
-      const result = detector.recordCall("tool", {
-        retry: true
-      });
-      expect(result.blocked).toBe(true);
-    });
-  });
-  describe("constructor — accepts config overrides", () => {
-    it("uses custom thresholds from config", () => {
-      const custom = new LoopDetector({
-        consecutiveErrorLimit: 10,
-        turnErrorLimit: 20,
-        fileReadLimit: 5
-      });
-      for (let i = 0; i < 5; i++) {
-        expect(custom.trackRead("/file.ts").blocked).toBe(false);
-      }
-      expect(custom.trackRead("/file.ts").blocked).toBe(true);
-      for (let i = 0; i < 9; i++) {
-        custom.recordCall("tool", {
-          i
-        });
-        custom.recordResult("tool", false);
-      }
-      const result = custom.recordCall("tool", {
-        attempt: "10th"
-      });
-      expect(result.blocked).toBe(false);
-    });
-  });
-  describe("reset", () => {
-    it("clears all state", () => {
-      for (let i = 0; i < 5; i++) {
-        detector.recordCall("tool", {
-          i
-        });
-        detector.recordResult("tool", false, {
-          i
-        });
-      }
-      detector.reset();
-      const stats = detector.getSessionStats();
-      expect(stats.totalErrors).toBe(0);
-      expect(stats.failedStrategies).toBe(0);
-      expect(stats.consecutiveFailedTurns).toBe(0);
-    });
-  });
-  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);
-      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);
-      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);
-      }
-      const check = detector.recordCall("task_output", {
-        task_id: "abc"
-      });
-      expect(check.blocked).toBe(true);
-    });
-  });
-  describe("getSessionStats", () => {
-    it("tracks error counts", () => {
-      detector.recordCall("a", {
-        x: 1
-      });
-      detector.recordResult("a", false, {
-        x: 1
-      });
-      detector.recordCall("b", {
-        y: 2
-      });
-      detector.recordResult("b", false, {
-        y: 2
-      });
-      const stats = detector.getSessionStats();
-      expect(stats.totalErrors).toBe(2);
-      expect(stats.failedStrategies).toBe(2);
-    });
-  });
-});