whale-code 6.5.4 → 6.5.6

package/dist/cli/services/subagent.js

@@ -7,43 +7,57 @@
  * - Cost optimization (Haiku for simple tasks)
  * - Resume capability for long-running tasks
  */
+
 import { readFileSync, existsSync, writeFileSync, mkdirSync, appendFileSync } from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
-import { LOCAL_TOOL_DEFINITIONS, } from "./local-tools.js";
-import { LoopDetector, estimateCostUsd, demoteSubagentModel } from "../../shared/agent-core.js";
+import { LOCAL_TOOL_DEFINITIONS } from "./local-tools.js";
+import { LoopDetector, estimateCostUsd, demoteSubagentModel, AGENT_DEFAULTS, resolveAgentLoopConfig } from "../../shared/agent-core.js";
+import { preCompact } from "../../shared/compaction.js";
+import { loadCLIAgentConfig } from "./agent-config.js";
 import { MODEL_MAP } from "../../shared/constants.js";
-import { loadServerToolDefinitions, } from "./server-tools.js";
-import { logSpan, generateSpanId, generateTraceId } from "./telemetry.js";
+import { loadServerToolDefinitions } from "./server-tools.js";
+import { logSpan, generateSpanId, generateTraceId, PKG_VERSION } from "./telemetry.js";
 import { loadClaudeMd } from "./agent-loop.js";
 import { getGlobalEmitter } from "./agent-events.js";
 import { getAgentDefinition } from "./agent-definitions.js";
-import { callAgentAPI, executeToolBlocks, extractTextBlocks, extractToolUseBlocks, getResponseText, yieldToEventLoop, yieldForRender, } from "./agent-worker-base.js";
+import { callAgentAPI, executeToolBlocks, extractTextBlocks, extractToolUseBlocks, getResponseText, yieldToEventLoop, yieldForRender, deduplicateTools, assertUniqueToolNames } from "./agent-worker-base.js";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+// Documentation lookups, web research
+
+// Accepts built-in types + custom agent names from .whale/agents/
+
 // ============================================================================
 // CONSTANTS
 // ============================================================================
-const AGENTS_DIR = join(homedir(), ".swagmanager", "agents");
-// Claude Code pattern: subagents should be discrete tasks, not open-ended
-// Low turn limit prevents infinite loops and forces focused execution
-const MAX_TURNS = 8;
-const SUBAGENT_MAX_OUTPUT_TOKENS = 32_000; // Claude Code parity — subagents get 32K output
+
+const AGENTS_DIR = join(homedir(), ".whale", "agents");
+
+// No hard cap on subagent turns — agent self-regulates via end_turn (Claude Code parity).
+// DB config (subagent_max_turns) controls the default. Callers can override via max_turns param.
+
 // ============================================================================
 // AGENT PROMPTS — specialized per type
 // ============================================================================
+
 // Build agent prompt with working directory context
 function buildAgentPrompt(type, cwd) {
-    const cwdContext = `
+  const cwdContext = `
 ## Working Directory
 You are working in: ${cwd}
 All file paths should be relative to or absolute from this directory.
 IMPORTANT: Focus ONLY on files within this directory. Do not get confused by other projects.
 `;
-    // Check for custom agent definition first
-    const custom = getAgentDefinition(type);
-    if (custom)
-        return custom.prompt + cwdContext;
-    const prompts = {
-        explore: `You are an exploration agent. Your ONLY job is to quickly find specific information in the codebase, then STOP.
+
+  // Check for custom agent definition first
+  const custom = getAgentDefinition(type);
+  if (custom) return custom.prompt + cwdContext;
+  const prompts = {
+    explore: `You are an exploration agent. Your ONLY job is to quickly find specific information in the codebase, then STOP.
 
 Tools available:
 - glob: Find files by pattern (e.g., "**/*.ts")
@@ -70,7 +84,7 @@ Return a concise summary with:
 - Direct answer to the question asked
 
 IMPORTANT: Complete in 2-4 turns. If you haven't found it by turn 4, summarize what you found and STOP.`,
-        plan: `You are a planning agent. Your ONLY job is to analyze the codebase and create an implementation plan, then STOP.
+    plan: `You are a planning agent. Your ONLY job is to analyze the codebase and create an implementation plan, then STOP.
 
 Tools available:
 - glob: Find files by pattern
@@ -104,7 +118,7 @@ ${cwdContext}
 - [Any considerations]
 
 IMPORTANT: Complete in 3-5 turns. If you haven't finished by turn 5, output your best plan and STOP.`,
-        "general-purpose": `You are an autonomous agent for discrete tasks. Complete the task, then STOP.
+    "general-purpose": `You are an autonomous agent for discrete tasks. Complete the task, then STOP.
 
 Tools available:
 - File operations: read_file, write_file, edit_file, glob, grep
@@ -137,7 +151,7 @@ ${cwdContext}
 [Any problems encountered]
 
 IMPORTANT: This is a discrete task. Complete it in 4-6 turns maximum. Do not loop.`,
-        research: `You are a research agent. Find the specific information requested, then STOP.
+    research: `You are a research agent. Find the specific information requested, then STOP.
 
 Tools available:
 - web_fetch: Fetch and parse web content
@@ -171,446 +185,607 @@ ${cwdContext}
 ### Caveats
 [Any version requirements or limitations]
 
-IMPORTANT: Complete in 2-4 turns. Stop as soon as you have a good answer.`,
-    };
-    return prompts[type] || prompts["general-purpose"];
+IMPORTANT: Complete in 2-4 turns. Stop as soon as you have a good answer.`
+  };
+  return prompts[type] || prompts["general-purpose"];
 }
+
 // ============================================================================
 // AGENT STATE PERSISTENCE
 // ============================================================================
+
 function ensureAgentsDir() {
-    if (!existsSync(AGENTS_DIR))
-        mkdirSync(AGENTS_DIR, { recursive: true });
+  if (!existsSync(AGENTS_DIR)) mkdirSync(AGENTS_DIR, {
+    recursive: true
+  });
 }
 function saveAgentState(state) {
-    ensureAgentsDir();
-    const path = join(AGENTS_DIR, `${state.id}.json`);
-    writeFileSync(path, JSON.stringify(state, null, 2), "utf-8");
+  ensureAgentsDir();
+  const path = join(AGENTS_DIR, `${state.id}.json`);
+  writeFileSync(path, JSON.stringify(state, null, 2), "utf-8");
 }
 function loadAgentState(agentId) {
-    const path = join(AGENTS_DIR, `${agentId}.json`);
-    if (!existsSync(path))
-        return null;
-    try {
-        return JSON.parse(readFileSync(path, "utf-8"));
-    }
-    catch {
-        return null;
-    }
+  const path = join(AGENTS_DIR, `${agentId}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
 }
 function generateAgentId() {
-    return `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `agent-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
+
 // ============================================================================
 // TOOL FILTERING — restrict tools per agent type
 // ============================================================================
+
 function getToolsForAgent(type) {
-    // Check for custom agent definition with explicit tools
-    const custom = getAgentDefinition(type);
-    if (custom?.tools && custom.tools.length > 0)
-        return custom.tools;
-    switch (type) {
-        case "explore":
-            return ["glob", "grep", "read_file", "list_directory", "search_files", "search_content"];
-        case "plan":
-            return ["glob", "grep", "read_file", "list_directory", "search_files", "search_content"];
-        case "research":
-            return ["web_fetch", "web_search", "read_file", "grep", "glob"];
-        case "general-purpose":
-            // All tools
-            return [
-                "read_file", "write_file", "edit_file", "list_directory",
-                "search_files", "search_content", "run_command",
-                "glob", "grep", "notebook_edit", "web_fetch", "tasks",
-            ];
-        default:
-            return ["read_file", "glob", "grep"];
-    }
+  // Check for custom agent definition with explicit tools
+  const custom = getAgentDefinition(type);
+  if (custom?.tools && custom.tools.length > 0) return custom.tools;
+  switch (type) {
+    case "explore":
+      return ["glob", "grep", "read_file", "list_directory", "search_files", "search_content"];
+    case "plan":
+      return ["glob", "grep", "read_file", "list_directory", "search_files", "search_content"];
+    case "research":
+      return ["web_fetch", "web_search", "read_file", "grep", "glob"];
+    case "general-purpose":
+      // All tools EXCEPT delegation — "Subagents cannot spawn other subagents" (Claude Code parity)
+      return ["read_file", "write_file", "edit_file", "list_directory", "search_files", "search_content", "run_command", "glob", "grep", "notebook_edit", "web_fetch"];
+    default:
+      return ["read_file", "glob", "grep"];
+  }
 }
 async function getFilteredTools(type) {
-    const allowedNames = new Set(getToolsForAgent(type));
-    // Local tools
-    const localTools = LOCAL_TOOL_DEFINITIONS
-        .filter((t) => allowedNames.has(t.name))
-        .map((t) => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.input_schema,
-    }));
-    // Add web_search from server tools if allowed
-    if (allowedNames.has("web_search")) {
-        try {
-            const serverTools = await loadServerToolDefinitions();
-            const webSearch = serverTools.find((t) => t.name === "web_search");
-            if (webSearch)
-                localTools.push(webSearch);
-        }
-        catch { /* server tools unavailable */ }
-    }
-    return localTools;
+  const allowedNames = new Set(getToolsForAgent(type));
+
+  // Local tools
+  const localTools = LOCAL_TOOL_DEFINITIONS.filter(t => allowedNames.has(t.name)).map(t => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.input_schema
+  }));
+
+  // Add server tools if available, filtering by allowed names
+  try {
+    const serverTools = await loadServerToolDefinitions();
+    const allowedServerTools = serverTools.filter(t => allowedNames.has(t.name));
+    localTools.push(...allowedServerTools);
+  } catch {/* server tools unavailable */}
+
+  // Deduplicate: local tools take priority over server tools with same name
+  return deduplicateTools(localTools);
 }
+
 // ============================================================================
 // DISPLAY HELPERS — icons and colors for trace visualization
 // ============================================================================
+
 function getAgentIcon(type) {
-    const icons = {
-        explore: "🔍", // Magnifying glass for exploration
-        plan: "📋", // Clipboard for planning
-        "general-purpose": "🤖", // Robot for autonomous work
-        research: "📚", // Books for research
-    };
-    return icons[type] || "⚙️";
+  const icons = {
+    explore: "🔍",
+    // Magnifying glass for exploration
+    plan: "📋",
+    // Clipboard for planning
+    "general-purpose": "🤖",
+    // Robot for autonomous work
+    research: "📚" // Books for research
+  };
+  return icons[type] || "⚙️";
 }
 function getAgentColor(type) {
-    const colors = {
-        explore: "#3B82F6", // Blue for exploration
-        plan: "#8B5CF6", // Purple for planning
-        "general-purpose": "#10B981", // Green for general work
-        research: "#F59E0B", // Amber for research
-    };
-    return colors[type] || "#6B7280";
+  const colors = {
+    explore: "#3B82F6",
+    // Blue for exploration
+    plan: "#8B5CF6",
+    // Purple for planning
+    "general-purpose": "#10B981",
+    // Green for general work
+    research: "#F59E0B" // Amber for research
+  };
+  return colors[type] || "#6B7280";
 }
+
 // ============================================================================
 // SUBAGENT EXECUTION
 // ============================================================================
+
 // Progress emitter — uses event system instead of stderr to avoid UI conflicts
 // The global emitter batches and routes these to ChatApp without causing re-renders
 // NOTE: No module-level mutable state — agentId/turn passed through function params for parallel safety
+
 function emitSubagentProgress(agentType, agentId, message, turn, toolName) {
-    const emitter = getGlobalEmitter();
-    emitter.emitSubagentProgress(agentId, agentType, message, turn, toolName);
+  const emitter = getGlobalEmitter();
+  emitter.emitSubagentProgress(agentId, agentType, message, turn, toolName);
 }
 export async function runSubagent(options) {
-    const { prompt, subagent_type, model, resume, max_turns, name, parentContext, parentTraceContext } = options;
-    const agentId = resume || generateAgentId();
-    // Sub-agents default to Haiku for cost control — uses shared demotion logic
-    const demotedAlias = demoteSubagentModel(model, subagent_type);
-    const modelId = MODEL_MAP[demotedAlias] || MODEL_MAP["haiku"];
-    const cwd = process.cwd();
-    const systemPrompt = buildAgentPrompt(subagent_type, cwd);
-    const startTime = Date.now();
-    const effectiveMaxTurns = max_turns ? Math.max(1, Math.min(50, max_turns)) : MAX_TURNS;
-    // Extract short description from prompt (first sentence or 60 chars)
-    const descMatch = prompt.match(/^[^.!?\n]+/);
-    const shortDescription = name || (descMatch
-        ? descMatch[0].slice(0, 60) + (descMatch[0].length > 60 ? "…" : "")
-        : prompt.slice(0, 60) + (prompt.length > 60 ? "…" : ""));
-    // Emit subagent start event
-    const emitter = getGlobalEmitter();
-    emitter.emitSubagentStart(agentId, subagent_type, model || "inherited", shortDescription);
-    // Load or create agent state
-    let state = resume ? loadAgentState(resume) : null;
-    if (!state) {
-        state = {
-            id: agentId,
-            type: subagent_type,
-            model: modelId,
-            messages: [],
-            toolsUsed: [],
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-        };
-    }
-    const loopDetector = new LoopDetector();
-    // Get filtered tools for this agent type
-    const tools = await getFilteredTools(subagent_type);
-    // Build full system prompt with optional parent context
-    let fullSystemPrompt = systemPrompt;
-    if (parentContext) {
-        fullSystemPrompt += `\n\n## Parent Conversation Context\n${parentContext}`;
-    }
-    // Add CLAUDE.md if available
-    const claudeMd = loadClaudeMd();
-    if (claudeMd) {
-        fullSystemPrompt += `\n\n## Project Instructions\n${claudeMd.content}`;
-    }
-    // Add user prompt to messages
-    state.messages.push({ role: "user", content: prompt });
-    let totalIn = 0;
-    let totalOut = 0;
-    let finalText = "";
-    // Create subagent span context — inherit parent's trace context for hierarchy
-    // IMPORTANT: Don't increment global turn number — subagent is part of parent turn
-    const subagentSpanId = generateSpanId();
-    const turnCtx = {
-        source: "claude_code",
-        serviceName: "whale-cli",
-        serviceVersion: "2.1.0",
-        model: modelId,
-        agentId,
-        agentName: name || `subagent-${subagent_type}`,
-        // Inherit parent's trace to keep hierarchy intact
-        traceId: parentTraceContext?.traceId || generateTraceId(),
-        spanId: subagentSpanId,
-        parentSpanId: parentTraceContext?.spanId, // Parent's spanId becomes our parentSpanId
-        conversationId: parentTraceContext?.conversationId,
-        turnNumber: parentTraceContext?.turnNumber, // Inherit parent turn, don't increment
-        userId: parentTraceContext?.userId,
-        userEmail: parentTraceContext?.userEmail,
-        traceFlags: 1,
+  const {
+    prompt,
+    subagent_type,
+    model,
+    resume,
+    max_turns,
+    name,
+    parentContext,
+    parentTraceContext,
+    taskContext,
+    signal
+  } = options;
+  const agentId = resume || generateAgentId();
+  const cwd = process.cwd();
+  const systemPrompt = buildAgentPrompt(subagent_type, cwd);
+  const startTime = Date.now();
+
+  // Check for custom agent definition with per-agent config
+  const customDef = getAgentDefinition(subagent_type);
+
+  // Model resolution: caller override → agent definition → demotion logic → haiku
+  const effectiveModelAlias = model || customDef?.model || demoteSubagentModel(model, subagent_type);
+  const modelId = MODEL_MAP[effectiveModelAlias] || MODEL_MAP["haiku"];
+
+  // Resolve all config from DB → AGENT_DEFAULTS fallback (single source of truth)
+  const dbAgent = await loadCLIAgentConfig();
+  const resolved = dbAgent ? resolveAgentLoopConfig(dbAgent, "sse") : null;
+  const dbMaxTurns = resolved?.subagentMaxTurns ?? AGENT_DEFAULTS.subagentMaxTurns;
+  const dbMaxTokens = customDef?.max_tokens ?? resolved?.subagentMaxTokens ?? AGENT_DEFAULTS.subagentMaxTokens;
+  // 0 = no limit (agent self-regulates via end_turn, Claude Code parity)
+  // Safety: LoopDetector + cost budget + stall detection are the real guards.
+  const rawMaxTurns = max_turns ? Math.max(1, max_turns) : dbMaxTurns;
+  const effectiveMaxTurns = rawMaxTurns === 0 ? Number.MAX_SAFE_INTEGER : rawMaxTurns;
+  const maxToolResultChars = resolved?.maxToolResultChars ?? AGENT_DEFAULTS.maxToolResultChars;
+  const maxRetries = resolved?.subagentMaxRetries ?? AGENT_DEFAULTS.subagentMaxRetries;
+  const maxContinuations = resolved?.subagentMaxContinuations ?? AGENT_DEFAULTS.subagentMaxContinuations;
+
+  // Extract short description from prompt (first sentence or 60 chars)
+  const descMatch = prompt.match(/^[^.!?\n]+/);
+  const shortDescription = name || (descMatch ? descMatch[0].slice(0, 60) + (descMatch[0].length > 60 ? "…" : "") : prompt.slice(0, 60) + (prompt.length > 60 ? "…" : ""));
+
+  // Emit subagent start event
+  const emitter = getGlobalEmitter();
+  emitter.emitSubagentStart(agentId, subagent_type, model || "inherited", shortDescription);
+
+  // Load or create agent state
+  let state = resume ? loadAgentState(resume) : null;
+  if (!state) {
+    state = {
+      id: agentId,
+      type: subagent_type,
+      model: modelId,
+      messages: [],
+      toolsUsed: [],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
     };
-    try {
-        for (let turn = 0; turn < effectiveMaxTurns; turn++) {
-            // Emit progress and yield before API call to keep UI responsive
-            emitSubagentProgress(subagent_type, agentId, `turn ${turn + 1}: calling API...`, turn + 1);
-            await yieldForRender(); // Give Ink time to render the progress update
-            // Claude Code parity: thinking is DISABLED for all subagents.
-            // Subagents don't get extended thinking — all output tokens go to actual content.
-            // max_tokens = 32K matching Claude Code's hardcoded subagent default.
-            const apiStart = Date.now();
-            let response;
-            let lastError = null;
-            for (let attempt = 0; attempt < 3; attempt++) {
-                try {
-                    response = await callAgentAPI({
-                        modelId,
-                        contextProfile: "subagent",
-                        systemPrompt: fullSystemPrompt,
-                        messages: state.messages,
-                        tools,
-                        thinkingEnabled: false,
-                        maxOutputTokens: SUBAGENT_MAX_OUTPUT_TOKENS,
-                        cacheLastTool: true,
-                    });
-                    lastError = null;
-                    break;
-                }
-                catch (err) {
-                    lastError = err;
-                    if (attempt < 2 && (err.status === 429 || err.status === 500 || err.status === 529)) {
-                        await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
-                        continue;
-                    }
-                    throw err;
-                }
-            }
-            if (lastError)
-                throw lastError;
-            const apiDuration = Date.now() - apiStart;
-            // Yield after API call
-            await yieldToEventLoop();
-            totalIn += response.usage.input_tokens;
-            totalOut += response.usage.output_tokens;
-            // Log API call as child span
-            const apiCostUsd = estimateCostUsd(response.usage.input_tokens, response.usage.output_tokens, modelId);
-            logSpan({
-                action: "claude_api_request",
-                durationMs: apiDuration,
-                context: {
-                    ...turnCtx,
-                    spanId: generateSpanId(), // New span for this API call
-                    parentSpanId: turnCtx.spanId, // Parent is the subagent
-                    inputTokens: response.usage.input_tokens,
-                    outputTokens: response.usage.output_tokens,
-                    totalCost: apiCostUsd,
-                    model: modelId,
-                },
-                details: {
-                    "gen_ai.request.model": modelId,
-                    "gen_ai.usage.input_tokens": response.usage.input_tokens,
-                    "gen_ai.usage.output_tokens": response.usage.output_tokens,
-                    "gen_ai.usage.cost": apiCostUsd,
-                    agent_id: agentId,
-                    agent_type: subagent_type,
-                    turn: turn + 1,
-                    stop_reason: response.stop_reason,
-                    is_subagent_api: true,
-                },
-            });
-            // Yield to event loop to keep UI responsive
-            await yieldToEventLoop();
-            // Extract text and tool use using shared helpers
-            const textBlocks = extractTextBlocks(response.content);
-            const toolBlocks = extractToolUseBlocks(response.content);
-            if (textBlocks.length) {
-                finalText = getResponseText(response.content);
-            }
-            // No tool calls — we're done
-            if (toolBlocks.length === 0 || response.stop_reason === "end_turn") {
-                emitSubagentProgress(subagent_type, agentId, `done (${turn + 1} turn${turn > 0 ? "s" : ""})`, turn + 1);
-                break;
-            }
-            // Emit tool usage progress
-            const toolNames = toolBlocks.map(b => b.name).join(", ");
-            emitSubagentProgress(subagent_type, agentId, `using: ${toolNames}`, turn + 1);
-            // Execute tools using shared executeToolBlocks
-            const { toolResults, toolsUsed: turnToolsUsed } = await executeToolBlocks({
-                toolBlocks,
-                loopDetector,
-                callbacks: {
-                    onToolStart: (toolName, input) => {
-                        emitSubagentProgress(subagent_type, agentId, `running ${toolName}`, turn + 1, toolName);
-                        emitter.emitSubagentToolStart(agentId, toolName, input);
-                    },
-                    onToolEnd: (toolName, success, durationMs) => {
-                        emitter.emitSubagentToolEnd(agentId, toolName, success, durationMs);
-                        // Log tool call as child span of the subagent
-                        const tu = toolBlocks.find(b => b.name === toolName);
-                        logSpan({
-                            action: `tool.${toolName}`,
-                            durationMs,
-                            context: {
-                                ...turnCtx,
-                                spanId: generateSpanId(),
-                                parentSpanId: turnCtx.spanId,
-                            },
-                            error: success ? undefined : "(see tool result)",
-                            details: {
-                                tool_type: "subagent_tool",
-                                tool_input: tu?.input,
-                                agent_id: agentId,
-                                agent_type: subagent_type,
-                                is_subagent_tool: true,
-                                iteration: turn,
-                            },
-                        });
-                    },
-                },
-            });
-            // Track tool usage
-            for (const tn of turnToolsUsed) {
-                if (!state.toolsUsed.includes(tn)) {
-                    state.toolsUsed.push(tn);
-                }
-            }
-            // Append assistant response + tool results
-            state.messages.push({
-                role: "assistant",
-                content: response.content,
-            });
-            state.messages.push({
-                role: "user",
-                content: toolResults,
-            });
-            // Yield to event loop after tool execution
-            await yieldToEventLoop();
+  }
+  const loopDetector = resolved ? LoopDetector.fromResolved(resolved) : new LoopDetector();
+
+  // Get filtered tools for this agent type (deduped)
+  const tools = await getFilteredTools(subagent_type);
+  assertUniqueToolNames(tools);
+
+  // Build full system prompt with optional parent context and task dedup context
+  let fullSystemPrompt = systemPrompt;
+  if (parentContext) {
+    fullSystemPrompt += `\n\n## Parent Conversation Context\n${parentContext}`;
+  }
+  if (taskContext) {
+    fullSystemPrompt += `\n\n## Other Agents\n${taskContext}\nDo NOT duplicate research or work that other agents are handling. Focus only on your assigned task.`;
+  }
+
+  // Add CLAUDE.md if available
+  const claudeMd = loadClaudeMd();
+  if (claudeMd) {
+    fullSystemPrompt += `\n\n## Project Instructions\n${claudeMd.content}`;
+  }
+
+  // Add user prompt to messages
+  state.messages.push({
+    role: "user",
+    content: prompt
+  });
+  let totalIn = 0;
+  let totalOut = 0;
+  let totalCacheRead = 0;
+  let totalCacheCreate = 0;
+  let finalText = "";
+
+  // Create subagent span context — inherit parent's trace context for hierarchy
+  // IMPORTANT: Don't increment global turn number — subagent is part of parent turn
+  const subagentSpanId = generateSpanId();
+  const turnCtx = {
+    source: "claude_code",
+    serviceName: "whale-cli",
+    serviceVersion: PKG_VERSION,
+    model: modelId,
+    agentId,
+    agentName: name || `subagent-${subagent_type}`,
+    // Inherit parent's trace to keep hierarchy intact
+    traceId: parentTraceContext?.traceId || generateTraceId(),
+    spanId: subagentSpanId,
+    parentSpanId: parentTraceContext?.spanId,
+    // Parent's spanId becomes our parentSpanId
+    conversationId: parentTraceContext?.conversationId,
+    turnNumber: parentTraceContext?.turnNumber,
+    // Inherit parent turn, don't increment
+    userId: parentTraceContext?.userId,
+    userEmail: parentTraceContext?.userEmail,
+    traceFlags: 1
+  };
+  try {
+    for (let turn = 0; turn < effectiveMaxTurns; turn++) {
+      // Check for cancellation at start of each turn
+      if (signal?.aborted) {
+        emitSubagentProgress(subagent_type, agentId, "cancelled", turn + 1);
+        emitter.emitSubagentDone(agentId, subagent_type, false, "Cancelled", {
+          input: totalIn,
+          output: totalOut
+        }, state.toolsUsed, Date.now() - startTime);
+        return {
+          success: false,
+          output: "Cancelled",
+          agentId,
+          tokensUsed: {
+            input: totalIn,
+            output: totalOut
+          },
+          toolsUsed: state.toolsUsed
+        };
+      }
+
+      // Emit progress and yield before API call to keep UI responsive
+      emitSubagentProgress(subagent_type, agentId, `turn ${turn + 1}: calling API...`, turn + 1);
+      await yieldForRender(); // Give Ink time to render the progress update
+
+      // Adaptive thinking enabled — model decides when to think (Claude Code parity).
+      // Opus 4.6 uses adaptive thinking by default; no separate enable/disable needed.
+      const apiStart = Date.now();
+      let response;
+      let lastError = null;
+      for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+          response = await callAgentAPI({
+            modelId,
+            contextProfile: "subagent",
+            systemPrompt: fullSystemPrompt,
+            messages: state.messages,
+            tools,
+            thinkingEnabled: true,
+            maxOutputTokens: dbMaxTokens,
+            cacheLastTool: true,
+            abortSignal: signal
+          });
+          lastError = null;
+          break;
+        } catch (err) {
+          lastError = err;
+          if (attempt < maxRetries - 1 && (err.status === 429 || err.status === 500 || err.status === 529)) {
+            await new Promise(r => setTimeout(r, 1000 * Math.pow(2, attempt)));
+            continue;
+          }
+          throw err;
         }
-        // Save state for potential resume
-        state.updatedAt = new Date().toISOString();
-        saveAgentState(state);
-        // Log the subagent's final response as a chat.assistant_response span
-        // This ensures the full output is visible in the telemetry waterfall
-        const subFinalCost = estimateCostUsd(totalIn, totalOut, modelId);
-        if (finalText) {
-            logSpan({
-                action: "chat.assistant_response",
-                durationMs: Date.now() - startTime,
-                context: {
-                    ...turnCtx,
-                    spanId: generateSpanId(),
-                    parentSpanId: turnCtx.spanId,
-                    inputTokens: totalIn,
-                    outputTokens: totalOut,
-                    totalCost: subFinalCost,
-                    model: modelId,
-                },
-                details: {
-                    response: finalText,
-                    agent_id: agentId,
-                    agent_name: name || `subagent-${subagent_type}`,
-                    agent_type: subagent_type,
-                    is_subagent: true,
-                    "gen_ai.request.model": modelId,
-                    "gen_ai.usage.input_tokens": totalIn,
-                    "gen_ai.usage.output_tokens": totalOut,
-                    "gen_ai.usage.cost": subFinalCost,
-                    model: modelId,
-                    input_tokens: totalIn,
-                    output_tokens: totalOut,
-                    turn_count: Math.floor(state.messages.length / 2),
-                    tool_calls: state.toolsUsed.length,
-                    tool_names: state.toolsUsed,
-                },
-            });
+      }
+      if (lastError) throw lastError;
+      const apiDuration = Date.now() - apiStart;
+
+      // Yield after API call
+      await yieldToEventLoop();
+      totalIn += response.usage.input_tokens;
+      totalOut += response.usage.output_tokens;
+      totalCacheRead += response.usage.cache_read_tokens;
+      totalCacheCreate += response.usage.cache_creation_tokens;
+
+      // Log API call as child span — include cache tokens for accurate cost
+      const apiCostUsd = estimateCostUsd(response.usage.input_tokens, response.usage.output_tokens, modelId, 0,
+      // thinkingTokens (disabled for subagents)
+      response.usage.cache_read_tokens, response.usage.cache_creation_tokens);
+      logSpan({
+        action: "claude_api_request",
+        durationMs: apiDuration,
+        context: {
+          ...turnCtx,
+          spanId: generateSpanId(),
+          // New span for this API call
+          parentSpanId: turnCtx.spanId,
+          // Parent is the subagent
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          cacheReadTokens: response.usage.cache_read_tokens,
+          cacheCreationTokens: response.usage.cache_creation_tokens,
+          totalCost: apiCostUsd,
+          model: modelId
+        },
+        details: {
+          "gen_ai.request.model": modelId,
+          "gen_ai.usage.input_tokens": response.usage.input_tokens,
+          "gen_ai.usage.output_tokens": response.usage.output_tokens,
+          "gen_ai.usage.cache_read_tokens": response.usage.cache_read_tokens,
+          "gen_ai.usage.cache_creation_tokens": response.usage.cache_creation_tokens,
+          "gen_ai.usage.cost": apiCostUsd,
+          agent_id: agentId,
+          agent_type: subagent_type,
+          turn: turn + 1,
+          stop_reason: response.stop_reason,
+          is_subagent_api: true
+        }
+      });
+
+      // Yield to event loop to keep UI responsive
+      await yieldToEventLoop();
+
+      // Extract text and tool use using shared helpers
+      const textBlocks = extractTextBlocks(response.content);
+      const toolBlocks = extractToolUseBlocks(response.content);
+      if (textBlocks.length) {
+        finalText = getResponseText(response.content);
+      }
+
+      // Compaction handling — API paused after generating summary.
+      // Per Anthropic docs: just use the compaction block, don't preserve old messages.
+      if (response.stop_reason === "compaction") {
+        const compactionBlock = response.content.find(b => b.type === "compaction");
+        if (compactionBlock) {
+          state.compactionCount = (state.compactionCount ?? 0) + 1;
+          state.messages = [{
+            role: "assistant",
+            content: [{
+              type: "compaction",
+              content: compactionBlock.content
+            }]
+          }, {
+            role: "user",
+            content: [{
+              type: "text",
+              text: "Continue with your task."
+            }]
+          }];
+          turn--; // Don't count compaction as a turn
+          continue;
         }
-        // Log telemetry with rich metadata for trace visualization
-        const subagentTotalCost = estimateCostUsd(totalIn, totalOut, modelId);
-        logSpan({
-            action: `subagent.${subagent_type}`,
-            durationMs: Date.now() - new Date(state.createdAt).getTime(),
-            context: {
+      }
+
+      // No tool calls — check stop reason
+      if (toolBlocks.length === 0 || response.stop_reason === "end_turn") {
+        // max_tokens: response was truncated mid-generation — give the model a chance to finish
+        // Cap at 2 continuations to prevent infinite loops on very large outputs
+        if (response.stop_reason === "max_tokens" && (state.continuations ?? 0) < maxContinuations) {
+          state.continuations = (state.continuations ?? 0) + 1;
+          state.messages.push({
+            role: "assistant",
+            content: response.content
+          });
+          const contCount = state.continuations ?? 1;
+          const contText = contCount === 1 ? "[Your response was truncated due to the output token limit. If writing a large file, split into multiple smaller write_file calls (~200 lines each). Continue concisely.]" : `[Truncated again (${contCount}/${maxContinuations}). You MUST reduce output size — use multiple small write_file calls, not one large one.]`;
+          state.messages.push({
+            role: "user",
+            content: [{
+              type: "text",
+              text: contText
+            }]
+          });
+          continue;
+        }
+        emitSubagentProgress(subagent_type, agentId, `done (${turn + 1} turn${turn > 0 ? "s" : ""})`, turn + 1);
+        break;
+      }
+
+      // Emit tool usage progress
+      const toolNames = toolBlocks.map(b => b.name).join(", ");
+      emitSubagentProgress(subagent_type, agentId, `using: ${toolNames}`, turn + 1);
+
+      // Execute tools using shared executeToolBlocks
+      const {
+        toolResults,
+        toolsUsed: turnToolsUsed
+      } = await executeToolBlocks({
+        toolBlocks,
+        loopDetector,
+        signal,
+        callbacks: {
+          onToolStart: (toolName, input) => {
+            emitSubagentProgress(subagent_type, agentId, `running ${toolName}`, turn + 1, toolName);
+            emitter.emitSubagentToolStart(agentId, toolName, input);
+          },
+          onToolEnd: (toolName, success, durationMs) => {
+            emitter.emitSubagentToolEnd(agentId, toolName, success, durationMs);
+
+            // Log tool call as child span of the subagent
+            const tu = toolBlocks.find(b => b.name === toolName);
+            logSpan({
+              action: `tool.${toolName}`,
+              durationMs,
+              context: {
                 ...turnCtx,
-                inputTokens: totalIn,
-                outputTokens: totalOut,
-                totalCost: subagentTotalCost,
-            },
-            details: {
-                // Core identification
+                spanId: generateSpanId(),
+                parentSpanId: turnCtx.spanId
+              },
+              error: success ? undefined : "(see tool result)",
+              details: {
+                tool_type: "subagent_tool",
+                tool_input: tu?.input,
                 agent_id: agentId,
                 agent_type: subagent_type,
-                model: modelId,
-                // Cost for SwiftUI display
-                "gen_ai.request.model": modelId,
-                "gen_ai.usage.input_tokens": totalIn,
-                "gen_ai.usage.output_tokens": totalOut,
-                "gen_ai.usage.cost": subagentTotalCost,
-                // Execution metrics
-                turns: state.messages.length / 2,
-                tools_used: state.toolsUsed,
-                tool_count: state.toolsUsed.length,
-                // Hierarchy info for visualization
-                is_subagent: true,
-                parent_trace_id: parentTraceContext?.traceId,
-                parent_span_id: parentTraceContext?.spanId,
-                // Rich display metadata
-                display_name: `${subagent_type.charAt(0).toUpperCase() + subagent_type.slice(1)} Agent`,
-                display_icon: getAgentIcon(subagent_type),
-                display_color: getAgentColor(subagent_type),
-                // Summary for trace feed (2000 chars for meaningful preview)
-                summary: finalText.slice(0, 2000) + (finalText.length > 2000 ? "..." : ""),
-                prompt_preview: prompt.slice(0, 200) + (prompt.length > 200 ? "..." : ""),
-            },
-        });
-        // Emit subagent done event
-        emitter.emitSubagentDone(agentId, subagent_type, true, finalText || "(No output from agent)", { input: totalIn, output: totalOut }, state.toolsUsed, Date.now() - startTime);
-        return {
-            success: true,
-            output: finalText || "(No output from agent)",
-            agentId,
-            tokensUsed: { input: totalIn, output: totalOut },
-            toolsUsed: state.toolsUsed,
-        };
-    }
-    catch (err) {
-        // Emit subagent error event
-        emitter.emitSubagentDone(agentId, subagent_type, false, `Agent error: ${err.message || err}`, { input: totalIn, output: totalOut }, state.toolsUsed, Date.now() - startTime);
-        return {
-            success: false,
-            output: `Agent error: ${err.message || err}`,
-            agentId,
-            tokensUsed: { input: totalIn, output: totalOut },
-            toolsUsed: state.toolsUsed,
-        };
+                is_subagent_tool: true,
+                iteration: turn
+              }
+            });
+          }
+        }
+      });
+
+      // Track tool usage
+      for (const tn of turnToolsUsed) {
+        if (!state.toolsUsed.includes(tn)) {
+          state.toolsUsed.push(tn);
+        }
+      }
+
+      // Append assistant response + tool results
+      state.messages.push({
+        role: "assistant",
+        content: response.content
+      });
+      state.messages.push({
+        role: "user",
+        content: toolResults
+      });
+
+      // Progress nudge: when approaching turn limit without any edits, warn the agent
+      const turnsRemaining = effectiveMaxTurns - turn - 1;
+      const nudgeThreshold = Math.ceil(effectiveMaxTurns * 0.25); // Last 25% of turns
+      if (turnsRemaining === nudgeThreshold && turnsRemaining > 0) {
+        const editTools = ["write_file", "edit_file", "create_file", "notebook_edit"];
+        const hasEdited = state.toolsUsed.some(t => editTools.includes(t));
+        if (!hasEdited) {
+          state.messages.push({
+            role: "user",
+            content: [{
+              type: "text",
+              text: `⚠️ TURN LIMIT WARNING: You have ${turnsRemaining} turns remaining out of ${effectiveMaxTurns} and have NOT made any file edits yet. Stop exploring and start producing your output NOW. If you need to write or edit files, do it immediately. Prioritize delivering results over gathering more information.`
+            }]
+          });
+        }
+      }
+
+      // Pre-compact: trim large tool results and thinking blocks to prevent context bloat.
+      // Without this, context grows unbounded (4K→28K→73K tokens per turn).
+      const {
+        messages: compactedMessages
+      } = preCompact(state.messages, {
+        maxToolResultChars,
+        stripThinking: true
+      });
+      state.messages = compactedMessages;
+
+      // Yield to event loop after tool execution
+      await yieldToEventLoop();
     }
+
+    // Save state for potential resume
+    state.updatedAt = new Date().toISOString();
+    saveAgentState(state);
+
+    // Log single subagent span with all metadata for trace visualization
+    const subagentTotalCost = estimateCostUsd(totalIn, totalOut, modelId, 0, totalCacheRead, totalCacheCreate);
+    logSpan({
+      action: `subagent.${subagent_type}`,
+      durationMs: Date.now() - new Date(state.createdAt).getTime(),
+      context: {
+        ...turnCtx,
+        inputTokens: totalIn,
+        outputTokens: totalOut,
+        totalCost: subagentTotalCost
+      },
+      details: {
+        agent_id: agentId,
+        agent_type: subagent_type,
+        model: modelId,
+        // OpenTelemetry gen_ai semantic conventions
+        "gen_ai.request.model": modelId,
+        "gen_ai.usage.input_tokens": totalIn,
+        "gen_ai.usage.output_tokens": totalOut,
+        "gen_ai.usage.cache_read_tokens": totalCacheRead,
+        "gen_ai.usage.cache_creation_tokens": totalCacheCreate,
+        "gen_ai.usage.cost": subagentTotalCost,
+        // Execution metrics
+        turns: state.messages.length / 2,
+        tools_used: state.toolsUsed,
+        tool_count: state.toolsUsed.length,
+        // Hierarchy
+        is_subagent: true,
+        parent_trace_id: parentTraceContext?.traceId,
+        parent_span_id: parentTraceContext?.spanId,
+        // Display metadata
+        display_name: `${subagent_type.charAt(0).toUpperCase() + subagent_type.slice(1)} Agent`,
+        display_icon: getAgentIcon(subagent_type),
+        display_color: getAgentColor(subagent_type),
+        // Content previews
+        summary: finalText.slice(0, 2000) + (finalText.length > 2000 ? "..." : ""),
+        prompt_preview: prompt.slice(0, 200) + (prompt.length > 200 ? "..." : "")
+      }
+    });
+
+    // Emit subagent done event
+    emitter.emitSubagentDone(agentId, subagent_type, true, finalText || "(No output from agent)", {
+      input: totalIn,
+      output: totalOut
+    }, state.toolsUsed, Date.now() - startTime);
+    return {
+      success: true,
+      output: finalText || "(No output from agent)",
+      agentId,
+      tokensUsed: {
+        input: totalIn,
+        output: totalOut
+      },
+      toolsUsed: state.toolsUsed
+    };
+  } catch (err) {
+    // Emit subagent error event
+    emitter.emitSubagentDone(agentId, subagent_type, false, `Agent error: ${err.message || err}`, {
+      input: totalIn,
+      output: totalOut
+    }, state.toolsUsed, Date.now() - startTime);
+    return {
+      success: false,
+      output: `Agent error: ${err.message || err}`,
+      agentId,
+      tokensUsed: {
+        input: totalIn,
+        output: totalOut
+      },
+      toolsUsed: state.toolsUsed
+    };
+  }
 }
+
 // ============================================================================
 // BACKGROUND AGENT EXECUTION
 // ============================================================================
+
 export async function runSubagentBackground(options) {
-    const agentId = options.resume || generateAgentId();
-    const outputFile = join(tmpdir(), `whale-agent-${agentId}.output`);
-    // Write initial status
-    writeFileSync(outputFile, `Agent ${agentId} started (${options.subagent_type})\n`, "utf-8");
-    // Import background process tracker (dynamic to avoid circular deps)
-    const bgModule = await import("./background-processes.js");
-    bgModule.registerBackgroundAgent(agentId, options.subagent_type, outputFile);
-    // Start agent in detached async — don't await
-    runSubagent({ ...options, resume: undefined }).then(result => {
-        appendFileSync(outputFile, `\n---DONE---\n${JSON.stringify({ success: result.success, agentId: result.agentId, output: result.output })}\n`, "utf-8");
-        import("./background-processes.js").then(m => m.markAgentDone(agentId, result.success));
-    }).catch(err => {
-        appendFileSync(outputFile, `\n---ERROR---\n${err.message}\n`, "utf-8");
-        import("./background-processes.js").then(m => m.markAgentDone(agentId, false));
-    });
-    return { agentId, outputFile };
+  const agentId = options.resume || generateAgentId();
+  const outputFile = join(tmpdir(), `whale-agent-${agentId}.output`);
+
+  // Write initial status
+  writeFileSync(outputFile, `Agent ${agentId} started (${options.subagent_type})\n`, "utf-8");
+
+  // Import background process tracker (dynamic to avoid circular deps)
+  const bgModule = await import("./background-processes.js");
+  bgModule.registerBackgroundAgent(agentId, options.subagent_type, outputFile);
+
+  // Start agent in detached async — don't await
+  runSubagent({
+    ...options,
+    resume: undefined
+  }).then(result => {
+    appendFileSync(outputFile, `\n---DONE---\n${JSON.stringify({
+      success: result.success,
+      agentId: result.agentId,
+      output: result.output
+    })}\n`, "utf-8");
+    import("./background-processes.js").then(m => m.markAgentDone(agentId, result.success));
+  }).catch(err => {
+    appendFileSync(outputFile, `\n---ERROR---\n${err.message}\n`, "utf-8");
+    import("./background-processes.js").then(m => m.markAgentDone(agentId, false));
+  });
+  return {
+    agentId,
+    outputFile
+  };
 }
+
 // ============================================================================
 // TOOL DEFINITION — for integration with main agent loop
 // ============================================================================
+
 // Following Claude Code pattern: discrete, focused tasks with clear completion criteria
 export const TASK_TOOL_DEFINITION = {
-    name: "task",
-    description: `Launch a subagent in isolated context. Subagents have full tool access and batch multiple tool calls per turn (glob + grep + read_file in parallel). Launch multiple task calls in one response for parallel execution.
+  name: "task",
+  description: `Launch a subagent in isolated context. Subagents have full tool access and batch multiple tool calls per turn (glob + grep + read_file in parallel). Launch multiple task calls in one response for parallel execution.
 
 Use for any work requiring 3+ tool calls or touching multiple parts of the codebase.
 
@@ -621,28 +796,29 @@ Agent types:
 - research: Look up specific info (2-4 turns)
 
 Each agent completes autonomously and returns results.`,
-    input_schema: {
-        type: "object",
-        properties: {
-            prompt: {
-                type: "string",
-                description: "Specific task with clear completion criteria. Include: what to find/do, where to look, what to return.",
-            },
-            subagent_type: {
-                type: "string",
-                enum: ["explore", "plan", "general-purpose", "research"],
-                description: "Agent type: explore=find, plan=design, general-purpose=do, research=lookup.",
-            },
-            model: {
-                type: "string",
-                enum: ["sonnet", "haiku"],
-                description: "Optional model. haiku (default) for fast tasks, sonnet for complex reasoning.",
-            },
-            resume: {
-                type: "string",
-                description: "Agent ID to resume (rarely needed).",
-            },
-        },
-        required: ["prompt", "subagent_type"],
+  input_schema: {
+    type: "object",
+    properties: {
+      prompt: {
+        type: "string",
+        description: "Specific task with clear completion criteria. Include: what to find/do, where to look, what to return."
+      },
+      subagent_type: {
+        type: "string",
+        enum: ["explore", "plan", "general-purpose", "research"],
+        description: "Agent type: explore=find, plan=design, general-purpose=do, research=lookup."
+      },
+      model: {
+        type: "string",
+        enum: ["sonnet", "haiku"],
+        description: "Optional model. haiku (default) for fast tasks, sonnet for complex reasoning."
+      },
+      resume: {
+        type: "string",
+        description: "Agent ID to resume (rarely needed)."
+      }
     },
+    required: ["prompt", "subagent_type"]
+  }
 };
+//# sourceMappingURL=subagent.js.map