whale-code 6.5.4 → 6.5.6

package/dist/shared/agent-core.js

@@ -4,7 +4,25 @@
  * Pure TypeScript, no runtime-specific APIs (no Deno.env, no process.env, no fs).
  * Both the CLI (Node.js) and server (Fly container) import from here.
  */
+
 import { getProvider } from "./constants.js";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+// ============================================================================
+// TOOL CHOICE
+// ============================================================================
+
+/**
+ * Controls which tools the model can/must use:
+ * - "auto": Model decides whether to use tools (default)
+ * - "any": Model must use at least one tool
+ * - "none": Model must not use any tools (text-only response)
+ * - { type: "tool", name: string }: Model must use the specified tool
+ */
+
 /**
  * Resolve the effective tool_choice for a given turn.
  *
@@ -15,102 +33,164 @@ import { getProvider } from "./constants.js";
  * 4. Default: "auto"
  */
 export function resolveToolChoice(opts) {
-    // 1. Explicit override always wins
-    if (opts.toolChoice !== undefined)
-        return opts.toolChoice;
-    // 2. Loop detection: if last 3+ turns all used the exact same tool, force text
-    if (opts.recentToolUses.length >= 3) {
-        const last3 = opts.recentToolUses.slice(-3);
-        if (last3[0] === last3[1] && last3[1] === last3[2]) {
-            return "none";
-        }
-    }
-    // 2b. Alternating pattern detection: catch A→B→A→B→A→B death spirals (e.g. read→edit→read→edit)
-    if (opts.recentToolUses.length >= 6) {
-        const last6 = opts.recentToolUses.slice(-6);
-        const isRepeatingPair = last6[2] === last6[0] && last6[3] === last6[1] &&
-            last6[4] === last6[0] && last6[5] === last6[1];
-        if (isRepeatingPair)
-            return "none";
+  // 1. Explicit override always wins
+  if (opts.toolChoice !== undefined) return opts.toolChoice;
+
+  // 2. Loop detection: if last 3+ turns all used the exact same tool, force text
+  if (opts.recentToolUses.length >= 3) {
+    const last3 = opts.recentToolUses.slice(-3);
+    if (last3[0] === last3[1] && last3[1] === last3[2]) {
+      return "none";
     }
-    // 3. Keyword matching: check if the user message mentions a specific tool name
-    //    Only on the first turn (avoids false positives on multi-turn conversations)
-    if (opts.turnCount === 1 && opts.userMessage && opts.availableToolNames.length > 0) {
-        const msgLower = opts.userMessage.toLowerCase();
-        for (const toolName of opts.availableToolNames) {
-            // Match tool name as a whole word (e.g. "blender_do" not "do")
-            // Only consider tool names >= 4 chars to avoid false positives
-            if (toolName.length >= 4 && msgLower.includes(toolName.toLowerCase())) {
-                return { type: "tool", name: toolName };
-            }
-        }
+  }
+
+  // 2b. Alternating pattern detection: catch A→B→A→B→A→B death spirals (e.g. read→edit→read→edit)
+  if (opts.recentToolUses.length >= 6) {
+    const last6 = opts.recentToolUses.slice(-6);
+    const isRepeatingPair = last6[2] === last6[0] && last6[3] === last6[1] && last6[4] === last6[0] && last6[5] === last6[1];
+    if (isRepeatingPair) return "none";
+  }
+
+  // 3. Keyword matching: check if the user message mentions a specific tool name
+  //    Only on the first turn (avoids false positives on multi-turn conversations)
+  if (opts.turnCount === 1 && opts.userMessage && opts.availableToolNames.length > 0) {
+    const msgLower = opts.userMessage.toLowerCase();
+    for (const toolName of opts.availableToolNames) {
+      // Match tool name as a whole word (e.g. "blender_do" not "do")
+      // Only consider tool names >= 4 chars to avoid false positives
+      if (toolName.length >= 4 && msgLower.includes(toolName.toLowerCase())) {
+        return {
+          type: "tool",
+          name: toolName
+        };
+      }
     }
-    // 4. Default
-    return "auto";
+  }
+
+  // 4. Default
+  return "auto";
 }
+
+/** Overrides from ai_agent_config.context_config JSONB — all optional, falls back to defaults */
+
 // ============================================================================
 // MODEL-AWARE CONTEXT MANAGEMENT
 // ============================================================================
-/** Compaction trigger threshold — shared so agent loops can track budget */
-export const COMPACTION_TRIGGER_TOKENS = 120_000;
-/** Max cumulative tokens before forcing wrap-up (prevents runaway compaction cost) */
+
+// These re-export from AGENT_DEFAULTS so there's exactly one place to change.
+// DB context_config always overrides these via resolveAgentLoopConfig().
+
+/** Legacy compaction trigger — used by getCompactionConfig() for non-Anthropic providers. */
+export const COMPACTION_TRIGGER_TOKENS = 167_000;
+/** Max cumulative tokens before forcing wrap-up */
 export const COMPACTION_TOTAL_BUDGET = 2_000_000;
-/** Default session cost budget in USD — hard cap to prevent runaway spending */
-export const DEFAULT_SESSION_COST_BUDGET_USD = 5.00;
+/** Session cost safety cap — DB context_config.session_cost_budget_usd overrides */
+export const DEFAULT_SESSION_COST_BUDGET_USD = 25.00;
+
+/**
+ * Provider-aware compaction configuration.
+ * - Anthropic/Bedrock: native server-side compaction via compact_20260112
+ * - OpenAI/Gemini: Haiku-based summarization (same instructions, same format)
+ */
+
 export function getCompactionConfig(model) {
-    const provider = getProvider(model);
-    switch (provider) {
-        case "gemini":
-            return { triggerTokens: 700_000, totalBudget: 4_000_000, isNative: false };
-        case "openai":
-            return { triggerTokens: 120_000, totalBudget: 2_000_000, isNative: false };
-        case "bedrock":
-        case "anthropic":
-        default:
-            return { triggerTokens: COMPACTION_TRIGGER_TOKENS, totalBudget: COMPACTION_TOTAL_BUDGET, isNative: true };
-    }
+  const provider = getProvider(model);
+  switch (provider) {
+    case "gemini":
+      return {
+        triggerTokens: 700_000,
+        totalBudget: 4_000_000,
+        isNative: false
+      };
+    case "openai":
+      return {
+        triggerTokens: 120_000,
+        totalBudget: 2_000_000,
+        isNative: false
+      };
+    case "bedrock":
+    case "anthropic":
+    default:
+      return {
+        triggerTokens: COMPACTION_TRIGGER_TOKENS,
+        totalBudget: COMPACTION_TOTAL_BUDGET,
+        isNative: true
+      };
+  }
 }
+
 /**
  * Returns Anthropic beta flags and context_management config for the given model.
  * - Opus 4.6 / Sonnet 4.6: compact at 120K (pause after) + clear thinking + clear tools at 80K/keep 3
  * - All other Claude models: clear thinking + clear tools at 80K/keep 3
  * - Non-Anthropic models (Gemini, OpenAI): no betas, no context management
  */
-export function getContextManagement(model) {
-    // Non-Anthropic models don't use Anthropic betas or context management
-    const provider = getProvider(model);
-    if (provider === "gemini" || provider === "openai") {
-        return { betas: [], config: { edits: [] } };
+export function getContextManagement(model, overrides) {
+  // Non-Anthropic models don't use Anthropic betas or context management
+  const provider = getProvider(model);
+  if (provider === "gemini" || provider === "openai") {
+    return {
+      betas: [],
+      config: {
+        edits: []
+      }
+    };
+  }
+  const edits = [];
+  const betas = ["context-management-2025-06-27"];
+
+  // Thinking block clearing — must come FIRST in edits array (API requirement).
+  // Default: keep 1 thinking turn (matches Claude Code / Anthropic API defaults).
+  const clearThinkingKeep = overrides?.clear_thinking_keep ?? 1;
+  edits.push({
+    type: "clear_thinking_20251015",
+    keep: {
+      type: "thinking_turns",
+      value: clearThinkingKeep
     }
-    const edits = [];
-    const betas = ["context-management-2025-06-27"];
-    // Thinking block clearing — must come FIRST in edits array (API requirement).
-    // Keeps last 2 turns of thinking to maintain reasoning continuity while
-    // preventing unbounded growth from extended thinking.
+  });
+
+  // Server-side compaction for models that support compact_20260112.
+  // Default trigger: 150K tokens (matches Anthropic API default).
+  // pause_after_compaction: true enables the loop to preserve recent messages
+  // and track compaction count for budget enforcement.
+  const supportsCompaction = model.includes("opus-4-6") || model.includes("sonnet-4-6");
+  const compactionTrigger = overrides?.compaction_trigger_tokens ?? AGENT_DEFAULTS.compactionTriggerTokens;
+  if (supportsCompaction) {
     edits.push({
-        type: "clear_thinking_20251015",
-        keep: { type: "thinking_turns", value: 2 },
+      type: "compact_20260112",
+      trigger: {
+        type: "input_tokens",
+        value: compactionTrigger
+      },
+      pause_after_compaction: true,
+      instructions: "Summarize the conversation preserving: (1) task goals and constraints, (2) files created/modified with paths, (3) decisions made and rationale, (4) errors encountered and resolutions, (5) exact next steps. Be concise but preserve all state needed to continue work without repeating mistakes."
     });
-    // Server-side compaction for models that support compact_20260112.
-    // pause_after_compaction: true enables the loop to preserve recent messages
-    // and track compaction count for budget enforcement.
-    const supportsCompaction = model.includes("opus-4-6") || model.includes("sonnet-4-6");
-    if (supportsCompaction) {
-        edits.push({
-            type: "compact_20260112",
-            trigger: { type: "input_tokens", value: COMPACTION_TRIGGER_TOKENS },
-            pause_after_compaction: true,
-            instructions: "Summarize the conversation preserving: (1) task goals and constraints, (2) files created/modified with paths, (3) decisions made and rationale, (4) errors encountered and resolutions, (5) exact next steps. Be concise but preserve all state needed to continue work without repeating mistakes.",
-        });
-        betas.push("compact-2026-01-12");
+    betas.push("compact-2026-01-12");
+  }
+
+  // Clear tool uses — default: trigger at 100K, keep 3 (matches Anthropic API defaults).
+  const clearToolUsesTrigger = overrides?.clear_tool_uses_trigger ?? 100_000;
+  const clearToolUsesKeep = overrides?.clear_tool_uses_keep ?? 3;
+  edits.push({
+    type: "clear_tool_uses_20250919",
+    trigger: {
+      type: "input_tokens",
+      value: clearToolUsesTrigger
+    },
+    keep: {
+      type: "tool_uses",
+      value: clearToolUsesKeep
     }
-    edits.push({
-        type: "clear_tool_uses_20250919",
-        trigger: { type: "input_tokens", value: 80_000 },
-        keep: { type: "tool_uses", value: 3 },
-    });
-    return { betas, config: { edits } };
+  });
+  return {
+    betas,
+    config: {
+      edits
+    }
+  };
 }
+
 /**
  * Model-aware max output tokens.
  * Agent config max_tokens takes priority but is capped at model maximum.
@@ -118,50 +198,62 @@ export function getContextManagement(model) {
  * DEFAULT_OUTPUT_TOKENS is the sensible per-response cap (like Claude Code's ~16K).
  * The full MODEL_MAX is only used when explicitly requested via agentMax.
  */
-const DEFAULT_OUTPUT_TOKENS = 16384; // 16K — sane default, prevents single-response burns
+// Fallback only when DB agent.max_tokens is null/0. DB value (ai_agent_config.max_tokens) takes priority.
+const DEFAULT_OUTPUT_TOKENS = 32000;
 const MODEL_MAX_OUTPUT_TOKENS = {
-    // Anthropic — current models (actual API-enforced limits)
-    "claude-opus-4-6": 128000, // 128K
-    "claude-sonnet-4-6": 64000, // 64K (API enforces 64000, not 65536)
-    "claude-haiku-4-5-20251001": 64000, // 64K
-    // Anthropic — legacy models
-    "claude-sonnet-4-5-20250929": 64000, // 64K (API enforces 64000)
-    "claude-opus-4-5-20251101": 64000, // 64K
-    "claude-opus-4-1-20250805": 32768, // 32K
-    "claude-sonnet-4-20250514": 64000, // 64K
-    "claude-opus-4-20250514": 32768, // 32K
-    "claude-3-7-sonnet-20250219": 64000, // 64K
-    "claude-3-haiku-20240307": 4096, // 4K
-    // Bedrock — same limits as direct API
-    "anthropic.claude-sonnet-4-6": 64000,
-    "us.anthropic.claude-sonnet-4-20250514-v1:0": 64000,
-    "us.anthropic.claude-sonnet-4-5-20250929-v1:0": 64000,
-    "us.anthropic.claude-haiku-4-5-20251001-v1:0": 64000,
-    // Google Gemini
-    "gemini-3-pro-preview": 65536,
-    "gemini-3-flash-preview": 65536,
-    "gemini-2.5-pro": 65536,
-    "gemini-2.5-flash": 65536,
-    "gemini-2.5-flash-lite": 65536,
-    // OpenAI — GPT-5 family: 128K max output, o-series: 100K
-    "gpt-5": 128000,
-    "gpt-5-mini": 128000,
-    "gpt-5-nano": 128000,
-    "o3": 100000,
-    "o4-mini": 100000,
-    "gpt-4o": 16384,
+  // Anthropic — current models (actual API-enforced limits)
+  "claude-opus-4-6": 128000,
+  // 128K
+  "claude-sonnet-4-6": 64000,
+  // 64K (API enforces 64000, not 65536)
+  "claude-haiku-4-5-20251001": 64000,
+  // 64K
+  // Anthropic — legacy models
+  "claude-sonnet-4-5-20250929": 64000,
+  // 64K (API enforces 64000)
+  "claude-opus-4-5-20251101": 64000,
+  // 64K
+  "claude-opus-4-1-20250805": 32768,
+  // 32K
+  "claude-sonnet-4-20250514": 64000,
+  // 64K
+  "claude-opus-4-20250514": 32768,
+  // 32K
+  "claude-3-7-sonnet-20250219": 64000,
+  // 64K
+  "claude-3-haiku-20240307": 4096,
+  // 4K
+  // Bedrock — same limits as direct API
+  "anthropic.claude-sonnet-4-6": 64000,
+  "us.anthropic.claude-sonnet-4-20250514-v1:0": 64000,
+  "us.anthropic.claude-sonnet-4-5-20250929-v1:0": 64000,
+  "us.anthropic.claude-haiku-4-5-20251001-v1:0": 64000,
+  // Google Gemini
+  "gemini-3-pro-preview": 65536,
+  "gemini-3-flash-preview": 65536,
+  "gemini-2.5-pro": 65536,
+  "gemini-2.5-flash": 65536,
+  "gemini-2.5-flash-lite": 65536,
+  // OpenAI — GPT-5 family: 128K max output, o-series: 100K
+  "gpt-5": 128000,
+  "gpt-5-mini": 128000,
+  "gpt-5-nano": 128000,
+  "o3": 100000,
+  "o4-mini": 100000,
+  "gpt-4o": 16384
 };
 export function getMaxOutputTokens(model, agentMax) {
-    const modelMax = MODEL_MAX_OUTPUT_TOKENS[model] ?? DEFAULT_OUTPUT_TOKENS;
-    // If caller explicitly sets agentMax, respect it (capped at model max).
-    // Otherwise use sane default — never auto-request 128K output.
-    if (agentMax)
-        return Math.min(agentMax, modelMax);
-    return Math.min(DEFAULT_OUTPUT_TOKENS, modelMax);
+  const modelMax = MODEL_MAX_OUTPUT_TOKENS[model] ?? DEFAULT_OUTPUT_TOKENS;
+  // If caller explicitly sets agentMax, respect it (capped at model max).
+  // Otherwise use sane default — never auto-request 128K output.
+  if (agentMax) return Math.min(agentMax, modelMax);
+  return Math.min(DEFAULT_OUTPUT_TOKENS, modelMax);
 }
+
 // ============================================================================
 // MULTI-BREAKPOINT PROMPT CACHING
 // ============================================================================
+
 /**
  * Add prompt cache breakpoints to tools and messages.
  * Uses 2 of 4 allowed breakpoints:
@@ -170,204 +262,293 @@ export function getMaxOutputTokens(model, agentMax) {
  * System prompt caching is handled by the caller.
  */
 export function addPromptCaching(tools, messages) {
-    const cachedTools = tools.length > 0
-        ? [...tools.slice(0, -1), { ...tools[tools.length - 1], cache_control: { type: "ephemeral" } }]
-        : [...tools];
-    const cachedMessages = [...messages];
-    if (cachedMessages.length >= 2) {
-        const idx = cachedMessages.length - 2;
-        const msg = cachedMessages[idx];
-        if (typeof msg.content === "string") {
-            cachedMessages[idx] = {
-                ...msg,
-                content: [{ type: "text", text: msg.content, cache_control: { type: "ephemeral" } }],
-            };
-        }
-        else if (Array.isArray(msg.content)) {
-            const blocks = [...msg.content];
-            blocks[blocks.length - 1] = { ...blocks[blocks.length - 1], cache_control: { type: "ephemeral" } };
-            cachedMessages[idx] = { ...msg, content: blocks };
+  const cachedTools = tools.length > 0 ? [...tools.slice(0, -1), {
+    ...tools[tools.length - 1],
+    cache_control: {
+      type: "ephemeral"
+    }
+  }] : [...tools];
+  const cachedMessages = [...messages];
+  if (cachedMessages.length >= 2) {
+    const idx = cachedMessages.length - 2;
+    const msg = cachedMessages[idx];
+    if (typeof msg.content === "string") {
+      cachedMessages[idx] = {
+        ...msg,
+        content: [{
+          type: "text",
+          text: msg.content,
+          cache_control: {
+            type: "ephemeral"
+          }
+        }]
+      };
+    } else if (Array.isArray(msg.content)) {
+      const blocks = [...msg.content];
+      blocks[blocks.length - 1] = {
+        ...blocks[blocks.length - 1],
+        cache_control: {
+          type: "ephemeral"
         }
+      };
+      cachedMessages[idx] = {
+        ...msg,
+        content: blocks
+      };
     }
-    return { tools: cachedTools, messages: cachedMessages };
+  }
+  return {
+    tools: cachedTools,
+    messages: cachedMessages
+  };
 }
+
 // ============================================================================
 // LOOP DETECTION
 // ============================================================================
+
 /** djb2 string hash — fast, deterministic, no dependencies */
 export function djb2Hash(str) {
-    let hash = 5381;
-    for (let i = 0; i < str.length; i++) {
-        hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0xffffffff;
-    }
-    return hash.toString(36);
+  let hash = 5381;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) + hash + str.charCodeAt(i) & 0xffffffff;
+  }
+  return hash.toString(36);
 }
 export class LoopDetector {
-    history = [];
-    consecutiveErrors = new Map();
-    turnErrors = 0;
-    turnHadErrors = false;
-    sessionErrors = new Map();
-    failedStrategies = new Set();
-    consecutiveFailedTurns = 0;
-    totalSessionErrors = 0;
-    /** Tracks how many times the same file path has been read this session */
-    fileReadCounts = new Map();
-    static IDENTICAL_CALL_LIMIT = 4;
-    static CONSECUTIVE_ERROR_LIMIT = 3;
-    static TURN_ERROR_LIMIT = 5;
-    static WINDOW = 20;
-    static SESSION_TOOL_ERROR_LIMIT = 10;
-    static CONSECUTIVE_FAILED_TURN_LIMIT = 3;
-    static FILE_READ_LIMIT = 3;
-    /** Get the error-tracking key for a tool call. Tools with an `action` param
-     *  are tracked per-action so e.g. voice/speak failing won't block voice/music_compose. */
-    errorKey(name, input) {
-        if (input && typeof input.action === "string")
-            return `${name}:${input.action}`;
-        return name;
+  history = [];
+  consecutiveErrors = new Map();
+  turnErrors = 0;
+  turnHadErrors = false;
+  sessionErrors = new Map();
+  failedStrategies = new Set();
+  consecutiveFailedTurns = 0;
+  totalSessionErrors = 0;
+
+  /** Tracks how many times the same file path has been read this session */
+  fileReadCounts = new Map();
+
+  /** Resolved config — accepts DB overrides, falls back to AGENT_DEFAULTS */
+
+  constructor(config) {
+    this.config = {
+      identicalCallLimit: config?.identicalCallLimit ?? AGENT_DEFAULTS.loopIdenticalCallLimit,
+      consecutiveErrorLimit: config?.consecutiveErrorLimit ?? AGENT_DEFAULTS.loopConsecutiveErrorLimit,
+      turnErrorLimit: config?.turnErrorLimit ?? AGENT_DEFAULTS.loopTurnErrorLimit,
+      window: config?.window ?? AGENT_DEFAULTS.loopWindow,
+      sessionToolErrorLimit: config?.sessionToolErrorLimit ?? AGENT_DEFAULTS.loopSessionToolErrorLimit,
+      consecutiveFailedTurnLimit: config?.consecutiveFailedTurnLimit ?? AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit,
+      fileReadLimit: config?.fileReadLimit ?? AGENT_DEFAULTS.loopFileReadLimit
+    };
+  }
+
+  /** Create a LoopDetector from a ResolvedAgentLoopConfig */
+  static fromResolved(resolved) {
+    return new LoopDetector({
+      identicalCallLimit: resolved.loopIdenticalCallLimit,
+      consecutiveErrorLimit: resolved.loopConsecutiveErrorLimit,
+      turnErrorLimit: resolved.loopTurnErrorLimit,
+      window: resolved.loopWindow,
+      sessionToolErrorLimit: resolved.loopSessionToolErrorLimit,
+      consecutiveFailedTurnLimit: resolved.loopConsecutiveFailedTurnLimit,
+      fileReadLimit: resolved.loopFileReadLimit
+    });
+  }
+
+  /** Get the error-tracking key for a tool call. Tools with an `action` param
+   *  are tracked per-action so e.g. voice/speak failing won't block voice/music_compose. */
+  errorKey(name, input) {
+    if (input && typeof input.action === "string") return `${name}:${input.action}`;
+    return name;
+  }
+  recordCall(name, input) {
+    const inputHash = djb2Hash(JSON.stringify({
+      name,
+      ...input
+    }));
+    const eKey = this.errorKey(name, input);
+    if (this.failedStrategies.has(inputHash)) {
+      return {
+        blocked: true,
+        reason: `Blocked: this exact "${name}" call failed in a previous turn. Try a fundamentally different approach.`
+      };
     }
-    recordCall(name, input) {
-        const inputHash = djb2Hash(JSON.stringify({ name, ...input }));
-        const eKey = this.errorKey(name, input);
-        if (this.failedStrategies.has(inputHash)) {
-            return {
-                blocked: true,
-                reason: `Blocked: this exact "${name}" call failed in a previous turn. Try a fundamentally different approach.`,
-            };
-        }
-        const sessionErrorCount = this.sessionErrors.get(eKey) || 0;
-        if (sessionErrorCount >= LoopDetector.SESSION_TOOL_ERROR_LIMIT) {
-            return {
-                blocked: true,
-                reason: `Tool "${name}" (action: ${input.action || "default"}) has failed ${sessionErrorCount} times this session. Stop using this tool and try a different approach.`,
-            };
-        }
-        if (this.turnErrors >= LoopDetector.TURN_ERROR_LIMIT) {
-            return {
-                blocked: true,
-                reason: `${this.turnErrors} errors this turn. Stop and re-assess your approach.`,
-            };
-        }
-        const errorCount = this.consecutiveErrors.get(eKey) || 0;
-        if (errorCount >= LoopDetector.CONSECUTIVE_ERROR_LIMIT) {
-            return {
-                blocked: true,
-                reason: `Tool "${name}" (action: ${input.action || "default"}) blocked: failed ${errorCount} times consecutively. Try a different approach or action.`,
-            };
-        }
-        const windowSlice = this.history.slice(-LoopDetector.WINDOW);
-        const identicalCount = windowSlice.filter((h) => h.inputHash === inputHash).length;
-        if (identicalCount >= LoopDetector.IDENTICAL_CALL_LIMIT) {
-            return {
-                blocked: true,
-                reason: `Tool "${name}" blocked: identical call made ${identicalCount} times. Try different parameters.`,
-            };
-        }
-        this.history.push({ name, inputHash });
-        if (this.history.length > LoopDetector.WINDOW * 2) {
-            this.history = this.history.slice(-LoopDetector.WINDOW);
-        }
-        return { blocked: false };
+    const sessionErrorCount = this.sessionErrors.get(eKey) || 0;
+    if (sessionErrorCount >= this.config.sessionToolErrorLimit) {
+      return {
+        blocked: true,
+        reason: `Tool "${name}" (action: ${input.action || "default"}) has failed ${sessionErrorCount} times this session. Stop using this tool and try a different approach.`
+      };
     }
-    /**
-     * Track file read frequency — call when the tool is known to be a file read.
-     * Blocks re-reading the same path more than FILE_READ_LIMIT times per session.
-     */
-    trackRead(path) {
-        const readCount = (this.fileReadCounts.get(path) || 0) + 1;
-        this.fileReadCounts.set(path, readCount);
-        if (readCount > LoopDetector.FILE_READ_LIMIT) {
-            return {
-                blocked: true,
-                reason: `File "${path}" already read ${readCount - 1} times this session. Use the content from a previous read instead of re-reading.`,
-            };
-        }
-        return { blocked: false };
+    if (this.turnErrors >= this.config.turnErrorLimit) {
+      return {
+        blocked: true,
+        reason: `${this.turnErrors} errors this turn. Stop and re-assess your approach.`
+      };
     }
-    recordResult(name, success, input) {
-        const eKey = this.errorKey(name, input);
-        if (success) {
-            this.consecutiveErrors.delete(eKey);
-        }
-        else {
-            const current = this.consecutiveErrors.get(eKey) || 0;
-            this.consecutiveErrors.set(eKey, current + 1);
-            this.turnErrors++;
-            this.turnHadErrors = true;
-            const sessionCount = this.sessionErrors.get(eKey) || 0;
-            this.sessionErrors.set(eKey, sessionCount + 1);
-            this.totalSessionErrors++;
-            if (input) {
-                const inputHash = djb2Hash(JSON.stringify({ name, ...input }));
-                this.failedStrategies.add(inputHash);
-                if (this.failedStrategies.size > 200) {
-                    const arr = Array.from(this.failedStrategies);
-                    this.failedStrategies = new Set(arr.slice(-100));
-                }
-            }
-        }
+    const errorCount = this.consecutiveErrors.get(eKey) || 0;
+    if (errorCount >= this.config.consecutiveErrorLimit) {
+      return {
+        blocked: true,
+        reason: `Tool "${name}" (action: ${input.action || "default"}) blocked: failed ${errorCount} times consecutively. Try a different approach or action.`
+      };
     }
-    endTurn() {
-        if (this.turnHadErrors) {
-            this.consecutiveFailedTurns++;
-        }
-        else {
-            this.consecutiveFailedTurns = 0;
-            // A clean turn means the agent has recovered — unblock previously failed strategies
-            // so it can retry calls that failed due to bad params (e.g., wrong UUID format)
-            this.failedStrategies.clear();
-            // Decay session error counts on clean turns so tools aren't permanently blocked.
-            // Each clean turn halves all session error counts, allowing recovery from
-            // transient issues while still blocking persistently broken tools.
-            if (this.sessionErrors.size > 0) {
-                for (const [key, count] of this.sessionErrors) {
-                    const decayed = Math.floor(count / 2);
-                    if (decayed <= 0) {
-                        this.sessionErrors.delete(key);
-                    }
-                    else {
-                        this.sessionErrors.set(key, decayed);
-                    }
-                }
-            }
-        }
-        // Reset turn-level counters so the NEXT dispatch batch starts fresh.
-        // Session-level counters (sessionErrors, consecutiveFailedTurns) persist.
-        this.turnErrors = 0;
-        this.turnHadErrors = false;
-        if (this.consecutiveFailedTurns >= LoopDetector.CONSECUTIVE_FAILED_TURN_LIMIT) {
-            return {
-                shouldBail: true,
-                message: `You have had errors in ${this.consecutiveFailedTurns} consecutive turns (${this.totalSessionErrors} total errors). Your approach is not working. STOP and explain to the user what's failing.`,
-            };
+    const windowSlice = this.history.slice(-this.config.window);
+    const identicalCount = windowSlice.filter(h => h.inputHash === inputHash).length;
+    if (identicalCount >= this.config.identicalCallLimit) {
+      return {
+        blocked: true,
+        reason: `Tool "${name}" blocked: identical call made ${identicalCount} times. Try different parameters.`
+      };
+    }
+    this.history.push({
+      name,
+      inputHash
+    });
+    if (this.history.length > this.config.window * 2) {
+      this.history = this.history.slice(-this.config.window);
+    }
+    return {
+      blocked: false
+    };
+  }
+
+  /**
+   * Track file read frequency — call when the tool is known to be a file read.
+   * Blocks re-reading the same path more than FILE_READ_LIMIT times per session.
+   */
+  trackRead(path) {
+    const readCount = (this.fileReadCounts.get(path) || 0) + 1;
+    this.fileReadCounts.set(path, readCount);
+    if (readCount > this.config.fileReadLimit) {
+      return {
+        blocked: true,
+        reason: `File "${path}" already read ${readCount - 1} times this session. Use the content from a previous read instead of re-reading.`
+      };
+    }
+    return {
+      blocked: false
+    };
+  }
+
+  /**
+   * Record a tool execution result.
+   * @param transient - If true, the failure is transient (timeout, rate limit)
+   *   and should NOT be added to failedStrategies. Transient failures are
+   *   retryable with the exact same inputs — e.g., a task_output poll that
+   *   timed out because the task is still running.
+   */
+  recordResult(name, success, input, transient) {
+    const eKey = this.errorKey(name, input);
+    if (success) {
+      this.consecutiveErrors.delete(eKey);
+    } else {
+      const current = this.consecutiveErrors.get(eKey) || 0;
+      this.consecutiveErrors.set(eKey, current + 1);
+      this.turnErrors++;
+      this.turnHadErrors = true;
+      const sessionCount = this.sessionErrors.get(eKey) || 0;
+      this.sessionErrors.set(eKey, sessionCount + 1);
+      this.totalSessionErrors++;
+
+      // Only add to failedStrategies for non-transient errors.
+      // Transient errors (timeouts, rate limits) should be retryable with
+      // the exact same inputs — blocking them creates a deadlock for polling
+      // tools like task_output where the input (task_id) never changes.
+      if (input && !transient) {
+        const inputHash = djb2Hash(JSON.stringify({
+          name,
+          ...input
+        }));
+        this.failedStrategies.add(inputHash);
+        if (this.failedStrategies.size > 200) {
+          const arr = Array.from(this.failedStrategies);
+          this.failedStrategies = new Set(arr.slice(-100));
         }
-        return { shouldBail: false };
+      }
     }
-    resetTurn() {
-        // Only reset per-turn counters — history and consecutiveErrors persist
-        // for cross-turn detection. The full reset() clears everything for new sessions.
-        this.turnErrors = 0;
-        this.turnHadErrors = false;
+  }
+  endTurn() {
+    if (this.turnHadErrors) {
+      this.consecutiveFailedTurns++;
+    } else {
+      this.consecutiveFailedTurns = 0;
+      // A clean turn means the agent has recovered — unblock previously failed strategies
+      // so it can retry calls that failed due to bad params (e.g., wrong UUID format)
+      this.failedStrategies.clear();
+      // Decay session error counts on clean turns so tools aren't permanently blocked.
+      // Each clean turn halves all session error counts, allowing recovery from
+      // transient issues while still blocking persistently broken tools.
+      if (this.sessionErrors.size > 0) {
+        for (const [key, count] of this.sessionErrors) {
+          const decayed = Math.floor(count / 2);
+          if (decayed <= 0) {
+            this.sessionErrors.delete(key);
+          } else {
+            this.sessionErrors.set(key, decayed);
+          }
+        }
+      }
     }
-    reset() {
-        this.resetTurn();
-        this.history = [];
-        this.consecutiveErrors.clear();
-        this.sessionErrors.clear();
-        this.failedStrategies.clear();
-        this.fileReadCounts.clear();
-        this.consecutiveFailedTurns = 0;
-        this.totalSessionErrors = 0;
+
+    // Cap consecutiveErrors so a single bad batch (parallel Promise.all) can't
+    // permanently brick a tool. Without this, N parallel failures push
+    // consecutiveErrors to N, which exceeds consecutiveErrorLimit and creates
+    // a deadlock: the tool is blocked because it failed, but can't succeed to
+    // unblock itself because it's blocked. Capping to (limit - 1) gives the
+    // tool one retry on the next turn. Only permanently block after multiple
+    // consecutive failed turns (handled by the bail-out check below).
+    if (this.consecutiveFailedTurns < this.config.consecutiveFailedTurnLimit) {
+      for (const [key, count] of this.consecutiveErrors) {
+        if (count >= this.config.consecutiveErrorLimit) {
+          this.consecutiveErrors.set(key, this.config.consecutiveErrorLimit - 1);
+        }
+      }
     }
-    getSessionStats() {
-        return {
-            totalErrors: this.totalSessionErrors,
-            failedStrategies: this.failedStrategies.size,
-            consecutiveFailedTurns: this.consecutiveFailedTurns,
-        };
+
+    // Reset turn-level counters so the NEXT dispatch batch starts fresh.
+    // Session-level counters (sessionErrors, consecutiveFailedTurns) persist.
+    this.turnErrors = 0;
+    this.turnHadErrors = false;
+    if (this.consecutiveFailedTurns >= this.config.consecutiveFailedTurnLimit) {
+      return {
+        shouldBail: true,
+        message: `You have had errors in ${this.consecutiveFailedTurns} consecutive turns (${this.totalSessionErrors} total errors). Your approach is not working. STOP and explain to the user what's failing.`
+      };
     }
+    return {
+      shouldBail: false
+    };
+  }
+  resetTurn() {
+    // Only reset per-turn counters — history and consecutiveErrors persist
+    // for cross-turn detection. The full reset() clears everything for new sessions.
+    this.turnErrors = 0;
+    this.turnHadErrors = false;
+  }
+  reset() {
+    this.resetTurn();
+    this.history = [];
+    this.consecutiveErrors.clear();
+    this.sessionErrors.clear();
+    this.failedStrategies.clear();
+    this.fileReadCounts.clear();
+    this.consecutiveFailedTurns = 0;
+    this.totalSessionErrors = 0;
+  }
+  getSessionStats() {
+    return {
+      totalErrors: this.totalSessionErrors,
+      failedStrategies: this.failedStrategies.size,
+      consecutiveFailedTurns: this.consecutiveFailedTurns
+    };
+  }
 }
+
+// ============================================================================
+// EXTENDED THINKING
+// ============================================================================
+
 /**
  * Returns the thinking configuration and required beta string for the given model.
  * - Opus 4.6: adaptive thinking (no budget needed)
@@ -375,195 +556,365 @@ export class LoopDetector {
  * - budget_tokens must be strictly < max_tokens
  */
 export function getThinkingConfig(model, enabled) {
-    if (!enabled) {
-        return { thinking: { type: "disabled" }, beta: "" };
-    }
-    const provider = getProvider(model);
-    // Gemini models: thinking is always-on for 2.5+/3.x — signal pass-through
-    if (provider === "gemini") {
-        return { thinking: { type: "enabled" }, beta: "" };
-    }
-    // OpenAI models: reasoning models (o-series) have built-in reasoning, GPT models don't support thinking
-    if (provider === "openai") {
-        const isReasoning = /^o\d/.test(model);
-        return { thinking: { type: isReasoning ? "enabled" : "disabled" }, beta: "" };
-    }
-    if (model.includes("opus-4-6") || model.includes("sonnet-4-6")) {
-        return {
-            thinking: { type: "adaptive" },
-            beta: "adaptive-thinking-2026-01-28",
-        };
-    }
-    // Sonnet 4.5/4.0 / Haiku: fixed budget
+  if (!enabled) {
+    return {
+      thinking: {
+        type: "disabled"
+      },
+      beta: ""
+    };
+  }
+  const provider = getProvider(model);
+
+  // Gemini models: thinking is always-on for 2.5+/3.x — signal pass-through
+  if (provider === "gemini") {
+    return {
+      thinking: {
+        type: "enabled"
+      },
+      beta: ""
+    };
+  }
+
+  // OpenAI models: reasoning models (o-series) have built-in reasoning, GPT models don't support thinking
+  if (provider === "openai") {
+    const isReasoning = /^o\d/.test(model);
     return {
-        thinking: { type: "enabled", budget_tokens: 10_000 },
-        beta: "interleaved-thinking-2025-05-14",
+      thinking: {
+        type: isReasoning ? "enabled" : "disabled"
+      },
+      beta: ""
     };
+  }
+  if (model.includes("opus-4-6") || model.includes("sonnet-4-6")) {
+    return {
+      thinking: {
+        type: "adaptive"
+      },
+      beta: "adaptive-thinking-2026-01-28"
+    };
+  }
+
+  // Sonnet 4.5/4.0 / Haiku: fixed budget (matches Claude Code's 31,999 default)
+  return {
+    thinking: {
+      type: "enabled",
+      budget_tokens: 31_999
+    },
+    beta: "interleaved-thinking-2025-05-14"
+  };
 }
+
 // ============================================================================
 // COST TRACKING
 // ============================================================================
+
 export const MODEL_PRICING = {
-    // Anthropic direct — Claude 4.x
-    "claude-sonnet-4-6": { inputPer1M: 3.0, outputPer1M: 15.0, thinkingPer1M: 15.0 },
-    "claude-sonnet-4-20250514": { inputPer1M: 3.0, outputPer1M: 15.0, thinkingPer1M: 15.0 },
-    "claude-sonnet-4-5-20250929": { inputPer1M: 3.0, outputPer1M: 15.0, thinkingPer1M: 15.0 },
-    "claude-opus-4-6": { inputPer1M: 5.0, outputPer1M: 25.0, thinkingPer1M: 25.0 },
-    "claude-opus-4-20250514": { inputPer1M: 5.0, outputPer1M: 25.0, thinkingPer1M: 25.0 },
-    "claude-opus-4-5-20251101": { inputPer1M: 5.0, outputPer1M: 25.0, thinkingPer1M: 25.0 },
-    "claude-haiku-4-20250514": { inputPer1M: 1.0, outputPer1M: 5.0, thinkingPer1M: 5.0 },
-    "claude-haiku-4-5-20251001": { inputPer1M: 1.0, outputPer1M: 5.0, thinkingPer1M: 5.0 },
-    // Anthropic direct — Claude 3.5
-    "claude-3-5-sonnet-20241022": { inputPer1M: 3.0, outputPer1M: 15.0 },
-    "claude-3-5-haiku-20241022": { inputPer1M: 0.80, outputPer1M: 4.0 },
-    // Bedrock — Claude 4.x
-    "anthropic.claude-sonnet-4-6": { inputPer1M: 3.0, outputPer1M: 15.0, thinkingPer1M: 15.0 },
-    "us.anthropic.claude-sonnet-4-20250514-v1:0": { inputPer1M: 3.0, outputPer1M: 15.0, thinkingPer1M: 15.0 },
-    "us.anthropic.claude-sonnet-4-5-20250929-v1:0": { inputPer1M: 3.0, outputPer1M: 15.0, thinkingPer1M: 15.0 },
-    "us.anthropic.claude-haiku-4-5-20251001-v1:0": { inputPer1M: 1.0, outputPer1M: 5.0, thinkingPer1M: 5.0 },
-    // Bedrock — Claude 3.5
-    "us.anthropic.claude-3-5-haiku-20241022-v1:0": { inputPer1M: 0.80, outputPer1M: 4.0 },
-    // Bedrock — Llama & Nova
-    "us.meta.llama3-1-70b-instruct-v1:0": { inputPer1M: 0.72, outputPer1M: 0.72 },
-    "us.amazon.nova-pro-v1:0": { inputPer1M: 0.80, outputPer1M: 3.20 },
-    // Gemini (thinking tokens are cheaper than output)
-    "gemini-3-pro-preview": { inputPer1M: 1.25, outputPer1M: 10.0, thinkingPer1M: 2.50 },
-    "gemini-3-flash-preview": { inputPer1M: 0.15, outputPer1M: 0.60, thinkingPer1M: 0.15 },
-    "gemini-2.5-pro": { inputPer1M: 1.25, outputPer1M: 10.0, thinkingPer1M: 2.50 },
-    "gemini-2.5-flash": { inputPer1M: 0.15, outputPer1M: 0.60, thinkingPer1M: 0.15 },
-    "gemini-2.5-flash-lite": { inputPer1M: 0.075, outputPer1M: 0.30, thinkingPer1M: 0.075 },
-    "gemini-2.0-flash": { inputPer1M: 0.10, outputPer1M: 0.40 },
-    "gemini-2.0-flash-lite": { inputPer1M: 0.075, outputPer1M: 0.30 },
-    // OpenAI — GPT
-    "gpt-5": { inputPer1M: 1.25, outputPer1M: 10.0 },
-    "gpt-5-mini": { inputPer1M: 0.25, outputPer1M: 2.0 },
-    "gpt-5-nano": { inputPer1M: 0.05, outputPer1M: 0.40 },
-    "gpt-4o": { inputPer1M: 2.50, outputPer1M: 10.0 },
-    "gpt-4o-mini": { inputPer1M: 0.15, outputPer1M: 0.60 },
-    "gpt-4-turbo": { inputPer1M: 10.0, outputPer1M: 30.0 },
-    // OpenAI — reasoning models
-    "o1": { inputPer1M: 15.0, outputPer1M: 60.0, thinkingPer1M: 60.0 },
-    "o1-mini": { inputPer1M: 3.0, outputPer1M: 12.0, thinkingPer1M: 12.0 },
-    "o3": { inputPer1M: 2.0, outputPer1M: 8.0, thinkingPer1M: 8.0 },
-    "o3-mini": { inputPer1M: 1.10, outputPer1M: 4.40, thinkingPer1M: 4.40 },
-    "o4-mini": { inputPer1M: 1.10, outputPer1M: 4.40, thinkingPer1M: 4.40 },
+  // Anthropic direct — Claude 4.x
+  "claude-sonnet-4-6": {
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    thinkingPer1M: 15.0
+  },
+  "claude-sonnet-4-20250514": {
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    thinkingPer1M: 15.0
+  },
+  "claude-sonnet-4-5-20250929": {
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    thinkingPer1M: 15.0
+  },
+  "claude-opus-4-6": {
+    inputPer1M: 5.0,
+    outputPer1M: 25.0,
+    thinkingPer1M: 25.0
+  },
+  "claude-opus-4-20250514": {
+    inputPer1M: 5.0,
+    outputPer1M: 25.0,
+    thinkingPer1M: 25.0
+  },
+  "claude-opus-4-5-20251101": {
+    inputPer1M: 5.0,
+    outputPer1M: 25.0,
+    thinkingPer1M: 25.0
+  },
+  "claude-haiku-4-20250514": {
+    inputPer1M: 1.0,
+    outputPer1M: 5.0,
+    thinkingPer1M: 5.0
+  },
+  "claude-haiku-4-5-20251001": {
+    inputPer1M: 1.0,
+    outputPer1M: 5.0,
+    thinkingPer1M: 5.0
+  },
+  // Anthropic direct — Claude 3.5
+  "claude-3-5-sonnet-20241022": {
+    inputPer1M: 3.0,
+    outputPer1M: 15.0
+  },
+  "claude-3-5-haiku-20241022": {
+    inputPer1M: 0.80,
+    outputPer1M: 4.0
+  },
+  // Bedrock — Claude 4.x
+  "anthropic.claude-sonnet-4-6": {
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    thinkingPer1M: 15.0
+  },
+  "us.anthropic.claude-sonnet-4-20250514-v1:0": {
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    thinkingPer1M: 15.0
+  },
+  "us.anthropic.claude-sonnet-4-5-20250929-v1:0": {
+    inputPer1M: 3.0,
+    outputPer1M: 15.0,
+    thinkingPer1M: 15.0
+  },
+  "us.anthropic.claude-haiku-4-5-20251001-v1:0": {
+    inputPer1M: 1.0,
+    outputPer1M: 5.0,
+    thinkingPer1M: 5.0
+  },
+  // Bedrock — Claude 3.5
+  "us.anthropic.claude-3-5-haiku-20241022-v1:0": {
+    inputPer1M: 0.80,
+    outputPer1M: 4.0
+  },
+  // Bedrock — Llama & Nova
+  "us.meta.llama3-1-70b-instruct-v1:0": {
+    inputPer1M: 0.72,
+    outputPer1M: 0.72
+  },
+  "us.amazon.nova-pro-v1:0": {
+    inputPer1M: 0.80,
+    outputPer1M: 3.20
+  },
+  // Gemini (thinking tokens are cheaper than output)
+  "gemini-3-pro-preview": {
+    inputPer1M: 1.25,
+    outputPer1M: 10.0,
+    thinkingPer1M: 2.50
+  },
+  "gemini-3-flash-preview": {
+    inputPer1M: 0.15,
+    outputPer1M: 0.60,
+    thinkingPer1M: 0.15
+  },
+  "gemini-2.5-pro": {
+    inputPer1M: 1.25,
+    outputPer1M: 10.0,
+    thinkingPer1M: 2.50
+  },
+  "gemini-2.5-flash": {
+    inputPer1M: 0.15,
+    outputPer1M: 0.60,
+    thinkingPer1M: 0.15
+  },
+  "gemini-2.5-flash-lite": {
+    inputPer1M: 0.075,
+    outputPer1M: 0.30,
+    thinkingPer1M: 0.075
+  },
+  "gemini-2.0-flash": {
+    inputPer1M: 0.10,
+    outputPer1M: 0.40
+  },
+  "gemini-2.0-flash-lite": {
+    inputPer1M: 0.075,
+    outputPer1M: 0.30
+  },
+  // OpenAI — GPT
+  "gpt-5": {
+    inputPer1M: 1.25,
+    outputPer1M: 10.0
+  },
+  "gpt-5-mini": {
+    inputPer1M: 0.25,
+    outputPer1M: 2.0
+  },
+  "gpt-5-nano": {
+    inputPer1M: 0.05,
+    outputPer1M: 0.40
+  },
+  "gpt-4o": {
+    inputPer1M: 2.50,
+    outputPer1M: 10.0
+  },
+  "gpt-4o-mini": {
+    inputPer1M: 0.15,
+    outputPer1M: 0.60
+  },
+  "gpt-4-turbo": {
+    inputPer1M: 10.0,
+    outputPer1M: 30.0
+  },
+  // OpenAI — reasoning models
+  "o1": {
+    inputPer1M: 15.0,
+    outputPer1M: 60.0,
+    thinkingPer1M: 60.0
+  },
+  "o1-mini": {
+    inputPer1M: 3.0,
+    outputPer1M: 12.0,
+    thinkingPer1M: 12.0
+  },
+  "o3": {
+    inputPer1M: 2.0,
+    outputPer1M: 8.0,
+    thinkingPer1M: 8.0
+  },
+  "o3-mini": {
+    inputPer1M: 1.10,
+    outputPer1M: 4.40,
+    thinkingPer1M: 4.40
+  },
+  "o4-mini": {
+    inputPer1M: 1.10,
+    outputPer1M: 4.40,
+    thinkingPer1M: 4.40
+  }
 };
+
 /**
  * Emit graduated cost warnings at 25%, 50%, 75% thresholds.
  * Single source of truth — replaces copy-pasted blocks in server + CLI.
  */
 export function emitCostWarningIfNeeded(sessionCostUsd, maxCostUsd, costWarningsEmitted, onText) {
-    if (!isFinite(maxCostUsd) || !onText)
-        return;
-    for (const pct of [25, 50, 75]) {
-        if (!costWarningsEmitted.has(pct) && sessionCostUsd >= maxCostUsd * (pct / 100)) {
-            costWarningsEmitted.add(pct);
-            onText(`\n[Cost warning: ${pct}% of budget used ($${sessionCostUsd.toFixed(2)}/$${maxCostUsd.toFixed(2)}).${pct >= 75 ? " Wrap up soon." : ""}]`);
-        }
+  if (!isFinite(maxCostUsd) || !onText) return;
+  for (const pct of [25, 50, 75]) {
+    if (!costWarningsEmitted.has(pct) && sessionCostUsd >= maxCostUsd * (pct / 100)) {
+      costWarningsEmitted.add(pct);
+      onText(`\n[Cost warning: ${pct}% of budget used ($${sessionCostUsd.toFixed(2)}/$${maxCostUsd.toFixed(2)}).${pct >= 75 ? " Wrap up soon." : ""}]`);
     }
+  }
 }
 export function estimateCostUsd(inputTokens, outputTokens, model, thinkingTokens = 0, cacheReadTokens = 0, cacheCreationTokens = 0) {
-    // Exact match first, then find a pricing key that is a prefix of the model ID
-    const pricing = MODEL_PRICING[model]
-        || MODEL_PRICING[Object.keys(MODEL_PRICING).find((k) => model.startsWith(k)) ?? ""]
-        || MODEL_PRICING["claude-sonnet-4-6"];
-    const thinkingRate = pricing.thinkingPer1M || pricing.outputPer1M;
-    const inputRate = pricing.inputPer1M;
-    // Base cost
-    let cost = (inputTokens / 1_000_000) * inputRate
-        + (outputTokens / 1_000_000) * pricing.outputPer1M
-        + (thinkingTokens / 1_000_000) * thinkingRate;
-    // Cache pricing — subtract savings for cached tokens
-    // Anthropic/Bedrock: cache reads 90% cheaper, cache creation 25% surcharge
-    // OpenAI: cache reads 50% cheaper, no creation surcharge
-    // Gemini: cache reads 75% cheaper
-    if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
-        const provider = getProvider(model);
-        if (provider === "anthropic" || provider === "bedrock") {
-            cost -= (cacheReadTokens / 1_000_000) * inputRate * 0.9;
-            cost += (cacheCreationTokens / 1_000_000) * inputRate * 0.25;
-        }
-        else if (provider === "openai") {
-            cost -= (cacheReadTokens / 1_000_000) * inputRate * 0.5;
-        }
-        else if (provider === "gemini") {
-            cost -= (cacheReadTokens / 1_000_000) * inputRate * 0.75;
-        }
+  // Exact match first, then find a pricing key that is a prefix of the model ID
+  const pricing = MODEL_PRICING[model] || MODEL_PRICING[Object.keys(MODEL_PRICING).find(k => model.startsWith(k)) ?? ""] || MODEL_PRICING["claude-sonnet-4-6"];
+  const thinkingRate = pricing.thinkingPer1M || pricing.outputPer1M;
+  const inputRate = pricing.inputPer1M;
+
+  // Base cost
+  let cost = inputTokens / 1_000_000 * inputRate + outputTokens / 1_000_000 * pricing.outputPer1M + thinkingTokens / 1_000_000 * thinkingRate;
+
+  // Cache pricing — subtract savings for cached tokens
+  // Anthropic/Bedrock: cache reads 90% cheaper, cache creation 25% surcharge
+  // OpenAI: cache reads 50% cheaper, no creation surcharge
+  // Gemini: cache reads 75% cheaper
+  if (cacheReadTokens > 0 || cacheCreationTokens > 0) {
+    const provider = getProvider(model);
+    if (provider === "anthropic" || provider === "bedrock") {
+      cost -= cacheReadTokens / 1_000_000 * inputRate * 0.9;
+      cost += cacheCreationTokens / 1_000_000 * inputRate * 0.25;
+    } else if (provider === "openai") {
+      cost -= cacheReadTokens / 1_000_000 * inputRate * 0.5;
+    } else if (provider === "gemini") {
+      cost -= cacheReadTokens / 1_000_000 * inputRate * 0.75;
     }
-    return cost;
+  }
+  return cost;
 }
+
 // ============================================================================
 // MODEL ROUTING BY TASK COMPLEXITY
 // ============================================================================
+
 /**
  * Route to cheaper model when the task is simple enough.
  * Returns the model to actually use.
  */
 export function routeModel(message, requestedModel, forceModel) {
-    // If user explicitly picked a model, respect it
-    if (forceModel)
-        return requestedModel;
-    // Estimate token count (rough: 1 token ~= 4 chars)
-    const estimatedTokens = Math.ceil(message.length / 4);
-    // Simple queries → Haiku (30x cheaper than Opus)
-    const simplePatterns = /^(what|who|when|where|show|list|get|find|look ?up|check)\b/i;
-    const complexPatterns = /\b(analyze|implement|refactor|design|architect|debug|explain why|compare|evaluate|write|create|build|fix)\b/i;
-    if (estimatedTokens < 50 && simplePatterns.test(message) && !complexPatterns.test(message)) {
-        return "claude-haiku-4-5-20251001";
-    }
-    // Medium queries → Sonnet
-    if (estimatedTokens < 200 && !complexPatterns.test(message)) {
-        return "claude-sonnet-4-5-20250929";
-    }
-    // Complex → honor requested model
-    return requestedModel;
+  // If user explicitly picked a model, respect it
+  if (forceModel) return requestedModel;
+
+  // Estimate token count (rough: 1 token ~= 4 chars)
+  const estimatedTokens = Math.ceil(message.length / 4);
+
+  // Simple queries → Haiku (30x cheaper than Opus)
+  const simplePatterns = /^(what|who|when|where|show|list|get|find|look ?up|check)\b/i;
+  const complexPatterns = /\b(analyze|implement|refactor|design|architect|debug|explain why|compare|evaluate|write|create|build|fix)\b/i;
+  if (estimatedTokens < 50 && simplePatterns.test(message) && !complexPatterns.test(message)) {
+    return "claude-haiku-4-5-20251001";
+  }
+
+  // Medium queries → Sonnet
+  if (estimatedTokens < 200 && !complexPatterns.test(message)) {
+    return "claude-sonnet-4-5-20250929";
+  }
+
+  // Complex → honor requested model
+  return requestedModel;
 }
+
+// ============================================================================
+// ERROR CATEGORIZATION
+// ============================================================================
+
 export function categorizeError(err) {
-    const e = err;
-    const status = e?.status || e?.statusCode;
-    const msg = String(e?.message || "").toLowerCase();
-    if (status === 429 || msg.includes("rate limit")) {
-        return { category: "RATE_LIMIT", retryable: true };
-    }
-    if (status === 401 || status === 403 || msg.includes("unauthorized") || msg.includes("forbidden") || msg.includes("invalid api key")) {
-        return { category: "AUTH", retryable: false };
-    }
-    if (status === 400 || msg.includes("malformed") || msg.includes("invalid") || msg.includes("validation")) {
-        return { category: "MALFORMED", retryable: false };
-    }
-    if (status === 500 || status === 502 || status === 503 || status === 529 || msg.includes("overloaded") || msg.includes("internal server error")) {
-        return { category: "PROVIDER_DOWN", retryable: true };
-    }
-    if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("deadline") || msg.includes("econnreset")) {
-        return { category: "TIMEOUT", retryable: true };
-    }
-    if (msg.includes("econnrefused") || msg.includes("enetunreach") || msg.includes("enotfound") || msg.includes("fetch failed") || msg.includes("network")) {
-        return { category: "NETWORK", retryable: true };
-    }
-    return { category: "UNKNOWN", retryable: false };
+  const e = err;
+  const status = e?.status || e?.statusCode;
+  const msg = String(e?.message || "").toLowerCase();
+  if (status === 429 || msg.includes("rate limit")) {
+    return {
+      category: "RATE_LIMIT",
+      retryable: true
+    };
+  }
+  if (status === 401 || status === 403 || msg.includes("unauthorized") || msg.includes("forbidden") || msg.includes("invalid api key")) {
+    return {
+      category: "AUTH",
+      retryable: false
+    };
+  }
+  if (status === 400 || msg.includes("malformed") || msg.includes("invalid") || msg.includes("validation")) {
+    return {
+      category: "MALFORMED",
+      retryable: false
+    };
+  }
+  if (status === 500 || status === 502 || status === 503 || status === 529 || msg.includes("overloaded") || msg.includes("internal server error")) {
+    return {
+      category: "PROVIDER_DOWN",
+      retryable: true
+    };
+  }
+  if (msg.includes("timeout") || msg.includes("timed out") || msg.includes("deadline") || msg.includes("econnreset") || msg.includes("stream stalled")) {
+    return {
+      category: "TIMEOUT",
+      retryable: true
+    };
+  }
+  if (msg.includes("econnrefused") || msg.includes("enetunreach") || msg.includes("enotfound") || msg.includes("fetch failed") || msg.includes("network")) {
+    return {
+      category: "NETWORK",
+      retryable: true
+    };
+  }
+  return {
+    category: "UNKNOWN",
+    retryable: false
+  };
 }
+
 // ============================================================================
 // RETRY LOGIC
 // ============================================================================
+
 export function isRetryableError(err) {
-    return categorizeError(err).retryable;
+  return categorizeError(err).retryable;
 }
+
 // ============================================================================
-// TOOL RESULT TRUNCATION (deprecated — Anthropic context_management handles limits)
-// ============================================================================
-/** @deprecated — Anthropic context_management handles limits. Use SAFETY_MAX_CHARS in tool-dispatch instead. */
-export function truncateToolResult(content, maxChars) {
-    if (content.length <= maxChars)
-        return content;
-    return content.slice(0, maxChars) + `\n\n... (truncated — ${content.length.toLocaleString()} chars total)`;
-}
-/** @deprecated — Anthropic context_management handles limits. */
-export function getMaxToolResultChars(contextConfig) {
-    return contextConfig?.max_tool_result_chars || 80_000;
-}
-// ============================================================================
-// UTILITY — sanitize errors (strip API keys, passwords)
+// UTILITY — model demotion, sanitize errors
 // ============================================================================
+
 /**
  * Demote subagent model requests — single source of truth for server + CLI.
  * - explore/research: always haiku
@@ -571,25 +922,183 @@ export function getMaxToolResultChars(contextConfig) {
  * - sonnet: kept for plan, demoted to haiku for others
  * - default/undefined: haiku
  */
+/**
+ * Resolve subagent model based on agent type and request.
+ *
+ * Claude Code behavior: general-purpose and plan subagents inherit the parent
+ * model (they do real work / need full reasoning). Only explore and research
+ * are demoted to haiku (fast, focused tasks).
+ */
 export function demoteSubagentModel(requested, agentType) {
-    if (agentType === "explore" || agentType === "research")
-        return "haiku";
-    if (!requested)
-        return "haiku";
-    if (requested === "opus")
-        return "sonnet";
-    if (requested === "sonnet")
-        return agentType === "plan" ? "sonnet" : "haiku";
-    return "haiku";
+  // Fast, focused agent types always use haiku regardless of request
+  if (agentType === "explore" || agentType === "research") return "haiku";
+
+  // General-purpose and plan inherit the requested model (Claude Code parity)
+  if (agentType === "general-purpose" || agentType === "plan") {
+    if (requested === "opus") return "opus";
+    if (requested === "sonnet") return "sonnet";
+    return "sonnet"; // default to sonnet if no model specified
+  }
+
+  // Unknown/custom agent types — default to haiku for safety
+  if (!requested) return "haiku";
+  return requested === "opus" ? "sonnet" : requested === "sonnet" ? "sonnet" : "haiku";
+}
+
+// ============================================================================
+// AGENT LOOP CONFIG RESOLVER — single source of truth for all call paths
+// ============================================================================
+
+/**
+ * EMERGENCY FALLBACK DEFAULTS — used ONLY when ai_agent_config DB is unreachable.
+ *
+ * The SINGLE SOURCE OF TRUTH is the ai_agent_config table (Supabase), specifically
+ * the row for Whale Code (id: 72d7aaa8-2e8b-48a0-a38d-f332f69600bb).
+ * All behavioral knobs are stored in `context_config` JSONB.
+ *
+ * These values MUST mirror what's in the DB. If you change a value, update the DB
+ * first (via Supabase dashboard or migration), then mirror it here.
+ *
+ * DB → resolveAgentLoopConfig() → code reads resolved values.
+ * AGENT_DEFAULTS → code reads ONLY if DB fetch returns null.
+ */
+export const AGENT_DEFAULTS = {
+  // Mirrors ai_agent_config.max_tool_calls / temperature
+  maxTurns: 0,
+  // 0 = no limit (agent self-regulates via end_turn, Claude Code parity)
+  temperature: 1.0,
+  // Mirrors ai_agent_config.context_config JSONB fields
+  maxConcurrentTools: 7,
+  enableDelegation: true,
+  maxDurationMs: 900_000,
+  maxDurationMsWorkflow: 120_000,
+  enableModelRouting: true,
+  subagentMaxTokens: 32000,
+  subagentMaxTurns: 0,
+  // 0 = no limit (agent self-regulates via end_turn, Claude Code parity)
+  subagentTemperature: 1.0,
+  subagentMaxRetries: 2,
+  // 1 retry (2 total attempts) — proxy already handles auth refresh, avoid double backoff
+  maxContinuations: 10,
+  subagentMaxContinuations: 5,
+  maxMessageChars: 100_000,
+  maxHistoryChars: 400_000,
+  maxToolResultChars: 2048,
+  compactionTriggerTokens: 167_000,
+  compactionTotalBudget: 2_000_000,
+  sessionCostBudgetUsd: 25.00,
+  // Team / teammate behavioral defaults
+  teammateMaxTotalTurns: 0,
+  // 0 = no limit (teammate self-regulates, Claude Code parity)
+  teamTimeoutMs: 600_000,
+  // 10 min global safety cap — prevents runaway team runs (DB overridable)
+  workerStallMs: 90_000,
+  // 90s no-message stall detection (API timeout is 90s, so 90s silence = truly stalled)
+  teamReviewMaxTokens: 1024,
+  // Max tokens for team review synthesis
+  // Infrastructure timeouts for teammates (DB overridable, not hardcoded)
+  apiTimeoutMs: 90_000,
+  // 90s timeout on proxy/API fetch calls
+  toolTimeoutMs: 60_000,
+  // 60s timeout on individual tool execution
+  // Per-tool-result truncation cap (different from maxToolResultChars which is for preCompact)
+  toolResultTruncateChars: 30_000,
+  // Match SAFETY_MAX_CHARS from tool-dispatch.ts — 500K was blowing context windows
+  // Loop detector thresholds (DB overridable via context_config)
+  loopIdenticalCallLimit: 4,
+  loopConsecutiveErrorLimit: 3,
+  loopTurnErrorLimit: 5,
+  loopWindow: 20,
+  loopSessionToolErrorLimit: 10,
+  loopConsecutiveFailedTurnLimit: 3,
+  loopFileReadLimit: 3,
+  loopBatchErrorLimit: 3 // Max errors from single parallel batch before abort
+};
+
+/** Context config shape from ai_agent_config.context_config JSONB */
+
+/**
+ * Resolve all agent loop behavioral knobs from DB config.
+ * All 3 call paths MUST use this — structurally prevents hardcoded constants.
+ *
+ * @param agent - Agent config (DB row or subset)
+ * @param callPath - Which call path is invoking ("sse" | "workflow" | "channel")
+ * @param workflowMaxTurns - Optional cap from workflow step config (workflow path only)
+ */
+export function resolveAgentLoopConfig(agent, callPath, workflowMaxTurns) {
+  const cc = agent.context_config;
+  const defaultsUsed = [];
+  function resolve(dbValue, defaultValue, name) {
+    if (dbValue != null) return dbValue;
+    defaultsUsed.push(name);
+    return defaultValue;
+  }
+
+  // Core agent behavior
+  const agentMaxTurns = agent.max_tool_calls || AGENT_DEFAULTS.maxTurns;
+  if (!agent.max_tool_calls) defaultsUsed.push("maxTurns");
+  const temperature = agent.temperature ?? AGENT_DEFAULTS.temperature;
+  if (agent.temperature == null) defaultsUsed.push("temperature");
+  const maxTokens = getMaxOutputTokens(agent.model || "claude-sonnet-4-6", agent.max_tokens);
+  if (!agent.max_tokens) defaultsUsed.push("maxTokens");
+
+  // Call-path-specific duration defaults
+  const durationDefault = callPath === "sse" ? AGENT_DEFAULTS.maxDurationMs : AGENT_DEFAULTS.maxDurationMsWorkflow;
+
+  // Call-path-specific turn caps (0 = no limit, Claude Code parity)
+  let maxTurns = agentMaxTurns;
+  if (maxTurns > 0) {
+    if (callPath === "channel") maxTurns = Math.min(agentMaxTurns, 15);
+    if (callPath === "workflow" && workflowMaxTurns != null) {
+      maxTurns = Math.min(agentMaxTurns, workflowMaxTurns);
+    }
+  }
+  return {
+    maxTurns,
+    temperature,
+    maxTokens,
+    maxConcurrentTools: resolve(cc?.max_concurrent_tools, AGENT_DEFAULTS.maxConcurrentTools, "maxConcurrentTools"),
+    enableDelegation: resolve(cc?.enable_delegation, AGENT_DEFAULTS.enableDelegation, "enableDelegation"),
+    maxDurationMs: resolve(cc?.max_duration_ms, durationDefault, "maxDurationMs"),
+    enableModelRouting: resolve(cc?.enable_model_routing, AGENT_DEFAULTS.enableModelRouting, "enableModelRouting"),
+    maxMessageChars: resolve(cc?.max_message_chars, AGENT_DEFAULTS.maxMessageChars, "maxMessageChars"),
+    maxHistoryChars: resolve(cc?.max_history_chars, AGENT_DEFAULTS.maxHistoryChars, "maxHistoryChars"),
+    contextOverrides: {
+      compaction_trigger_tokens: cc?.compaction_trigger_tokens ?? undefined,
+      compaction_total_budget: cc?.compaction_total_budget ?? undefined,
+      clear_thinking_keep: cc?.clear_thinking_keep ?? undefined,
+      clear_tool_uses_trigger: cc?.clear_tool_uses_trigger ?? undefined,
+      clear_tool_uses_keep: cc?.clear_tool_uses_keep ?? undefined,
+      session_cost_budget_usd: cc?.session_cost_budget_usd ?? undefined
+    },
+    subagentMaxTokens: resolve(cc?.subagent_max_tokens, AGENT_DEFAULTS.subagentMaxTokens, "subagentMaxTokens"),
+    subagentMaxTurns: resolve(cc?.subagent_max_turns, AGENT_DEFAULTS.subagentMaxTurns, "subagentMaxTurns"),
+    subagentTemperature: resolve(cc?.subagent_temperature, AGENT_DEFAULTS.subagentTemperature, "subagentTemperature"),
+    maxContinuations: resolve(cc?.max_continuations, AGENT_DEFAULTS.maxContinuations, "maxContinuations"),
+    subagentMaxContinuations: resolve(cc?.subagent_max_continuations, AGENT_DEFAULTS.subagentMaxContinuations, "subagentMaxContinuations"),
+    subagentMaxRetries: resolve(cc?.subagent_max_retries, AGENT_DEFAULTS.subagentMaxRetries, "subagentMaxRetries"),
+    maxToolResultChars: resolve(cc?.max_tool_result_chars, AGENT_DEFAULTS.maxToolResultChars, "maxToolResultChars"),
+    teammateMaxTotalTurns: resolve(cc?.teammate_max_total_turns, AGENT_DEFAULTS.teammateMaxTotalTurns, "teammateMaxTotalTurns"),
+    teamTimeoutMs: resolve(cc?.team_timeout_ms, AGENT_DEFAULTS.teamTimeoutMs, "teamTimeoutMs"),
+    workerStallMs: resolve(cc?.worker_stall_ms, AGENT_DEFAULTS.workerStallMs, "workerStallMs"),
+    teamReviewMaxTokens: resolve(cc?.team_review_max_tokens, AGENT_DEFAULTS.teamReviewMaxTokens, "teamReviewMaxTokens"),
+    apiTimeoutMs: resolve(cc?.api_timeout_ms, AGENT_DEFAULTS.apiTimeoutMs, "apiTimeoutMs"),
+    toolTimeoutMs: resolve(cc?.tool_timeout_ms, AGENT_DEFAULTS.toolTimeoutMs, "toolTimeoutMs"),
+    toolResultTruncateChars: resolve(cc?.tool_result_truncate_chars, AGENT_DEFAULTS.toolResultTruncateChars, "toolResultTruncateChars"),
+    // Loop detector thresholds
+    loopIdenticalCallLimit: resolve(cc?.loop_identical_call_limit, AGENT_DEFAULTS.loopIdenticalCallLimit, "loopIdenticalCallLimit"),
+    loopConsecutiveErrorLimit: resolve(cc?.loop_consecutive_error_limit, AGENT_DEFAULTS.loopConsecutiveErrorLimit, "loopConsecutiveErrorLimit"),
+    loopTurnErrorLimit: resolve(cc?.loop_turn_error_limit, AGENT_DEFAULTS.loopTurnErrorLimit, "loopTurnErrorLimit"),
+    loopWindow: resolve(cc?.loop_window, AGENT_DEFAULTS.loopWindow, "loopWindow"),
+    loopSessionToolErrorLimit: resolve(cc?.loop_session_tool_error_limit, AGENT_DEFAULTS.loopSessionToolErrorLimit, "loopSessionToolErrorLimit"),
+    loopConsecutiveFailedTurnLimit: resolve(cc?.loop_consecutive_failed_turn_limit, AGENT_DEFAULTS.loopConsecutiveFailedTurnLimit, "loopConsecutiveFailedTurnLimit"),
+    loopFileReadLimit: resolve(cc?.loop_file_read_limit, AGENT_DEFAULTS.loopFileReadLimit, "loopFileReadLimit"),
+    loopBatchErrorLimit: resolve(cc?.loop_batch_error_limit, AGENT_DEFAULTS.loopBatchErrorLimit, "loopBatchErrorLimit"),
+    defaultsUsed
+  };
 }
 export function sanitizeError(err) {
-    const msg = String(err);
-    return msg
-        .replace(/sk-[a-zA-Z0-9_-]+/g, "sk-***")
-        .replace(/AIzaSy[a-zA-Z0-9_-]+/g, "AIzaSy***")
-        .replace(/AKIA[A-Z0-9]{16}/g, "AKIA***")
-        .replace(/key[=:]\s*["']?[a-zA-Z0-9_-]{20,}["']?/gi, "key=***")
-        .replace(/password[=:]\s*["']?[^\s"']+["']?/gi, "password=***")
-        .replace(/\n\s+at\s+.*/g, "")
-        .substring(0, 500);
+  const msg = String(err);
+  return msg.replace(/sk-[a-zA-Z0-9_-]+/g, "sk-***").replace(/AIzaSy[a-zA-Z0-9_-]+/g, "AIzaSy***").replace(/AKIA[A-Z0-9]{16}/g, "AKIA***").replace(/key[=:]\s*["']?[a-zA-Z0-9_-]{20,}["']?/gi, "key=***").replace(/password[=:]\s*["']?[^\s"']+["']?/gi, "password=***").replace(/\n\s+at\s+.*/g, "").substring(0, 500);
 }
+//# sourceMappingURL=agent-core.js.map