whale-code 6.5.5 → 6.5.7

package/dist/cli/services/agent-loop.js

@@ -16,14 +16,15 @@
  *   - session-persistence.ts (SessionMeta, save/load/list/find sessions)
  *   - system-prompt.ts      (buildSystemPrompt)
  */
-import { LOCAL_TOOL_DEFINITIONS, executeLocalTool, isLocalTool, } from "./local-tools.js";
-import { INTERACTIVE_TOOL_DEFINITIONS, executeInteractiveTool, waitForPlanApproval, } from "./interactive-tools.js";
-import { loadConfig, resolveConfig, getProxyUrl } from "./config-store.js";
+
+import { LOCAL_TOOL_DEFINITIONS, executeLocalTool, isLocalTool } from "./local-tools.js";
+import { INTERACTIVE_TOOL_DEFINITIONS, executeInteractiveTool, waitForPlanApproval } from "./interactive-tools.js";
+import { loadConfig, resolveConfig, getProxyUrl, resolveDefaultAgentId } from "./config-store.js";
 import { getValidToken, refreshSession } from "./auth-service.js";
-import { isServerTool, loadServerToolDefinitions, executeServerTool, getServerStatus, setServerToolContext, } from "./server-tools.js";
-import { nextTurn, createTurnContext, logSpan, generateSpanId, flushCliSpans, } from "./telemetry.js";
+import { isServerTool, loadServerToolDefinitions, executeServerTool, getServerStatus, setServerToolContext } from "./server-tools.js";
+import { nextTurn, createTurnContext, logSpan, generateSpanId, flushCliSpans } from "./telemetry.js";
 import { captureError, addBreadcrumb } from "./error-logger.js";
-import { setGlobalEmitter, clearGlobalEmitter, } from "./agent-events.js";
+import { setGlobalEmitter, clearGlobalEmitter } from "./agent-events.js";
 import { mcpClientManager } from "./mcp-client.js";
 import { loadHooks, runBeforeToolHook, runAfterToolHook, runSessionHook } from "./hooks.js";
 import { LoopDetector, COMPACTION_TOTAL_BUDGET, getCompactionConfig, getContextManagement, DEFAULT_SESSION_COST_BUDGET_USD, emitCostWarningIfNeeded, resolveAgentLoopConfig, AGENT_DEFAULTS } from "../../shared/agent-core.js";
@@ -39,41 +40,65 @@ import { loadClaudeMd, reloadClaudeMd, resetClaudeMdCache } from "./claude-md-lo
 import { clearReadCache } from "./tools/file-ops.js";
 import { setPermissionMode, getPermissionMode, isToolAllowedByPermission } from "./permission-modes.js";
 import { setModel, setModelById, getModel, getModelShortName, estimateCostUsd } from "./model-manager.js";
-import { saveSession, loadSession, listSessions, findLatestSessionForCwd } from "./session-persistence.js";
+import { saveSession, loadSession, listSessions, findLatestSessionForCwd, updateSessionMeta } from "./session-persistence.js";
 import { buildSystemPrompt } from "./system-prompt.js";
+
 // ============================================================================
-// RE-EXPORTS — all consumers keep importing from agent-loop.ts
+// RE-EXPORTS — legacy compatibility. Prefer importing from source modules directly:
+//   memory-manager.ts, git-context.ts, claude-md-loader.ts,
+//   permission-modes.ts, model-manager.ts, session-persistence.ts,
+//   server-tools.ts, mcp-client.ts, background-processes.ts, agent-events.ts
 // ============================================================================
-// Memory
+
+// Memory → import from "./memory-manager.js"
 export { loadMemory, addMemory, removeMemory, listMemories };
-// Git context
+
+// Git context → import from "./git-context.js"
 export { refreshGitContext };
-// CLAUDE.md
+
+// CLAUDE.md → import from "./claude-md-loader.js"
 export { loadClaudeMd, reloadClaudeMd };
-// Permission modes
+
+// Permission modes → import from "./permission-modes.js"
 export { setPermissionMode, getPermissionMode, isToolAllowedByPermission };
-// Model management
+
+// Model management → import from "./model-manager.js"
 export { setModel, getModel, getModelShortName, estimateCostUsd };
-// Session persistence
-export { saveSession, loadSession, listSessions, findLatestSessionForCwd };
-// Server status (pass-through)
+
+// Session persistence → import from "./session-persistence.js"
+export { saveSession, loadSession, listSessions, findLatestSessionForCwd, updateSessionMeta };
+
+// Server status → import from "./server-tools.js"
 export { getServerStatus };
-// MCP client manager
+
+// MCP client manager → import from "./mcp-client.js"
 export { mcpClientManager };
-// Re-export background process listing for /tasks command
+
+// Background processes → import from "./background-processes.js"
 export { listProcesses, listBackgroundAgents } from "./background-processes.js";
-// Re-export event emitter for ChatApp
+
+// Event emitter → import from "./agent-events.js"
 export { AgentEventEmitter } from "./agent-events.js";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
 // ============================================================================
 // SESSION STATE
 // ============================================================================
+
 // CLI-only: Session-wide token tracking (actual counts from API responses).
 // Reset via resetSessionState() when starting a new conversation.
 let sessionInputTokens = 0;
 let sessionOutputTokens = 0;
 export function getSessionTokens() {
-    return { input: sessionInputTokens, output: sessionOutputTokens };
+  return {
+    input: sessionInputTokens,
+    output: sessionOutputTokens
+  };
 }
+
 /**
  * Reset all CLI-only session state. Call when starting a new conversation
  * (e.g., /clear command, new print-mode run) to prevent stale token counts,
@@ -83,758 +108,1166 @@ export function getSessionTokens() {
  * that persist intentionally until explicitly changed.
  */
 export function resetSessionState() {
-    sessionInputTokens = 0;
-    sessionOutputTokens = 0;
-    sessionLoopDetector = null;
-    resetGitContext();
-    resetClaudeMdCache();
-    clearReadCache();
-    resetAgentConfigCache();
+  sessionInputTokens = 0;
+  sessionOutputTokens = 0;
+  sessionLoopDetector = null;
+  resetGitContext();
+  resetClaudeMdCache();
+  clearReadCache();
+  resetAgentConfigCache();
 }
+
 /** CLI-only: loop detector — persists session error state across turns (reset by resetSessionState) */
 let sessionLoopDetector = null;
-// CLI max turns — high ceiling since user controls via Ctrl+C.
-// DB agent config maxTurns is used when available, this is the absolute safety cap.
-const CLI_MAX_TURNS_CAP = 200;
+
+// No artificial turn cap — agent self-regulates via end_turn (Claude Code parity).
+// Safety: LoopDetector catches loops, cost budget catches runaway spending, user has Ctrl+C.
+const CLI_NO_LIMIT = Number.MAX_SAFE_INTEGER;
+
 // ============================================================================
 // SHELL OUTPUT SUMMARIZATION
 // ============================================================================
+
 const SHELL_SUMMARIZE_LINE_THRESHOLD = 800;
 const SHELL_SUMMARIZE_SIZE_THRESHOLD = 200_000; // 200KB — only summarize truly huge outputs
 const SHELL_SUMMARIZE_MAX_INPUT = 300_000; // 300KB max to summarizer
 const SHELL_SUMMARIZE_ORIGINAL_PREVIEW_LINES = 20;
+
 /**
  * Check if shell output should be summarized based on line count or size.
  */
 function shouldSummarizeShellOutput(output) {
-    if (output.length > SHELL_SUMMARIZE_SIZE_THRESHOLD)
-        return true;
-    const lineCount = output.split("\n").length;
-    return lineCount > SHELL_SUMMARIZE_LINE_THRESHOLD;
+  if (output.length > SHELL_SUMMARIZE_SIZE_THRESHOLD) return true;
+  const lineCount = output.split("\n").length;
+  return lineCount > SHELL_SUMMARIZE_LINE_THRESHOLD;
 }
+
 /**
  * Summarize long shell output using Haiku via server proxy.
  * Returns summarized output or original if summarization fails.
  */
 async function summarizeShellOutput(output, proxyUrl, token, storeId) {
-    const lineCount = output.split("\n").length;
-    const truncatedForSummary = output.length > SHELL_SUMMARIZE_MAX_INPUT
-        ? output.slice(0, SHELL_SUMMARIZE_MAX_INPUT) + "\n... (truncated for summarization)"
-        : output;
-    try {
-        const summaryConfig = buildAPIRequest({
-            model: MODELS.HAIKU,
-            contextProfile: "subagent",
-        });
-        const stream = await callServerProxy({
-            proxyUrl,
-            token,
-            model: MODELS.HAIKU,
-            system: [{ type: "text", text: "You are a concise technical summarizer. Summarize shell/command output preserving key information, errors, warnings, file paths, and actionable items. Be brief but thorough." }],
-            messages: [{ role: "user", content: `Summarize this shell output concisely, preserving key information, errors, and actionable items:\n\n${truncatedForSummary}` }],
-            tools: [],
-            apiConfig: summaryConfig,
-            storeId,
-            timeoutMs: 15_000,
-        });
-        const result = await collectStreamResult(parseSSEStream(stream));
-        const summary = result.text.trim();
-        if (!summary)
-            return output; // Summarization failed, return original
-        // Build first N lines preview
-        const originalLines = output.split("\n");
-        const preview = originalLines.slice(0, SHELL_SUMMARIZE_ORIGINAL_PREVIEW_LINES).join("\n");
-        return `[Summarized from ${lineCount} lines]\n\n${summary}\n\n[First ${SHELL_SUMMARIZE_ORIGINAL_PREVIEW_LINES} lines of original output]\n${preview}`;
-    }
-    catch {
-        // Summarization failed silently — return original output
-        return output;
-    }
+  const lineCount = output.split("\n").length;
+  const truncatedForSummary = output.length > SHELL_SUMMARIZE_MAX_INPUT ? output.slice(0, SHELL_SUMMARIZE_MAX_INPUT) + "\n... (truncated for summarization)" : output;
+  try {
+    const summaryConfig = buildAPIRequest({
+      model: MODELS.HAIKU,
+      contextProfile: "subagent"
+    });
+    const stream = await callServerProxy({
+      proxyUrl,
+      token,
+      model: MODELS.HAIKU,
+      system: [{
+        type: "text",
+        text: "You are a concise technical summarizer. Summarize shell/command output preserving key information, errors, warnings, file paths, and actionable items. Be brief but thorough."
+      }],
+      messages: [{
+        role: "user",
+        content: `Summarize this shell output concisely, preserving key information, errors, and actionable items:\n\n${truncatedForSummary}`
+      }],
+      tools: [],
+      apiConfig: summaryConfig,
+      storeId,
+      timeoutMs: 15_000
+    });
+    const result = await collectStreamResult(parseSSEStream(stream));
+    const summary = result.text.trim();
+    if (!summary) return output; // Summarization failed, return original
+
+    // Build first N lines preview
+    const originalLines = output.split("\n");
+    const preview = originalLines.slice(0, SHELL_SUMMARIZE_ORIGINAL_PREVIEW_LINES).join("\n");
+    return `[Summarized from ${lineCount} lines]\n\n${summary}\n\n[First ${SHELL_SUMMARIZE_ORIGINAL_PREVIEW_LINES} lines of original output]\n${preview}`;
+  } catch {
+    // Summarization failed silently — return original output
+    return output;
+  }
 }
+
 /**
  * Post-process tool results to summarize long bash output.
  * Only affects bash tool results that exceed size/line thresholds.
  */
 async function summarizeLongToolResults(toolResults, toolNames, proxyUrl, token, shellSummarization, storeId) {
-    if (!shellSummarization)
-        return toolResults;
-    const tasks = toolResults.map(async (result) => {
-        // Only summarize bash tool string results
-        const toolName = toolNames.get(result.tool_use_id);
-        if (toolName !== "bash" || typeof result.content !== "string")
-            return result;
-        // Check thresholds
-        if (!shouldSummarizeShellOutput(result.content))
-            return result;
-        const summarized = await summarizeShellOutput(result.content, proxyUrl, token, storeId);
-        return { ...result, content: summarized };
-    });
-    return Promise.all(tasks);
+  if (!shellSummarization) return toolResults;
+  const tasks = toolResults.map(async result => {
+    // Only summarize bash tool string results
+    const toolName = toolNames.get(result.tool_use_id);
+    if (toolName !== "bash" || typeof result.content !== "string") return result;
+
+    // Check thresholds
+    if (!shouldSummarizeShellOutput(result.content)) return result;
+    const summarized = await summarizeShellOutput(result.content, proxyUrl, token, storeId);
+    return {
+      ...result,
+      content: summarized
+    };
+  });
+  return Promise.all(tasks);
 }
+
 // ============================================================================
 // TOOL DEFINITIONS
 // ============================================================================
+
 async function getTools(allowedTools, disallowedTools) {
-    const localTools = LOCAL_TOOL_DEFINITIONS.map((t) => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.input_schema,
-    }));
-    // Add interactive tools (ask_user_question, enter_plan_mode, exit_plan_mode)
-    const interactiveTools = INTERACTIVE_TOOL_DEFINITIONS.map((t) => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.input_schema,
-    }));
-    localTools.push(...interactiveTools);
-    let serverTools = [];
-    try {
-        serverTools = await loadServerToolDefinitions();
-    }
-    catch {
-        // Server tools silently unavailable
-    }
-    // Deduplicate: local tools take priority over server tools with the same name
-    const localNames = new Set(localTools.map(t => t.name));
-    const uniqueServerTools = serverTools.filter(t => !localNames.has(t.name));
-    // MCP tools from external servers
-    const mcpTools = mcpClientManager.getTools();
-    let allTools = [...localTools, ...uniqueServerTools, ...mcpTools];
-    // Apply tool filtering
-    if (allowedTools && allowedTools.length > 0) {
-        const allowed = new Set(allowedTools);
-        allTools = allTools.filter(t => allowed.has(t.name));
-    }
-    if (disallowedTools && disallowedTools.length > 0) {
-        const disallowed = new Set(disallowedTools);
-        allTools = allTools.filter(t => !disallowed.has(t.name));
-    }
-    return {
-        tools: allTools,
-        serverToolCount: uniqueServerTools.length,
-    };
+  const localTools = LOCAL_TOOL_DEFINITIONS.map(t => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.input_schema
+  }));
+
+  // Add interactive tools — skip plan mode tools in yolo mode (user doesn't want plan gates)
+  const skipPlanTools = getPermissionMode() === "yolo";
+  const interactiveTools = INTERACTIVE_TOOL_DEFINITIONS.filter(t => !skipPlanTools || t.name !== "enter_plan_mode" && t.name !== "exit_plan_mode").map(t => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.input_schema
+  }));
+  localTools.push(...interactiveTools);
+  let serverTools = [];
+  try {
+    serverTools = await loadServerToolDefinitions();
+  } catch {
+    // Server tools silently unavailable
+  }
+
+  // Deduplicate: local tools take priority over server tools with the same name
+  const localNames = new Set(localTools.map(t => t.name));
+  const uniqueServerTools = serverTools.filter(t => !localNames.has(t.name));
+
+  // MCP tools from external servers
+  const mcpTools = mcpClientManager.getTools();
+  let allTools = [...localTools, ...uniqueServerTools, ...mcpTools];
+
+  // Apply tool filtering
+  if (allowedTools && allowedTools.length > 0) {
+    const allowed = new Set(allowedTools);
+    allTools = allTools.filter(t => allowed.has(t.name));
+  }
+  if (disallowedTools && disallowedTools.length > 0) {
+    const disallowed = new Set(disallowedTools);
+    allTools = allTools.filter(t => !disallowed.has(t.name));
+  }
+  return {
+    tools: allTools,
+    serverToolCount: uniqueServerTools.length
+  };
 }
+
 /** Exposed for /status command */
 export async function getServerToolCount() {
-    try {
-        const defs = await loadServerToolDefinitions();
-        return defs.length;
-    }
-    catch {
-        return 0;
-    }
+  try {
+    const defs = await loadServerToolDefinitions();
+    return defs.length;
+  } catch {
+    return 0;
+  }
 }
+
 // ============================================================================
 // MAIN LOOP
 // ============================================================================
+
 export async function runAgentLoop(opts) {
-    const { message, conversationHistory, callbacks, abortSignal, emitter } = opts;
-    if (opts.model)
-        setModel(opts.model);
-    // Set global emitter for subagents to use
-    if (emitter) {
-        setGlobalEmitter(emitter);
-    }
-    // effectiveMaxTurns resolved after DB config fetch below
-    let effectiveMaxTurns = opts.maxTurns || CLI_MAX_TURNS_CAP;
-    // Load hooks from project and user config
-    const hooksCwd = opts.cwd || process.cwd();
-    const hooks = loadHooks(hooksCwd);
-    // Fire SessionStart hook (non-blocking)
-    if (hooks.length > 0) {
-        runSessionHook(hooks, "SessionStart", { session_id: `turn-${Date.now()}` }).catch(() => { });
-    }
-    // Shell summarization config (default: true)
-    const shellSummarization = opts.shellSummarization !== false;
-    const { tools, serverToolCount } = await getTools(opts.allowedTools, opts.disallowedTools);
-    const systemPrompt = await buildSystemPrompt(serverToolCount > 0, opts.effort);
-    // Build user content — text-only string or content blocks array with images
-    let userContent;
-    if (opts.images && opts.images.length > 0) {
-        const blocks = [];
-        for (const img of opts.images) {
-            blocks.push({
-                type: "image",
-                source: {
-                    type: "base64",
-                    media_type: img.mediaType,
-                    data: img.base64,
-                },
-            });
+  // Session mode: delegate to server-side SessionManager when available
+  if (await shouldUseSessionMode()) {
+    return runSessionAgentLoop(opts);
+  }
+  const {
+    message,
+    conversationHistory,
+    callbacks,
+    abortSignal,
+    emitter
+  } = opts;
+  if (opts.model) setModel(opts.model);
+
+  // Set global emitter for subagents to use
+  if (emitter) {
+    setGlobalEmitter(emitter);
+  }
+
+  // effectiveMaxTurns resolved after DB config fetch below
+  // 0 or unset = no limit (Claude Code parity — agent self-regulates via end_turn)
+  let effectiveMaxTurns = opts.maxTurns || CLI_NO_LIMIT;
+
+  // Load hooks from project and user config
+  const hooksCwd = opts.cwd || process.cwd();
+  const hooks = loadHooks(hooksCwd);
+
+  // Fire SessionStart hook (non-blocking)
+  if (hooks.length > 0) {
+    runSessionHook(hooks, "SessionStart", {
+      session_id: `turn-${Date.now()}`
+    }).catch(() => {});
+  }
+
+  // Shell summarization config (default: true)
+  const shellSummarization = opts.shellSummarization !== false;
+  const {
+    tools,
+    serverToolCount
+  } = await getTools(opts.allowedTools, opts.disallowedTools);
+  const systemPrompt = await buildSystemPrompt(serverToolCount > 0, opts.effort);
+
+  // Build user content — text-only string or content blocks array with images
+  let userContent;
+  if (opts.images && opts.images.length > 0) {
+    const blocks = [];
+    for (const img of opts.images) {
+      blocks.push({
+        type: "image",
+        source: {
+          type: "base64",
+          media_type: img.mediaType,
+          data: img.base64
         }
-        blocks.push({ type: "text", text: message || "(see attached images)" });
-        userContent = blocks;
+      });
     }
-    else {
-        userContent = message;
+    blocks.push({
+      type: "text",
+      text: message || "(see attached images)"
+    });
+    userContent = blocks;
+  } else {
+    userContent = message;
+  }
+  const messages = [...conversationHistory, {
+    role: "user",
+    content: userContent
+  }];
+  let totalIn = 0;
+  let totalOut = 0;
+  let totalCacheCreation = 0;
+  let totalCacheRead = 0;
+  let totalThinking = 0;
+  let allAssistantText = [];
+  let prevIterationInputTokens = 0; // Tracks actual context size from last API call
+
+  // Telemetry: one turn per user message (not per API call)
+  const sessionStart = Date.now();
+  const {
+    storeId
+  } = resolveConfig();
+  const turnNum = nextTurn(); // ONCE per user message
+  const turnCtx = createTurnContext({
+    model: getModel(),
+    turnNumber: turnNum
+  });
+  addBreadcrumb("agent", `Turn ${turnNum}: ${message.slice(0, 100)}`, "info");
+
+  // Set server tool context so tool calls carry trace/user identity to Fly.io server
+  setServerToolContext({
+    traceId: turnCtx.traceId,
+    conversationId: turnCtx.conversationId,
+    userId: turnCtx.userId,
+    userEmail: turnCtx.userEmail,
+    source: "whale-code"
+  });
+  logSpan({
+    action: "chat.user_message",
+    durationMs: 0,
+    context: turnCtx,
+    storeId: storeId || undefined,
+    details: {
+      message: message,
+      conversation_history_length: conversationHistory.length
     }
-    const messages = [
-        ...conversationHistory,
-        { role: "user", content: userContent },
-    ];
-    // Session-level loop detector: persists failed strategies across turns.
-    // Created once per conversation, reset only when user starts a new conversation.
-    if (!sessionLoopDetector || conversationHistory.length === 0) {
-        sessionLoopDetector = new LoopDetector();
+  });
+  let sessionCostUsd = 0;
+  let compactionCount = 0;
+  let consecutiveCompactions = 0; // Circuit breaker: consecutive compactions without progress
+  let maxTokensContinuations = 0; // Cap continuation loops to prevent infinite looping
+  const costWarningsEmitted = new Set();
+  const activeModel = getModel();
+
+  // Fetch agent config from DB — single source of truth, nothing hardcoded.
+  // Falls back to AGENT_DEFAULTS only if DB is unreachable (never blocks).
+  const dbAgent = await loadCLIAgentConfig();
+  const resolved = dbAgent ? resolveAgentLoopConfig(dbAgent, "sse") : null;
+
+  // Session-level loop detector: persists failed strategies across turns.
+  // Created once per conversation, reset only when user starts a new conversation.
+  // Must be created AFTER config resolution so DB thresholds apply.
+  if (!sessionLoopDetector || conversationHistory.length === 0) {
+    sessionLoopDetector = resolved ? LoopDetector.fromResolved(resolved) : new LoopDetector();
+  }
+  const loopDetector = sessionLoopDetector;
+  loopDetector.resetTurn();
+  const effectiveBudget = opts.maxBudgetUsd ?? resolved?.contextOverrides.session_cost_budget_usd ?? DEFAULT_SESSION_COST_BUDGET_USD;
+
+  // Compaction settings from DB via getContextManagement — pass DB overrides so
+  // the trigger/budget values match what the Anthropic API actually uses.
+  const ctxOverrides = resolved?.contextOverrides;
+  const ctxMgmt = getContextManagement(activeModel, ctxOverrides);
+  const compactEdit = ctxMgmt.config.edits.find(e => e.type === "compact_20260112");
+  const effectiveCompactionTrigger = compactEdit?.trigger?.value ?? AGENT_DEFAULTS.compactionTriggerTokens;
+  const effectiveCompactionBudget = ctxOverrides?.compaction_total_budget ?? COMPACTION_TOTAL_BUDGET;
+
+  // Override maxTurns from DB config (if not explicitly set by caller)
+  // 0 = no limit (Claude Code parity)
+  if (!opts.maxTurns && resolved && resolved.maxTurns > 0) {
+    effectiveMaxTurns = resolved.maxTurns;
+  }
+
+  // Max continuations: resolved from DB config → AGENT_DEFAULTS fallback
+  const maxContinuations = resolved?.maxContinuations ?? AGENT_DEFAULTS.maxContinuations;
+
+  // Tool executor — routes to interactive, local, server, or MCP tools.
+  // Wraps execution with before/after hooks when hooks are loaded.
+  const INTERACTIVE_TOOL_NAMES = new Set(INTERACTIVE_TOOL_DEFINITIONS.map(t => t.name));
+  const toolExecutor = async (name, input) => {
+    if (!name) {
+      return {
+        success: false,
+        output: "Tool call missing name — skipping."
+      };
     }
-    const loopDetector = sessionLoopDetector;
-    loopDetector.resetTurn();
-    let totalIn = 0;
-    let totalOut = 0;
-    let totalCacheCreation = 0;
-    let totalCacheRead = 0;
-    let totalThinking = 0;
-    let allAssistantText = [];
-    let prevIterationInputTokens = 0; // Tracks actual context size from last API call
-    // Telemetry: one turn per user message (not per API call)
-    const sessionStart = Date.now();
-    const { storeId } = resolveConfig();
-    const turnNum = nextTurn(); // ONCE per user message
-    const turnCtx = createTurnContext({ model: getModel(), turnNumber: turnNum });
-    addBreadcrumb("agent", `Turn ${turnNum}: ${message.slice(0, 100)}`, "info");
-    // Set server tool context so tool calls carry trace/user identity to Fly.io server
-    setServerToolContext({
-        traceId: turnCtx.traceId,
-        conversationId: turnCtx.conversationId,
-        userId: turnCtx.userId,
-        userEmail: turnCtx.userEmail,
-        source: "whale-code",
-    });
-    logSpan({
-        action: "chat.user_message",
-        durationMs: 0,
-        context: turnCtx,
-        storeId: storeId || undefined,
-        details: {
-            message: message,
-            conversation_history_length: conversationHistory.length,
-        },
-    });
-    let sessionCostUsd = 0;
-    let compactionCount = 0;
-    const costWarningsEmitted = new Set();
-    const activeModel = getModel();
-    // Fetch agent config from DB — single source of truth, nothing hardcoded.
-    // Falls back to AGENT_DEFAULTS only if DB is unreachable (never blocks).
-    const dbAgent = await loadCLIAgentConfig();
-    const resolved = dbAgent
-        ? resolveAgentLoopConfig(dbAgent, "sse")
-        : null;
-    const effectiveBudget = opts.maxBudgetUsd
-        ?? resolved?.contextOverrides.session_cost_budget_usd
-        ?? DEFAULT_SESSION_COST_BUDGET_USD;
-    // Compaction settings from DB via getContextManagement — pass DB overrides so
-    // the trigger/budget values match what the Anthropic API actually uses.
-    const ctxOverrides = resolved?.contextOverrides;
-    const ctxMgmt = getContextManagement(activeModel, ctxOverrides);
-    const compactEdit = ctxMgmt.config.edits.find((e) => e.type === "compact_20260112");
-    const effectiveCompactionTrigger = compactEdit?.trigger?.value ?? AGENT_DEFAULTS.compactionTriggerTokens;
-    const effectiveCompactionBudget = ctxOverrides?.compaction_total_budget ?? COMPACTION_TOTAL_BUDGET;
-    // Override maxTurns from DB config (if not explicitly set by caller)
-    if (!opts.maxTurns && resolved) {
-        effectiveMaxTurns = resolved.maxTurns;
+
+    // Permission mode enforcement
+    if (!isToolAllowedByPermission(name)) {
+      return {
+        success: false,
+        output: `Tool "${name}" blocked by ${getPermissionMode()} mode. Switch modes with /mode.`
+      };
     }
-    // Tool executor — routes to interactive, local, server, or MCP tools.
-    // Wraps execution with before/after hooks when hooks are loaded.
-    const INTERACTIVE_TOOL_NAMES = new Set(INTERACTIVE_TOOL_DEFINITIONS.map(t => t.name));
-    const toolExecutor = async (name, input) => {
-        if (!name) {
-            return { success: false, output: "Tool call missing name — skipping." };
+
+    // BeforeTool hook — may block or modify input
+    let effectiveInput = input;
+    if (hooks.length > 0) {
+      const hookResult = await runBeforeToolHook(hooks, name, input);
+      if (!hookResult.allow) {
+        return {
+          success: false,
+          output: hookResult.message || "Blocked by hook"
+        };
+      }
+      if (hookResult.modifiedInput) {
+        effectiveInput = hookResult.modifiedInput;
+      }
+    }
+    let result;
+    if (INTERACTIVE_TOOL_NAMES.has(name)) {
+      result = await executeInteractiveTool(name, effectiveInput);
+
+      // For exit_plan_mode: wait for UI approval, then map decision to result
+      if (name === "exit_plan_mode" && result.success) {
+        const decision = await waitForPlanApproval(abortSignal);
+        switch (decision.action) {
+          case "execute":
+            result = {
+              success: true,
+              output: `__PLAN_APPROVED_CLEAN__\n${result.output}`
+            };
+            break;
+          case "edit":
+            result = {
+              success: true,
+              output: "Plan returned for revision. Make changes and use ExitPlanMode again when ready."
+            };
+            break;
+          case "feedback":
+            result = {
+              success: true,
+              output: `User feedback on plan:\n\n${decision.feedback || "(no feedback provided)"}\n\nRevise the plan based on this feedback, then use ExitPlanMode again.`
+            };
+            break;
+          case "cancel":
+            result = {
+              success: true,
+              output: "Plan cancelled by user. Do not proceed with implementation."
+            };
+            break;
         }
-        // Permission mode enforcement
-        if (!isToolAllowedByPermission(name)) {
-            return { success: false, output: `Tool "${name}" blocked by ${getPermissionMode()} mode. Switch modes with /mode.` };
+      }
+    } else if (isLocalTool(name)) {
+      result = await executeLocalTool(name, effectiveInput, abortSignal);
+    } else if (isServerTool(name)) {
+      result = await executeServerTool(name, effectiveInput, emitter);
+    } else if (mcpClientManager.isMcpTool(name)) {
+      result = await mcpClientManager.callTool(name, effectiveInput);
+    } else {
+      result = {
+        success: false,
+        output: `Unknown tool: ${name}`
+      };
+    }
+
+    // AfterTool hook — may modify output
+    if (hooks.length > 0) {
+      const afterResult = await runAfterToolHook(hooks, name, result.output, result.success);
+      if (afterResult.modifiedOutput !== undefined) {
+        result = {
+          ...result,
+          output: afterResult.modifiedOutput
+        };
+      }
+    }
+    return result;
+  };
+  try {
+    for (let iteration = 0; iteration < effectiveMaxTurns; iteration++) {
+      if (abortSignal?.aborted) {
+        logSpan({
+          action: "chat.cancelled",
+          durationMs: Date.now() - sessionStart,
+          context: turnCtx,
+          storeId: storeId || undefined,
+          details: {
+            iteration,
+            reason: "user_abort"
+          }
+        });
+        callbacks.onError("Cancelled", messages);
+        return;
+      }
+
+      // Budget enforcement — always enforced (defaults to DEFAULT_SESSION_COST_BUDGET_USD)
+      if (sessionCostUsd >= effectiveBudget) {
+        logSpan({
+          action: "chat.budget_exceeded",
+          durationMs: Date.now() - sessionStart,
+          context: turnCtx,
+          storeId: storeId || undefined,
+          severity: "warn",
+          details: {
+            session_cost_usd: sessionCostUsd,
+            max_budget_usd: effectiveBudget,
+            iteration
+          }
+        });
+        callbacks.onError(`Budget exceeded: $${sessionCostUsd.toFixed(4)} >= $${effectiveBudget}`, messages);
+        return;
+      }
+      const apiStart = Date.now();
+      const apiSpanId = generateSpanId();
+      const apiRowId = crypto.randomUUID(); // UUID for this span's row — children reference via parent_id
+      const costContext = `Session cost: $${sessionCostUsd.toFixed(2)} | Budget remaining: $${(effectiveBudget - sessionCostUsd).toFixed(2)}`;
+
+      // Build API request config
+      const currentModel = getModel();
+      const apiConfig = buildAPIRequest({
+        model: currentModel,
+        contextProfile: "main",
+        thinkingEnabled: opts.thinking,
+        contextOverrides: ctxOverrides
+      });
+
+      // Prepare with prompt caching
+      let {
+        tools: cachedTools,
+        messages: cachedMessages
+      } = prepareWithCaching(tools, messages);
+      const system = buildSystemBlocks(systemPrompt, costContext);
+
+      // Client-side context trimming for non-Anthropic providers.
+      // Uses prevIterationInputTokens (actual context size from last API call) — NOT
+      // cumulative sessionInputTokens, which grows quadratically and would trigger too early.
+      const provider = getProvider(currentModel);
+      if (provider === "gemini" || provider === "openai") {
+        const preTrimMessages = cachedMessages;
+        if (provider === "gemini") {
+          // Emergency fallback only — compaction fires at 700K first; trim at 950K catches failures
+          cachedMessages = trimGeminiContext(cachedMessages, prevIterationInputTokens);
+        } else {
+          // Emergency fallback only — compaction fires at 120K first; trim at 190K catches failures
+          // GPT-4o: 128K context → 96K threshold (no compaction headroom)
+          const threshold = currentModel === "gpt-4o" ? 96_000 : 190_000;
+          cachedMessages = trimOpenAIContext(cachedMessages, prevIterationInputTokens, threshold);
         }
-        // BeforeTool hook — may block or modify input
-        let effectiveInput = input;
-        if (hooks.length > 0) {
-            const hookResult = await runBeforeToolHook(hooks, name, input);
-            if (!hookResult.allow) {
-                return { success: false, output: hookResult.message || "Blocked by hook" };
-            }
-            if (hookResult.modifiedInput) {
-                effectiveInput = hookResult.modifiedInput;
-            }
+        // Notify UI when trimming actually occurred (trim returns same ref if no-op)
+        if (cachedMessages !== preTrimMessages) {
+          // Count tool results before/after to report meaningful numbers
+          const countToolResults = msgs => msgs.reduce((sum, m) => sum + (Array.isArray(m.content) ? m.content.filter(b => b.type === "tool_result" && b.content !== "[trimmed]").length : 0), 0);
+          const activeBefore = countToolResults(preTrimMessages);
+          const activeAfter = countToolResults(cachedMessages);
+          const estimatedSaved = Math.round(prevIterationInputTokens * ((activeBefore - activeAfter) / Math.max(activeBefore, 1)));
+          callbacks.onAutoCompact?.(activeBefore, activeAfter, estimatedSaved);
+          emitter?.emitCompact(activeBefore, activeAfter, estimatedSaved);
         }
-        let result;
-        if (INTERACTIVE_TOOL_NAMES.has(name)) {
-            result = await executeInteractiveTool(name, effectiveInput);
-            // For exit_plan_mode: wait for UI approval, then map decision to result
-            if (name === "exit_plan_mode" && result.success) {
-                const decision = await waitForPlanApproval();
-                switch (decision.action) {
-                    case "execute":
-                        result = { success: true, output: `__PLAN_APPROVED_CLEAN__\n${result.output}` };
-                        break;
-                    case "edit":
-                        result = { success: true, output: "Plan returned for revision. Make changes and use ExitPlanMode again when ready." };
-                        break;
-                    case "feedback":
-                        result = { success: true, output: `User feedback on plan:\n\n${decision.feedback || "(no feedback provided)"}\n\nRevise the plan based on this feedback, then use ExitPlanMode again.` };
-                        break;
-                    case "cancel":
-                        result = { success: true, output: "Plan cancelled by user. Do not proceed with implementation." };
-                        break;
-                }
+      }
+
+      // Get auth token
+      const token = await getValidToken();
+      if (!token) {
+        throw new Error("Not logged in. Run: whale login");
+      }
+
+      // Call server proxy with built-in retry
+      const originalModel = currentModel;
+      const stream = await callServerProxy({
+        proxyUrl: getProxyUrl(),
+        token,
+        model: currentModel,
+        system,
+        messages: cachedMessages,
+        tools: cachedTools,
+        apiConfig,
+        signal: abortSignal,
+        fallbackModel: opts.fallbackModel,
+        storeId: storeId || undefined,
+        onFallback: (from, to) => {
+          setModel(to);
+          logSpan({
+            action: "claude_api_fallback",
+            durationMs: 0,
+            context: {
+              ...turnCtx,
+              spanId: apiSpanId
+            },
+            storeId: storeId || undefined,
+            details: {
+              from_model: from,
+              to_model: to
             }
+          });
+        },
+        onRetry: (attempt, max, err) => {
+          const msg = `\n\x1b[33m\u21BB Retrying (${attempt}/${max})... ${err.slice(0, 80)}\x1b[0m\n`;
+          if (emitter) {
+            emitter.emitText(msg);
+          } else {
+            callbacks.onText(msg);
+          }
+        },
+        onTokenRefresh: async () => {
+          const result = await refreshSession();
+          return result.success ? result.config.access_token : null;
         }
-        else if (isLocalTool(name)) {
-            result = await executeLocalTool(name, effectiveInput);
+      });
+
+      // Process stream events with UI callbacks
+      let thinkingChunks = 0;
+      const result = await processStreamWithCallbacks(parseSSEStream(stream, abortSignal), {
+        onText: text => {
+          if (emitter) {
+            emitter.emitText(text);
+          } else {
+            callbacks.onText(text);
+          }
+        },
+        onThinking: () => {
+          thinkingChunks++;
+          emitter?.emitThinking(thinkingChunks);
+        },
+        onToolStart: (name, input) => {
+          // NOTE: Do NOT call callbacks.onToolStart here — dispatchTools.onStart
+          // fires it once per tool at execution time. Calling it here too would
+          // send duplicate tool_start events (stale spinners in WhaleChat).
+          if (input) {
+            // Tool block complete — emit structured start for CLI TUI only
+            emitter?.emitToolStart("", name);
+          }
         }
-        else if (isServerTool(name)) {
-            result = await executeServerTool(name, effectiveInput, emitter);
+      }, abortSignal);
+
+      // Flush buffered text
+      emitter?.flushText();
+
+      // Restore original model after transient fallback
+      if (getModel() !== originalModel && opts.fallbackModel) {
+        setModelById(originalModel);
+      }
+
+      // Update session token tracking
+      sessionInputTokens += result.usage.inputTokens;
+      sessionOutputTokens += result.usage.outputTokens;
+      prevIterationInputTokens = result.usage.inputTokens; // Actual context size for next trim check
+
+      // Emit usage with model + cost context for all providers
+      if (emitter && (result.usage.inputTokens > 0 || result.usage.outputTokens > 0)) {
+        const iterCost = estimateCostUsd(result.usage.inputTokens, result.usage.outputTokens, currentModel, result.thinkingTokens, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
+        emitter.emitUsage(result.usage.inputTokens, result.usage.outputTokens, currentModel, iterCost, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
+      }
+      totalIn += result.usage.inputTokens;
+      totalOut += result.usage.outputTokens;
+      totalCacheCreation += result.usage.cacheCreationTokens;
+      totalCacheRead += result.usage.cacheReadTokens;
+      totalThinking += result.thinkingTokens;
+      sessionCostUsd += estimateCostUsd(result.usage.inputTokens, result.usage.outputTokens, currentModel, result.thinkingTokens, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
+
+      // Graduated cost warnings
+      emitCostWarningIfNeeded(sessionCostUsd, effectiveBudget, costWarningsEmitted, text => {
+        if (emitter) {
+          emitter.emitText(text);
+        } else {
+          callbacks.onText(text);
         }
-        else if (mcpClientManager.isMcpTool(name)) {
-            result = await mcpClientManager.callTool(name, effectiveInput);
+      });
+
+      // Server-side context management notification
+      if (result.contextManagementApplied) {
+        callbacks.onAutoCompact?.(messages.length, messages.length, 0);
+        emitter?.emitCompact(messages.length, messages.length, 0);
+        logSpan({
+          action: "chat.api_compaction",
+          durationMs: Date.now() - apiStart,
+          context: turnCtx,
+          storeId: storeId || undefined,
+          details: {
+            type: "server_side",
+            has_compaction_content: result.compactionContent !== null,
+            iteration
+          }
+        });
+      }
+      if (result.text) allAssistantText.push(result.text);
+
+      // Telemetry: API call span
+      const iterCostUsd = estimateCostUsd(result.usage.inputTokens, result.usage.outputTokens, currentModel, result.thinkingTokens, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
+      logSpan({
+        action: "claude_api_request",
+        durationMs: Date.now() - apiStart,
+        context: {
+          ...turnCtx,
+          spanId: apiSpanId,
+          rowId: apiRowId,
+          inputTokens: result.usage.inputTokens,
+          outputTokens: result.usage.outputTokens,
+          totalCost: iterCostUsd,
+          model: currentModel
+        },
+        storeId: storeId || undefined,
+        details: {
+          "gen_ai.request.model": currentModel,
+          "gen_ai.usage.input_tokens": result.usage.inputTokens,
+          "gen_ai.usage.output_tokens": result.usage.outputTokens,
+          "gen_ai.usage.cache_creation_tokens": result.usage.cacheCreationTokens,
+          "gen_ai.usage.cache_read_tokens": result.usage.cacheReadTokens,
+          "gen_ai.usage.cost": iterCostUsd,
+          stop_reason: result.stopReason === "compaction" ? "compaction" : result.toolUseBlocks.length > 0 ? "tool_use" : "end_turn",
+          iteration,
+          tool_count: result.toolUseBlocks.length,
+          tool_names: result.toolUseBlocks.map(t => t.name)
         }
-        else {
-            result = { success: false, output: `Unknown tool: ${name}` };
+      });
+
+      // Compaction handling — API paused after generating summary.
+      // Per Anthropic docs: the compaction block replaces all prior context.
+      // Do NOT preserve old messages — they can exceed the trigger threshold
+      // and cause an infinite compaction loop. The summary captures all context.
+      if (result.stopReason === "compaction" && result.compactionContent) {
+        compactionCount++;
+        consecutiveCompactions++;
+        logSpan({
+          action: "chat.compaction_pause",
+          durationMs: Date.now() - apiStart,
+          context: turnCtx,
+          storeId: storeId || undefined,
+          details: {
+            compaction_count: compactionCount,
+            consecutive: consecutiveCompactions,
+            messages_before: messages.length
+          }
+        });
+
+        // Circuit breaker: if compaction fires repeatedly without progress,
+        // the summary + system prompt alone may exceed the trigger. Force wrap-up.
+        const MAX_CONSECUTIVE_COMPACTIONS = 3;
+        const shouldWrapUp = consecutiveCompactions > MAX_CONSECUTIVE_COMPACTIONS || compactionCount * effectiveCompactionTrigger >= effectiveCompactionBudget;
+        const compactedMessages = [{
+          role: "assistant",
+          content: [{
+            type: "compaction",
+            content: result.compactionContent
+          }]
+        }, {
+          role: "user",
+          content: [{
+            type: "text",
+            text: shouldWrapUp ? "You have reached the context budget. Please wrap up your current work and provide a final summary of what was accomplished and what remains." : "Continue with your task."
+          }]
+        }];
+        messages.length = 0;
+        messages.push(...compactedMessages);
+        if (shouldWrapUp) {
+          const budgetMsg = consecutiveCompactions > MAX_CONSECUTIVE_COMPACTIONS ? "\n[Compaction loop detected — wrapping up.]" : "\n[Context budget reached — wrapping up.]";
+          if (emitter) {
+            emitter.emitText(budgetMsg);
+          } else {
+            callbacks.onText(budgetMsg);
+          }
         }
-        // AfterTool hook — may modify output
-        if (hooks.length > 0) {
-            const afterResult = await runAfterToolHook(hooks, name, result.output, result.success);
-            if (afterResult.modifiedOutput !== undefined) {
-                result = { ...result, output: afterResult.modifiedOutput };
-            }
+        iteration--; // Don't count compaction as an iteration
+        continue;
+      }
+
+      // No tool calls — check if we should continue or stop
+      if (result.toolUseBlocks.length === 0) {
+        // If model hit max_tokens, it was truncated mid-response — continue so it can finish.
+        // Cap at MAX_CONTINUATIONS to prevent infinite loops on very large outputs (e.g. HTML reports).
+        if (result.stopReason === "max_tokens" && maxTokensContinuations < maxContinuations) {
+          maxTokensContinuations++;
+          const truncatedText = result.text || "";
+          const assistantContent = buildAssistantContent({
+            text: truncatedText,
+            toolUseBlocks: [],
+            thinkingBlocks: result.thinkingBlocks,
+            compactionContent: result.compactionContent
+          });
+          messages.push({
+            role: "assistant",
+            content: assistantContent
+          });
+
+          // Escalating continuation prompts — if the model keeps hitting max_tokens,
+          // it's probably trying to write a large file. Guide it toward smaller chunks.
+          const continuationText = maxTokensContinuations === 1 ? "[Your response was truncated due to the output token limit. If you were writing a large file, split it into multiple smaller write_file calls (~200 lines each) or use run_command with a heredoc. Continue concisely.]" : `[Your response was truncated again (attempt ${maxTokensContinuations}/${maxContinuations}). You MUST reduce output size. For large files: use multiple write_file calls of ~100-200 lines each, or write via run_command. Do NOT attempt to write the entire file in one call.]`;
+          messages.push({
+            role: "user",
+            content: [{
+              type: "text",
+              text: continuationText
+            }]
+          });
+          continue;
         }
-        return result;
-    };
-    try {
-        for (let iteration = 0; iteration < effectiveMaxTurns; iteration++) {
-            if (abortSignal?.aborted) {
-                logSpan({ action: "chat.cancelled", durationMs: Date.now() - sessionStart, context: turnCtx, storeId: storeId || undefined, details: { iteration, reason: "user_abort" } });
-                callbacks.onError("Cancelled", messages);
-                return;
-            }
-            // Budget enforcement — always enforced (defaults to DEFAULT_SESSION_COST_BUDGET_USD)
-            if (sessionCostUsd >= effectiveBudget) {
-                logSpan({ action: "chat.budget_exceeded", durationMs: Date.now() - sessionStart, context: turnCtx, storeId: storeId || undefined, severity: "warn", details: { session_cost_usd: sessionCostUsd, max_budget_usd: effectiveBudget, iteration } });
-                callbacks.onError(`Budget exceeded: $${sessionCostUsd.toFixed(4)} >= $${effectiveBudget}`, messages);
-                return;
-            }
-            const apiStart = Date.now();
-            const apiSpanId = generateSpanId();
-            const apiRowId = crypto.randomUUID(); // UUID for this span's row — children reference via parent_id
-            const costContext = `Session cost: $${sessionCostUsd.toFixed(2)} | Budget remaining: $${(effectiveBudget - sessionCostUsd).toFixed(2)}`;
-            // Build API request config
-            const currentModel = getModel();
-            const apiConfig = buildAPIRequest({
-                model: currentModel,
-                contextProfile: "main",
-                thinkingEnabled: opts.thinking,
-                contextOverrides: ctxOverrides,
-            });
-            // Prepare with prompt caching
-            let { tools: cachedTools, messages: cachedMessages } = prepareWithCaching(tools, messages);
-            const system = buildSystemBlocks(systemPrompt, costContext);
-            // Client-side context trimming for non-Anthropic providers.
-            // Uses prevIterationInputTokens (actual context size from last API call) — NOT
-            // cumulative sessionInputTokens, which grows quadratically and would trigger too early.
-            const provider = getProvider(currentModel);
-            if (provider === "gemini" || provider === "openai") {
-                const preTrimMessages = cachedMessages;
-                if (provider === "gemini") {
-                    // Emergency fallback only — compaction fires at 700K first; trim at 950K catches failures
-                    cachedMessages = trimGeminiContext(cachedMessages, prevIterationInputTokens);
-                }
-                else {
-                    // Emergency fallback only — compaction fires at 120K first; trim at 190K catches failures
-                    // GPT-4o: 128K context → 96K threshold (no compaction headroom)
-                    const threshold = currentModel === "gpt-4o" ? 96_000 : 190_000;
-                    cachedMessages = trimOpenAIContext(cachedMessages, prevIterationInputTokens, threshold);
-                }
-                // Notify UI when trimming actually occurred (trim returns same ref if no-op)
-                if (cachedMessages !== preTrimMessages) {
-                    // Count tool results before/after to report meaningful numbers
-                    const countToolResults = (msgs) => msgs.reduce((sum, m) => sum + (Array.isArray(m.content)
-                        ? m.content.filter(b => b.type === "tool_result" && b.content !== "[trimmed]").length
-                        : 0), 0);
-                    const activeBefore = countToolResults(preTrimMessages);
-                    const activeAfter = countToolResults(cachedMessages);
-                    const estimatedSaved = Math.round(prevIterationInputTokens * ((activeBefore - activeAfter) / Math.max(activeBefore, 1)));
-                    callbacks.onAutoCompact?.(activeBefore, activeAfter, estimatedSaved);
-                    emitter?.emitCompact(activeBefore, activeAfter, estimatedSaved);
-                }
-            }
-            // Get auth token
-            const token = await getValidToken();
-            if (!token) {
-                throw new Error("Not logged in. Run: whale login");
-            }
-            // Call server proxy with built-in retry
-            const originalModel = currentModel;
-            const stream = await callServerProxy({
-                proxyUrl: getProxyUrl(),
-                token,
-                model: currentModel,
-                system,
-                messages: cachedMessages,
-                tools: cachedTools,
-                apiConfig,
-                signal: abortSignal,
-                fallbackModel: opts.fallbackModel,
-                storeId: storeId || undefined,
-                onFallback: (from, to) => {
-                    setModel(to);
-                    logSpan({ action: "claude_api_fallback", durationMs: 0, context: { ...turnCtx, spanId: apiSpanId }, storeId: storeId || undefined, details: { from_model: from, to_model: to } });
-                },
-                onRetry: (attempt, max, err) => {
-                    const msg = `\n\x1b[33m\u21BB Retrying (${attempt}/${max})... ${err.slice(0, 80)}\x1b[0m\n`;
-                    if (emitter) {
-                        emitter.emitText(msg);
-                    }
-                    else {
-                        callbacks.onText(msg);
-                    }
-                },
-                onTokenRefresh: async () => {
-                    const result = await refreshSession();
-                    return result.success ? result.config.access_token : null;
-                },
-            });
-            // Process stream events with UI callbacks
-            let thinkingChunks = 0;
-            const result = await processStreamWithCallbacks(parseSSEStream(stream, abortSignal), {
-                onText: (text) => {
-                    if (emitter) {
-                        emitter.emitText(text);
-                    }
-                    else {
-                        callbacks.onText(text);
-                    }
-                },
-                onThinking: () => {
-                    thinkingChunks++;
-                    emitter?.emitThinking(thinkingChunks);
-                },
-                onToolStart: (name, input) => {
-                    // NOTE: Do NOT call callbacks.onToolStart here — dispatchTools.onStart
-                    // fires it once per tool at execution time. Calling it here too would
-                    // send duplicate tool_start events (stale spinners in WhaleChat).
-                    if (input) {
-                        // Tool block complete — emit structured start for CLI TUI only
-                        emitter?.emitToolStart("", name);
-                    }
-                },
-            }, abortSignal);
-            // Flush buffered text
-            emitter?.flushText();
-            // Restore original model after transient fallback
-            if (getModel() !== originalModel && opts.fallbackModel) {
-                setModelById(originalModel);
-            }
-            // Update session token tracking
-            sessionInputTokens += result.usage.inputTokens;
-            sessionOutputTokens += result.usage.outputTokens;
-            prevIterationInputTokens = result.usage.inputTokens; // Actual context size for next trim check
-            // Emit usage with model + cost context for all providers
-            if (emitter && (result.usage.inputTokens > 0 || result.usage.outputTokens > 0)) {
-                const iterCost = estimateCostUsd(result.usage.inputTokens, result.usage.outputTokens, currentModel, result.thinkingTokens, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
-                emitter.emitUsage(result.usage.inputTokens, result.usage.outputTokens, currentModel, iterCost, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
-            }
-            totalIn += result.usage.inputTokens;
-            totalOut += result.usage.outputTokens;
-            totalCacheCreation += result.usage.cacheCreationTokens;
-            totalCacheRead += result.usage.cacheReadTokens;
-            totalThinking += result.thinkingTokens;
-            sessionCostUsd += estimateCostUsd(result.usage.inputTokens, result.usage.outputTokens, currentModel, result.thinkingTokens, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
-            // Graduated cost warnings
-            emitCostWarningIfNeeded(sessionCostUsd, effectiveBudget, costWarningsEmitted, (text) => { if (emitter) {
-                emitter.emitText(text);
-            }
-            else {
-                callbacks.onText(text);
-            } });
-            // Server-side context management notification
-            if (result.contextManagementApplied) {
-                callbacks.onAutoCompact?.(messages.length, messages.length, 0);
-                emitter?.emitCompact(messages.length, messages.length, 0);
-                logSpan({ action: "chat.api_compaction", durationMs: Date.now() - apiStart, context: turnCtx, storeId: storeId || undefined, details: { type: "server_side", has_compaction_content: result.compactionContent !== null, iteration } });
-            }
-            if (result.text)
-                allAssistantText.push(result.text);
-            // Telemetry: API call span
-            const iterCostUsd = estimateCostUsd(result.usage.inputTokens, result.usage.outputTokens, currentModel, result.thinkingTokens, result.usage.cacheReadTokens, result.usage.cacheCreationTokens);
-            logSpan({
-                action: "claude_api_request",
-                durationMs: Date.now() - apiStart,
-                context: { ...turnCtx, spanId: apiSpanId, rowId: apiRowId, inputTokens: result.usage.inputTokens, outputTokens: result.usage.outputTokens, totalCost: iterCostUsd, model: currentModel },
-                storeId: storeId || undefined,
-                details: {
-                    "gen_ai.request.model": currentModel,
-                    "gen_ai.usage.input_tokens": result.usage.inputTokens,
-                    "gen_ai.usage.output_tokens": result.usage.outputTokens,
-                    "gen_ai.usage.cache_creation_tokens": result.usage.cacheCreationTokens,
-                    "gen_ai.usage.cache_read_tokens": result.usage.cacheReadTokens,
-                    "gen_ai.usage.cost": iterCostUsd,
-                    stop_reason: result.stopReason === "compaction" ? "compaction" : result.toolUseBlocks.length > 0 ? "tool_use" : "end_turn",
-                    iteration,
-                    tool_count: result.toolUseBlocks.length,
-                    tool_names: result.toolUseBlocks.map(t => t.name),
-                },
-            });
-            // Compaction handling — API paused after generating summary.
-            // Preserve last 2 messages for continuity, then resume.
-            if (result.stopReason === "compaction" && result.compactionContent) {
-                compactionCount++;
-                logSpan({ action: "chat.compaction_pause", durationMs: Date.now() - apiStart, context: turnCtx, storeId: storeId || undefined, details: { compaction_count: compactionCount, messages_before: messages.length } });
-                // Budget enforcement
-                if (compactionCount * effectiveCompactionTrigger >= effectiveCompactionBudget) {
-                    const budgetMsg = "\n[Context budget reached — wrapping up.]";
-                    if (emitter) {
-                        emitter.emitText(budgetMsg);
-                    }
-                    else {
-                        callbacks.onText(budgetMsg);
-                    }
-                    const compactedMessages = [
-                        { role: "assistant", content: [{ type: "compaction", content: result.compactionContent }] },
-                        { role: "user", content: [{ type: "text", text: "You have reached the context budget. Please wrap up your current work and provide a final summary of what was accomplished and what remains." }] },
-                    ];
-                    messages.length = 0;
-                    messages.push(...compactedMessages);
-                    continue;
-                }
-                // Normal compaction: preserve last 2 messages for continuity
-                const preserved = messages.slice(-2);
-                const compactedMessages = [
-                    { role: "assistant", content: [{ type: "compaction", content: result.compactionContent }] },
-                    ...preserved,
-                ];
-                messages.length = 0;
-                messages.push(...compactedMessages);
-                iteration--; // Don't count compaction as an iteration
-                continue;
-            }
-            // No tool calls — check if we should continue or stop
-            if (result.toolUseBlocks.length === 0) {
-                // If model hit max_tokens, it was truncated mid-response — continue so it can finish
-                if (result.stopReason === "max_tokens") {
-                    const truncatedText = result.text || "";
-                    const assistantContent = buildAssistantContent({
-                        text: truncatedText,
-                        toolUseBlocks: [],
-                        thinkingBlocks: result.thinkingBlocks,
-                        compactionContent: result.compactionContent,
-                    });
-                    messages.push({ role: "assistant", content: assistantContent });
-                    messages.push({ role: "user", content: [{ type: "text", text: "[Your response was truncated due to length. Please continue where you left off.]" }] });
-                    continue;
-                }
-                break;
-            }
-            // Execute tools via shared dispatch
-            const { results: toolResults, bailOut, bailMessage } = await dispatchTools(result.toolUseBlocks, toolExecutor, {
-                loopDetector,
-                maxConcurrent: 7,
-                onStart: (name, input) => {
-                    callbacks.onToolStart(name, input);
-                },
-                onResult: (name, success, output, durationMs) => {
-                    callbacks.onToolResult(name, success, output, undefined, durationMs);
-                    logSpan({
-                        action: `tool.${name}`,
-                        durationMs,
-                        context: { ...turnCtx, spanId: generateSpanId(), parentSpanId: apiSpanId, parentId: apiRowId },
-                        storeId: storeId || undefined,
-                        error: success ? undefined : output,
-                        details: {
-                            tool_input: {},
-                            tool_result: truncateResult(output, 2000),
-                            error_type: success ? undefined : classifyToolError(output),
-                            iteration,
-                        },
-                    });
-                },
-                signal: abortSignal,
-                transcribeAudio: storeId
-                    ? async (base64, mediaType) => callTranscribe({
-                        proxyUrl: getProxyUrl(),
-                        token,
-                        storeId: storeId,
-                        audioBase64: base64,
-                        mediaType,
-                    })
-                    : undefined,
-            });
-            if (bailOut) {
-                logSpan({ action: "chat.bail_out", durationMs: Date.now() - sessionStart, context: turnCtx, storeId: storeId || undefined, severity: "warn", details: { ...loopDetector.getSessionStats(), message: bailMessage, iteration } });
-            }
-            // Shell output summarization — summarize long bash output to save context window
-            const toolNameMap = new Map(result.toolUseBlocks.map(t => [t.id, t.name]));
-            const finalToolResults = await summarizeLongToolResults(toolResults, toolNameMap, getProxyUrl(), token, shellSummarization, storeId || undefined);
-            // Build assistant content and append to conversation
-            const assistantContent = buildAssistantContent({
-                text: result.text,
-                toolUseBlocks: result.toolUseBlocks,
-                thinkingBlocks: result.thinkingBlocks,
-                compactionContent: result.compactionContent,
-            });
-            messages.push({ role: "assistant", content: assistantContent });
-            // Check for __PLAN_APPROVED_CLEAN__ marker — clear context and start fresh with just the plan
-            const planCleanMarker = "__PLAN_APPROVED_CLEAN__\n";
-            const hasCleanPlanApproval = finalToolResults.some((tr) => {
-                const content = typeof tr.content === "string" ? tr.content : "";
-                return content.startsWith(planCleanMarker);
-            });
-            if (hasCleanPlanApproval) {
-                // Extract plan content from the marker
-                const planResult = finalToolResults.find((tr) => {
-                    const content = typeof tr.content === "string" ? tr.content : "";
-                    return content.startsWith(planCleanMarker);
-                });
-                const planText = planResult.content.slice(planCleanMarker.length);
-                const beforeCount = messages.length;
-                messages.length = 0;
-                messages.push({ role: "user", content: [{ type: "text", text: `Implement this plan:\n\n${planText}` }] });
-                callbacks.onAutoCompact?.(beforeCount, 1, 0);
-                continue;
-            }
-            messages.push({ role: "user", content: finalToolResults });
-            // Non-native compaction for OpenAI/Gemini — fires after tool results appended
-            const compactionCfg = getCompactionConfig(currentModel);
-            if (!compactionCfg.isNative && result.usage.inputTokens >= compactionCfg.triggerTokens) {
-                compactionCount++;
-                if (compactionCount * compactionCfg.triggerTokens >= compactionCfg.totalBudget) {
-                    // Budget exhaustion — force wrap-up (same as native compaction budget logic)
-                    const budgetMsg = "\n[Context budget reached — wrapping up.]";
-                    if (emitter) {
-                        emitter.emitText(budgetMsg);
-                    }
-                    else {
-                        callbacks.onText(budgetMsg);
-                    }
-                    const summary = await requestProviderCompaction({
-                        proxyUrl: getProxyUrl(),
-                        token,
-                        messages: messages,
-                        systemPrompt,
-                    });
-                    const compactedMessages = [
-                        ...(summary
-                            ? [{ role: "assistant", content: [{ type: "compaction", content: summary }] }]
-                            : []),
-                        { role: "user", content: [{ type: "text", text: "You have reached the context budget. Please wrap up your current work and provide a final summary of what was accomplished and what remains." }] },
-                    ];
-                    messages.length = 0;
-                    messages.push(...compactedMessages);
-                    continue;
-                }
-                // Normal compaction — summarize and preserve last 2 messages
-                const summary = await requestProviderCompaction({
-                    proxyUrl: getProxyUrl(),
-                    token,
-                    messages: messages,
-                    systemPrompt,
-                });
-                if (summary) {
-                    const preserved = messages.slice(-2);
-                    const compactedMessages = [
-                        { role: "assistant", content: [{ type: "compaction", content: summary }] },
-                        ...preserved,
-                    ];
-                    messages.length = 0;
-                    messages.push(...compactedMessages);
-                    iteration--; // Don't count compaction as an iteration
-                    callbacks.onAutoCompact?.(messages.length + preserved.length, messages.length, Math.round(result.usage.inputTokens * 0.7));
-                    emitter?.emitCompact(messages.length + preserved.length, messages.length, Math.round(result.usage.inputTokens * 0.7));
-                    logSpan({ action: "chat.provider_compaction", durationMs: 0, context: turnCtx, storeId: storeId || undefined, details: { compaction_count: compactionCount, provider, model: currentModel, input_tokens: result.usage.inputTokens, trigger_tokens: compactionCfg.triggerTokens } });
-                }
+        break;
+      }
+
+      // Reset counters — model is taking tool actions, making progress
+      maxTokensContinuations = 0;
+      consecutiveCompactions = 0;
+
+      // Execute tools via shared dispatch
+      const {
+        results: toolResults,
+        bailOut,
+        bailMessage
+      } = await dispatchTools(result.toolUseBlocks, toolExecutor, {
+        loopDetector,
+        maxConcurrent: resolved?.maxConcurrentTools ?? AGENT_DEFAULTS.maxConcurrentTools,
+        batchErrorLimit: resolved?.loopBatchErrorLimit ?? AGENT_DEFAULTS.loopBatchErrorLimit,
+        onStart: (name, input) => {
+          callbacks.onToolStart(name, input);
+        },
+        onResult: (name, success, output, durationMs) => {
+          callbacks.onToolResult(name, success, output, undefined, durationMs);
+          logSpan({
+            action: `tool.${name}`,
+            durationMs,
+            context: {
+              ...turnCtx,
+              spanId: generateSpanId(),
+              parentSpanId: apiSpanId,
+              parentId: apiRowId
+            },
+            storeId: storeId || undefined,
+            error: success ? undefined : output,
+            details: {
+              tool_input: {},
+              tool_result: truncateResult(output, 2000),
+              error_type: success ? undefined : classifyToolError(output),
+              iteration
             }
-        }
-        // Telemetry: session summary
+          });
+        },
+        signal: abortSignal,
+        transcribeAudio: storeId ? async (base64, mediaType) => callTranscribe({
+          proxyUrl: getProxyUrl(),
+          token,
+          storeId: storeId,
+          audioBase64: base64,
+          mediaType
+        }) : undefined
+      });
+      if (bailOut) {
         logSpan({
-            action: "chat.session_complete",
-            durationMs: Date.now() - sessionStart,
-            context: { ...turnCtx, inputTokens: totalIn, outputTokens: totalOut, model: activeModel },
+          action: "chat.bail_out",
+          durationMs: Date.now() - sessionStart,
+          context: turnCtx,
+          storeId: storeId || undefined,
+          severity: "warn",
+          details: {
+            ...loopDetector.getSessionStats(),
+            message: bailMessage,
+            iteration
+          }
+        });
+      }
+
+      // Shell output summarization — summarize long bash output to save context window
+      const toolNameMap = new Map(result.toolUseBlocks.map(t => [t.id, t.name]));
+      const finalToolResults = await summarizeLongToolResults(toolResults, toolNameMap, getProxyUrl(), token, shellSummarization, storeId || undefined);
+
+      // Build assistant content and append to conversation
+      const assistantContent = buildAssistantContent({
+        text: result.text,
+        toolUseBlocks: result.toolUseBlocks,
+        thinkingBlocks: result.thinkingBlocks,
+        compactionContent: result.compactionContent
+      });
+      messages.push({
+        role: "assistant",
+        content: assistantContent
+      });
+
+      // Check for __PLAN_APPROVED_CLEAN__ marker — clear context and start fresh with just the plan
+      const planCleanMarker = "__PLAN_APPROVED_CLEAN__\n";
+      const hasCleanPlanApproval = finalToolResults.some(tr => {
+        const content = typeof tr.content === "string" ? tr.content : "";
+        return content.startsWith(planCleanMarker);
+      });
+      if (hasCleanPlanApproval) {
+        // Extract plan content from the marker
+        const planResult = finalToolResults.find(tr => {
+          const content = typeof tr.content === "string" ? tr.content : "";
+          return content.startsWith(planCleanMarker);
+        });
+        const planText = planResult.content.slice(planCleanMarker.length);
+        const beforeCount = messages.length;
+        messages.length = 0;
+        messages.push({
+          role: "user",
+          content: [{
+            type: "text",
+            text: `Implement this plan:\n\n${planText}`
+          }]
+        });
+        callbacks.onAutoCompact?.(beforeCount, 1, 0);
+        continue;
+      }
+      messages.push({
+        role: "user",
+        content: finalToolResults
+      });
+
+      // Non-native compaction for OpenAI/Gemini — fires after tool results appended
+      const compactionCfg = getCompactionConfig(currentModel);
+      if (!compactionCfg.isNative && result.usage.inputTokens >= compactionCfg.triggerTokens) {
+        compactionCount++;
+        if (compactionCount * compactionCfg.triggerTokens >= compactionCfg.totalBudget) {
+          // Budget exhaustion — force wrap-up (same as native compaction budget logic)
+          const budgetMsg = "\n[Context budget reached — wrapping up.]";
+          if (emitter) {
+            emitter.emitText(budgetMsg);
+          } else {
+            callbacks.onText(budgetMsg);
+          }
+          const summary = await requestProviderCompaction({
+            proxyUrl: getProxyUrl(),
+            token,
+            messages,
+            systemPrompt
+          });
+          const compactedMessages = [...(summary ? [{
+            role: "assistant",
+            content: [{
+              type: "compaction",
+              content: summary
+            }]
+          }] : []), {
+            role: "user",
+            content: [{
+              type: "text",
+              text: "You have reached the context budget. Please wrap up your current work and provide a final summary of what was accomplished and what remains."
+            }]
+          }];
+          messages.length = 0;
+          messages.push(...compactedMessages);
+          continue;
+        }
+
+        // Normal compaction — summarize, don't preserve old messages (prevents loop)
+        const summary = await requestProviderCompaction({
+          proxyUrl: getProxyUrl(),
+          token,
+          messages: messages,
+          systemPrompt
+        });
+        if (summary) {
+          const beforeCount = messages.length;
+          const compactedMessages = [{
+            role: "assistant",
+            content: [{
+              type: "compaction",
+              content: summary
+            }]
+          }, {
+            role: "user",
+            content: [{
+              type: "text",
+              text: "Continue with your task."
+            }]
+          }];
+          messages.length = 0;
+          messages.push(...compactedMessages);
+          iteration--; // Don't count compaction as an iteration
+
+          callbacks.onAutoCompact?.(beforeCount, messages.length, Math.round(result.usage.inputTokens * 0.7));
+          emitter?.emitCompact(beforeCount, messages.length, Math.round(result.usage.inputTokens * 0.7));
+          logSpan({
+            action: "chat.provider_compaction",
+            durationMs: 0,
+            context: turnCtx,
             storeId: storeId || undefined,
             details: {
-                input_tokens: totalIn, output_tokens: totalOut, total_tokens: totalIn + totalOut,
-                cache_creation_tokens: totalCacheCreation, cache_read_tokens: totalCacheRead,
-                session_input_tokens: sessionInputTokens, session_output_tokens: sessionOutputTokens,
-                model: activeModel,
-            },
-        });
-        const turnCostUsd = estimateCostUsd(totalIn, totalOut, activeModel, totalThinking, totalCacheRead, totalCacheCreation);
-        callbacks.onUsage(totalIn, totalOut, totalThinking, activeModel, turnCostUsd, totalCacheRead, totalCacheCreation);
-        // Flush telemetry spans to server before session ends
-        flushCliSpans();
-        // Fire SessionEnd hook (non-blocking)
-        if (hooks.length > 0) {
-            runSessionHook(hooks, "SessionEnd", { session_id: `turn-${sessionStart}` }).catch(() => { });
+              compaction_count: compactionCount,
+              provider,
+              model: currentModel,
+              input_tokens: result.usage.inputTokens,
+              trigger_tokens: compactionCfg.triggerTokens
+            }
+          });
         }
-        const finalText = allAssistantText.length > 0 ? allAssistantText[allAssistantText.length - 1] : "";
-        emitter?.emitDone(finalText, messages);
-        if (emitter)
-            clearGlobalEmitter();
-        callbacks.onDone(messages);
+      }
     }
-    catch (err) {
-        const errorMsg = abortSignal?.aborted || err?.message === "Cancelled"
-            ? "Cancelled"
-            : String(err?.message || err);
-        logSpan({
-            action: errorMsg === "Cancelled" ? "chat.cancelled" : "chat.fatal_error",
-            durationMs: Date.now() - sessionStart,
-            context: { ...turnCtx, inputTokens: totalIn, outputTokens: totalOut, model: activeModel },
-            storeId: storeId || undefined,
-            severity: errorMsg === "Cancelled" ? "info" : "error",
-            error: errorMsg === "Cancelled" ? undefined : errorMsg,
-            details: { input_tokens: totalIn, output_tokens: totalOut, session_cost_usd: sessionCostUsd, model: activeModel },
-        });
-        // Capture to error_events (not just audit_logs) for non-cancellations
-        if (errorMsg !== "Cancelled") {
-            captureError({
-                error: err instanceof Error ? err : undefined,
-                errorType: "AgentLoopError",
-                errorMessage: errorMsg,
-                severity: "error",
-                traceId: turnCtx.traceId,
-                spanId: turnCtx.spanId,
-                storeId: storeId || undefined,
-                tags: { model: activeModel, turn: String(turnNum) },
-            });
+
+    // Telemetry: session summary
+    logSpan({
+      action: "chat.session_complete",
+      durationMs: Date.now() - sessionStart,
+      context: {
+        ...turnCtx,
+        inputTokens: totalIn,
+        outputTokens: totalOut,
+        model: activeModel
+      },
+      storeId: storeId || undefined,
+      details: {
+        input_tokens: totalIn,
+        output_tokens: totalOut,
+        total_tokens: totalIn + totalOut,
+        cache_creation_tokens: totalCacheCreation,
+        cache_read_tokens: totalCacheRead,
+        session_input_tokens: sessionInputTokens,
+        session_output_tokens: sessionOutputTokens,
+        model: activeModel
+      }
+    });
+    const turnCostUsd = estimateCostUsd(totalIn, totalOut, activeModel, totalThinking, totalCacheRead, totalCacheCreation);
+    callbacks.onUsage(totalIn, totalOut, totalThinking, activeModel, turnCostUsd, totalCacheRead, totalCacheCreation);
+
+    // Flush telemetry spans to server before session ends
+    flushCliSpans();
+
+    // Fire SessionEnd hook (non-blocking)
+    if (hooks.length > 0) {
+      runSessionHook(hooks, "SessionEnd", {
+        session_id: `turn-${sessionStart}`
+      }).catch(() => {});
+    }
+    const finalText = allAssistantText.length > 0 ? allAssistantText[allAssistantText.length - 1] : "";
+    emitter?.emitDone(finalText, messages);
+    if (emitter) clearGlobalEmitter();
+    callbacks.onDone(messages);
+  } catch (err) {
+    const errorMsg = abortSignal?.aborted || err?.message === "Cancelled" ? "Cancelled" : String(err?.message || err);
+    logSpan({
+      action: errorMsg === "Cancelled" ? "chat.cancelled" : "chat.fatal_error",
+      durationMs: Date.now() - sessionStart,
+      context: {
+        ...turnCtx,
+        inputTokens: totalIn,
+        outputTokens: totalOut,
+        model: activeModel
+      },
+      storeId: storeId || undefined,
+      severity: errorMsg === "Cancelled" ? "info" : "error",
+      error: errorMsg === "Cancelled" ? undefined : errorMsg,
+      details: {
+        input_tokens: totalIn,
+        output_tokens: totalOut,
+        session_cost_usd: sessionCostUsd,
+        model: activeModel
+      }
+    });
+
+    // Capture to error_events (not just audit_logs) for non-cancellations
+    if (errorMsg !== "Cancelled") {
+      captureError({
+        error: err instanceof Error ? err : undefined,
+        errorType: "AgentLoopError",
+        errorMessage: errorMsg,
+        severity: "error",
+        traceId: turnCtx.traceId,
+        spanId: turnCtx.spanId,
+        storeId: storeId || undefined,
+        tags: {
+          model: activeModel,
+          turn: String(turnNum)
         }
-        // Flush telemetry on error path too
-        flushCliSpans();
-        emitter?.emitError(errorMsg);
-        if (emitter)
-            clearGlobalEmitter();
-        callbacks.onError(errorMsg, messages);
+      });
     }
+
+    // Flush telemetry on error path too
+    flushCliSpans();
+    emitter?.emitError(errorMsg);
+    if (emitter) clearGlobalEmitter();
+    callbacks.onError(errorMsg, messages);
+  }
 }
+
 // ============================================================================
 // TELEMETRY HELPERS
 // ============================================================================
+
 export function truncateResult(output, maxLen) {
-    if (output.length <= maxLen)
-        return output;
-    return output.slice(0, maxLen) + `... (${output.length} chars total)`;
+  if (output.length <= maxLen) return output;
+  return output.slice(0, maxLen) + `... (${output.length} chars total)`;
 }
 export function classifyToolError(output) {
-    const lower = output.toLowerCase();
-    if (lower.includes("timed out") || lower.includes("timeout"))
-        return "timeout";
-    if (lower.includes("permission denied") || lower.includes("eacces"))
-        return "permission";
-    if (lower.includes("not found") || lower.includes("no such file"))
-        return "not_found";
-    if (lower.includes("command not found") || lower.includes("exit code 127"))
-        return "command_not_found";
-    if (lower.includes("import") && lower.includes("error"))
-        return "import_error";
-    if (lower.includes("syntax") || lower.includes("parse"))
-        return "syntax_error";
-    if (lower.includes("externally-managed"))
-        return "env_managed";
-    return "unknown";
+  const lower = output.toLowerCase();
+  if (lower.includes("timed out") || lower.includes("timeout")) return "timeout";
+  if (lower.includes("permission denied") || lower.includes("eacces")) return "permission";
+  if (lower.includes("not found") || lower.includes("no such file")) return "not_found";
+  if (lower.includes("command not found") || lower.includes("exit code 127")) return "command_not_found";
+  if (lower.includes("import") && lower.includes("error")) return "import_error";
+  if (lower.includes("syntax") || lower.includes("parse")) return "syntax_error";
+  if (lower.includes("externally-managed")) return "env_managed";
+  return "unknown";
 }
+
 // Convenience: check if user can use the agent (logged in OR has API key)
 export function canUseAgent() {
-    const config = loadConfig();
-    const hasToken = !!(config.access_token && config.refresh_token);
-    const hasApiKey = !!(process.env.ANTHROPIC_API_KEY || config.anthropic_api_key);
-    if (hasToken || hasApiKey)
-        return { ready: true };
-    return { ready: false, reason: "Run `whale login` to authenticate." };
+  const config = loadConfig();
+  const hasToken = !!(config.access_token && config.refresh_token);
+  const hasApiKey = !!(process.env.ANTHROPIC_API_KEY || config.anthropic_api_key);
+  if (hasToken || hasApiKey) return {
+    ready: true
+  };
+  return {
+    ready: false,
+    reason: "Run `whale login` to authenticate."
+  };
+}
+
+// ============================================================================
+// SESSION MODE — delegate to server-side SessionManager
+// ============================================================================
+
+import { SessionClient } from "./session-client.js";
+
+/** Check if session mode should be used (auto-detect by default). */
+async function shouldUseSessionMode() {
+  if (process.env.WHALE_SESSION_MODE === "off") return false;
+  if (process.env.WHALE_SESSION_MODE === "on") return true;
+
+  // Never auto-activate for interactive CLI — the emitter-based TUI
+  // requires the local loop. Session mode only activates via explicit
+  // env var or `whale resume <id>` (which sets WHALE_SESSION_MODE=on).
+  if (process.stdin.isTTY) return false;
+
+  // Auto: if logged in + server reachable → session mode (non-TTY: print mode, MCP)
+  const proxyUrl = getProxyUrl();
+  if (!proxyUrl) return false;
+  const config = resolveConfig();
+  if (!config.storeId) return false;
+  const client = new SessionClient(proxyUrl, getValidToken);
+  return client.healthCheck();
+}
+
+/**
+ * Run agent loop in session mode — all state managed server-side.
+ * The entire existing local loop stays as offline fallback.
+ */
+async function runSessionAgentLoop(opts) {
+  const {
+    message,
+    conversationHistory,
+    callbacks,
+    abortSignal,
+    emitter
+  } = opts;
+  const proxyUrl = getProxyUrl();
+  if (!proxyUrl) throw new Error("Session mode requires server connection");
+
+  // Set global emitter for subagents (mirrors local loop behavior)
+  if (emitter) setGlobalEmitter(emitter);
+  const client = new SessionClient(proxyUrl, getValidToken);
+  const config = resolveConfig();
+  const storeId = config.storeId;
+  if (!storeId) {
+    callbacks.onError("Session mode requires store_id in config. Falling back to local mode.");
+    if (emitter) clearGlobalEmitter();
+    return;
+  }
+
+  // Resolve agent ID: use config, or query server for store's first active agent
+  let agentId = config.defaultAgentId;
+  if (!agentId) {
+    agentId = (await resolveDefaultAgentId(proxyUrl, storeId, getValidToken)) || "";
+  }
+  if (!agentId) {
+    callbacks.onError("No agent configured. Set default_agent_id in config or create an agent. Falling back to local mode.");
+    if (emitter) clearGlobalEmitter();
+    return;
+  }
+
+  // Resume existing session or create new one
+  const resumeId = process.env.WHALE_RESUME_SESSION_ID;
+  let sessionId;
+  if (resumeId) {
+    sessionId = resumeId;
+    delete process.env.WHALE_RESUME_SESSION_ID; // consume once
+  } else {
+    const session = await client.createSession({
+      storeId,
+      agentId,
+      surface: "cli",
+      message
+    });
+    sessionId = session.id;
+  }
+
+  // Save local session backup with server session reference
+  const localSessionId = saveSession(conversationHistory);
+  updateSessionMeta(localSessionId, {
+    serverSessionId: sessionId,
+    synced: true
+  });
+
+  // Track accumulated text for emitDone — the TUI's handleDone handler
+  // overwrites accTextRef with event.text, so we must pass the full text.
+  let accumulatedText = "";
+  // Guard against double-error: SessionClient.sendMessage calls onError AND
+  // throws for HTTP errors. The catch must not re-fire emitter/callbacks.
+  let errorHandled = false;
+  try {
+    await client.sendMessage(sessionId, message, {
+      onText: text => {
+        accumulatedText += text;
+        if (emitter) {
+          emitter.emitText(text);
+        } else {
+          callbacks.onText(text);
+        }
+      },
+      onToolStart: (name, input) => {
+        callbacks.onToolStart(name, input);
+        if (input) emitter?.emitToolStart("", name);
+      },
+      onToolResult: (name, success, result) => {
+        callbacks.onToolResult(name, success, result);
+      },
+      onUsage: (tokens, costUsd) => {
+        callbacks.onUsage(tokens.input, tokens.output, 0, getModel(), costUsd, tokens.cacheRead, tokens.cacheCreation);
+        if (emitter && (tokens.input > 0 || tokens.output > 0)) {
+          emitter.emitUsage(tokens.input, tokens.output, getModel(), costUsd, tokens.cacheRead, tokens.cacheCreation);
+        }
+      },
+      onDone: _conversationId => {
+        emitter?.flushText();
+        emitter?.emitDone(accumulatedText, conversationHistory);
+        if (emitter) clearGlobalEmitter();
+        callbacks.onDone(conversationHistory);
+      },
+      onError: err => {
+        errorHandled = true;
+        emitter?.emitError(err);
+        if (emitter) clearGlobalEmitter();
+        callbacks.onError(err);
+      }
+    }, abortSignal);
+  } catch (err) {
+    if (!errorHandled) {
+      const errorMsg = abortSignal?.aborted || err?.message === "Cancelled" ? "Cancelled" : String(err?.message || err);
+      emitter?.emitError(errorMsg);
+      if (emitter) clearGlobalEmitter();
+      callbacks.onError(errorMsg);
+    }
+  }
 }
+//# sourceMappingURL=agent-loop.js.map