whale-code 6.5.4 → 6.5.6

package/dist/cli/services/teammate.js

@@ -7,37 +7,65 @@
  * - Can message other teammates directly
  * - Full tool access (not restricted like subagents)
  */
-import { Worker, parentPort, workerData, isMainThread } from "worker_threads";
+
+import { fork } from "child_process";
 import { fileURLToPath } from "url";
-import { loadTeam, claimTask, completeTask, failTask, getAvailableTasks, sendMessage, getUnreadMessages, markMessagesRead, updateTeammate, } from "./team-state.js";
-import { LoopDetector, estimateCostUsd } from "../../shared/agent-core.js";
+import { loadTeam, claimTask, completeTask, failTask, getAvailableTasks, sendMessage, getUnreadMessages, markMessagesRead, updateTeammate } from "./team-state.js";
+import { LoopDetector, estimateCostUsd, 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 { LOCAL_TOOL_DEFINITIONS, } from "./local-tools.js";
-import { loadServerToolDefinitions, } from "./server-tools.js";
+import { LOCAL_TOOL_DEFINITIONS } from "./local-tools.js";
+import { loadServerToolDefinitions } from "./server-tools.js";
 import { getValidToken } from "./auth-service.js";
-import { logSpan, generateSpanId, generateTraceId, getConversationId, initializeTelemetryClient } from "./telemetry.js";
-import { callAgentAPI, executeToolBlocks, extractTextBlocks, extractToolUseBlocks, } from "./agent-worker-base.js";
+import { logSpan, generateSpanId, generateTraceId, getConversationId, initializeTelemetryClient, flushCliSpans, PKG_VERSION } from "./telemetry.js";
+import { callAgentAPI, executeToolBlocks, extractTextBlocks, extractToolUseBlocks, deduplicateTools, assertUniqueToolNames } from "./agent-worker-base.js";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
 // ============================================================================
 // CONSTANTS
 // ============================================================================
-const MAX_TURNS_PER_TASK = 12; // More turns than subagent since tasks are larger
-const MAX_OUTPUT_TOKENS = 16384;
-const MAX_TEAMMATE_TURNS = 50; // Outer loop safety: max task claim cycles
-const MAX_TEAMMATE_DURATION_MS = 10 * 60 * 1000; // 10 minute hard timeout
-const API_TIMEOUT_MS = 90_000; // 90s timeout on proxy/API fetch calls
-const TOOL_TIMEOUT_MS = 60_000; // 60s timeout on individual tool execution
+
+// Teammate constants — ALL from DB via AGENT_DEFAULTS, nothing hardcoded
+let TEAMMATE_MAX_TURNS_PER_TASK = AGENT_DEFAULTS.subagentMaxTurns; // DB overridable
+let TEAMMATE_MAX_OUTPUT_TOKENS = AGENT_DEFAULTS.subagentMaxTokens; // DB overridable
+let TEAMMATE_MAX_TOTAL_TURNS = AGENT_DEFAULTS.teammateMaxTotalTurns;
+let TEAMMATE_MAX_DURATION_MS = AGENT_DEFAULTS.maxDurationMs;
+let API_TIMEOUT_MS = AGENT_DEFAULTS.apiTimeoutMs; // DB overridable
+let TOOL_TIMEOUT_MS = AGENT_DEFAULTS.toolTimeoutMs; // DB overridable
+
+// Cached resolved config for LoopDetector creation
+let resolvedTeammateConfig = null;
+
+// Lazy init from DB — called once per teammate spawn. ALL knobs from DB, nothing hardcoded.
+async function resolveTeammateConfig() {
+  const dbAgent = await loadCLIAgentConfig();
+  if (!dbAgent?.context_config) return;
+  const cc = dbAgent.context_config;
+  TEAMMATE_MAX_TURNS_PER_TASK = cc.subagent_max_turns ?? TEAMMATE_MAX_TURNS_PER_TASK;
+  TEAMMATE_MAX_OUTPUT_TOKENS = cc.subagent_max_tokens ?? TEAMMATE_MAX_OUTPUT_TOKENS;
+  TEAMMATE_MAX_DURATION_MS = cc.max_duration_ms ?? TEAMMATE_MAX_DURATION_MS;
+  TEAMMATE_MAX_TOTAL_TURNS = cc.teammate_max_total_turns ?? TEAMMATE_MAX_TOTAL_TURNS;
+  API_TIMEOUT_MS = cc.api_timeout_ms ?? API_TIMEOUT_MS;
+  TOOL_TIMEOUT_MS = cc.tool_timeout_ms ?? TOOL_TIMEOUT_MS;
+  // Cache resolved config for LoopDetector
+  resolvedTeammateConfig = resolveAgentLoopConfig(dbAgent, "sse");
+}
+
 // ============================================================================
 // TEAMMATE SYSTEM PROMPT
 // ============================================================================
+
 function buildTeammatePrompt(teammateName, team, currentTask, cwd) {
-    const taskList = team.tasks.map(t => {
-        const status = t.status === "in_progress" && t.assignedTo
-            ? `in_progress (${team.teammates.find(tm => tm.id === t.assignedTo)?.name || "unknown"})`
-            : t.status;
-        return `- [${status}] ${t.description}${t.id === currentTask?.id ? " (YOUR TASK)" : ""}`;
-    }).join("\n");
-    const teammates = team.teammates.map(t => `- ${t.name} (${t.id}): ${t.status}${t.currentTask ? ` - working on task` : ""}`).join("\n");
-    return `You are ${teammateName}, a teammate in the "${team.name}" team.
+  const taskList = team.tasks.map(t => {
+    const status = t.status === "in_progress" && t.assignedTo ? `in_progress (${team.teammates.find(tm => tm.id === t.assignedTo)?.name || "unknown"})` : t.status;
+    return `- [${status}] ${t.description}${t.id === currentTask?.id ? " (YOUR TASK)" : ""}`;
+  }).join("\n");
+  const teammates = team.teammates.map(t => `- ${t.name} (${t.id}): ${t.status}${t.currentTask ? ` - working on task` : ""}`).join("\n");
+  return `You are ${teammateName}, a teammate in the "${team.name}" team.
 
 ## Working Directory
 ${cwd}
@@ -71,13 +99,18 @@ You can delegate sub-tasks to specialized subagents using the 'task' tool:
 - Use model="haiku" for simple lookups (cheapest/fastest)
 - This lets you work on multiple things in parallel while staying focused on your main task
 
+## CRITICAL: Task Completion Protocol
+You MUST call team_complete_task when your work is done. This is NOT optional.
+- Your task is NOT considered complete until you call team_complete_task
+- Include a structured summary: what files were changed, what was done, any issues found
+- If you cannot complete the task, still call team_complete_task with what you accomplished and what remains
+
 ## Guidelines
-1. Focus on YOUR assigned task - don't work on others' tasks
-2. Communicate blockers or discoveries that affect other tasks
-3. When done, use team_complete_task with a clear summary
-4. Check messages periodically for updates from teammates
-5. Avoid modifying files assigned to other teammates' tasks
-6. Delegate research or exploration to subagents when your task requires checking multiple areas
+1. Focus on YOUR assigned task — don't work on others' tasks
+2. Communicate blockers or discoveries that affect other tasks via team_message
+3. Check messages periodically for updates from teammates
+4. Avoid modifying files assigned to other teammates' tasks
+5. Delegate research or exploration to subagents when your task requires checking multiple areas
 
 ## Self-Monitoring
 If a tool fails, use audit_trail (action="errors") to check patterns before retrying.
@@ -87,603 +120,872 @@ If a tool fails repeatedly, try a different approach instead of retrying the sam
 ## Output
 Be concise. Report progress and results clearly. Use tools to do the work.`;
 }
+
 // ============================================================================
 // TEAM-SPECIFIC TOOLS
 // ============================================================================
-const TEAM_TOOLS = [
-    {
-        name: "team_message",
-        description: "Send a message to a specific teammate or the team lead",
-        input_schema: {
-            type: "object",
-            properties: {
-                to: {
-                    type: "string",
-                    description: "Teammate ID or 'lead' for team lead",
-                },
-                message: {
-                    type: "string",
-                    description: "Message content",
-                },
-            },
-            required: ["to", "message"],
-        },
-    },
-    {
-        name: "team_broadcast",
-        description: "Send a message to all teammates",
-        input_schema: {
-            type: "object",
-            properties: {
-                message: {
-                    type: "string",
-                    description: "Message to broadcast",
-                },
-            },
-            required: ["message"],
-        },
+
+const TEAM_TOOLS = [{
+  name: "team_message",
+  description: "Send a message to a specific teammate or the team lead",
+  input_schema: {
+    type: "object",
+    properties: {
+      to: {
+        type: "string",
+        description: "Teammate ID or 'lead' for team lead"
+      },
+      message: {
+        type: "string",
+        description: "Message content"
+      }
     },
-    {
-        name: "team_claim_task",
-        description: "Claim an available task to work on",
-        input_schema: {
-            type: "object",
-            properties: {
-                task_id: {
-                    type: "string",
-                    description: "ID of the task to claim",
-                },
-            },
-            required: ["task_id"],
-        },
+    required: ["to", "message"]
+  }
+}, {
+  name: "team_broadcast",
+  description: "Send a message to all teammates",
+  input_schema: {
+    type: "object",
+    properties: {
+      message: {
+        type: "string",
+        description: "Message to broadcast"
+      }
     },
-    {
-        name: "team_complete_task",
-        description: "Mark your current task as complete",
-        input_schema: {
-            type: "object",
-            properties: {
-                result: {
-                    type: "string",
-                    description: "Summary of what was accomplished",
-                },
-            },
-            required: ["result"],
-        },
+    required: ["message"]
+  }
+}, {
+  name: "team_claim_task",
+  description: "Claim an available task to work on",
+  input_schema: {
+    type: "object",
+    properties: {
+      task_id: {
+        type: "string",
+        description: "ID of the task to claim"
+      }
     },
-    {
-        name: "team_check_messages",
-        description: "Check for unread messages from teammates",
-        input_schema: {
-            type: "object",
-            properties: {},
-        },
+    required: ["task_id"]
+  }
+}, {
+  name: "team_complete_task",
+  description: "REQUIRED: Mark your current task as complete. You MUST call this tool when done — your task is not considered complete without it. Include a summary of files changed and work done.",
+  input_schema: {
+    type: "object",
+    properties: {
+      result: {
+        type: "string",
+        description: "Summary of what was accomplished"
+      }
     },
-];
+    required: ["result"]
+  }
+}, {
+  name: "team_check_messages",
+  description: "Check for unread messages from teammates",
+  input_schema: {
+    type: "object",
+    properties: {}
+  }
+}];
+
 // ============================================================================
 // TOOL EXECUTION
 // ============================================================================
+
 async function executeTeamTool(toolName, input, teamId, teammateId, currentTaskId) {
-    switch (toolName) {
-        case "team_message": {
-            const to = input.to;
-            const message = input.message;
-            const result = await sendMessage(teamId, teammateId, to, message);
-            return result
-                ? { success: true, output: `Message sent to ${to}` }
-                : { success: false, output: "Failed to send message" };
-        }
-        case "team_broadcast": {
-            const message = input.message;
-            const result = await sendMessage(teamId, teammateId, "all", message);
-            return result
-                ? { success: true, output: "Message broadcast to all teammates" }
-                : { success: false, output: "Failed to broadcast message" };
-        }
-        case "team_claim_task": {
-            const taskId = input.task_id;
-            const task = await claimTask(teamId, taskId, teammateId);
-            return task
-                ? { success: true, output: `Claimed task: ${task.description}` }
-                : { success: false, output: "Failed to claim task (may be unavailable or have unmet dependencies)" };
-        }
-        case "team_complete_task": {
-            if (!currentTaskId) {
-                return { success: false, output: "No task currently assigned" };
-            }
-            const result = input.result;
-            const success = await completeTask(teamId, currentTaskId, result);
-            return success
-                ? { success: true, output: `Task completed: ${result}` }
-                : { success: false, output: "Failed to complete task" };
+  switch (toolName) {
+    case "team_message":
+      {
+        const to = input.to;
+        const message = input.message;
+        const result = await sendMessage(teamId, teammateId, to, message);
+        return result ? {
+          success: true,
+          output: `Message sent to ${to}`
+        } : {
+          success: false,
+          output: "Failed to send message"
+        };
+      }
+    case "team_broadcast":
+      {
+        const message = input.message;
+        const result = await sendMessage(teamId, teammateId, "all", message);
+        return result ? {
+          success: true,
+          output: "Message broadcast to all teammates"
+        } : {
+          success: false,
+          output: "Failed to broadcast message"
+        };
+      }
+    case "team_claim_task":
+      {
+        const taskId = input.task_id;
+        const task = await claimTask(teamId, taskId, teammateId);
+        return task ? {
+          success: true,
+          output: `Claimed task: ${task.description}`
+        } : {
+          success: false,
+          output: "Failed to claim task (may be unavailable or have unmet dependencies)"
+        };
+      }
+    case "team_complete_task":
+      {
+        if (!currentTaskId) {
+          return {
+            success: false,
+            output: "No task currently assigned"
+          };
         }
-        case "team_check_messages": {
-            const messages = await getUnreadMessages(teamId, teammateId);
-            if (messages.length === 0) {
-                return { success: true, output: "No unread messages" };
-            }
-            const msgList = messages.map(m => `From ${m.from}: ${m.content}`).join("\n");
-            await markMessagesRead(teamId, messages.map(m => m.id));
-            return { success: true, output: `${messages.length} messages:\n${msgList}` };
+        const result = input.result;
+        const success = await completeTask(teamId, currentTaskId, result);
+        return success ? {
+          success: true,
+          output: `Task completed: ${result}`
+        } : {
+          success: false,
+          output: "Failed to complete task"
+        };
+      }
+    case "team_check_messages":
+      {
+        const messages = await getUnreadMessages(teamId, teammateId);
+        if (messages.length === 0) {
+          return {
+            success: true,
+            output: "No unread messages"
+          };
         }
-        default:
-            return { success: false, output: `Unknown team tool: ${toolName}` };
-    }
+        const msgList = messages.map(m => `From ${m.from}: ${m.content}`).join("\n");
+        await markMessagesRead(teamId, messages.map(m => m.id));
+        return {
+          success: true,
+          output: `${messages.length} messages:\n${msgList}`
+        };
+      }
+    default:
+      return {
+        success: false,
+        output: `Unknown team tool: ${toolName}`
+      };
+  }
 }
+
 // ============================================================================
 // API CLIENT — uses shared callAgentAPI from agent-worker-base
 // ============================================================================
-async function callAPI(modelId, systemPrompt, messages, tools, thinkingEnabled = false) {
-    return callAgentAPI({
-        modelId,
-        contextProfile: "teammate",
-        systemPrompt,
-        messages,
-        tools,
-        thinkingEnabled,
-        maxOutputTokens: MAX_OUTPUT_TOKENS,
-        timeoutMs: API_TIMEOUT_MS,
-    });
+
+async function callAPI(modelId, systemPrompt, messages, tools, thinkingEnabled = false, onHeartbeat) {
+  return callAgentAPI({
+    modelId,
+    contextProfile: "teammate",
+    systemPrompt,
+    messages,
+    tools,
+    thinkingEnabled,
+    maxOutputTokens: TEAMMATE_MAX_OUTPUT_TOKENS,
+    timeoutMs: API_TIMEOUT_MS,
+    onHeartbeat
+  });
 }
+
 // ============================================================================
 // TEAMMATE WORKER LOOP
 // ============================================================================
+
 async function runTeammateLoop(data) {
-    const { teamId, teammateId, teammateName, model, cwd, parentConversationId, teamName, authToken } = data;
-    const modelId = MODEL_MAP[model] || MODEL_MAP.opus; // Inherit parent default
-    const startTime = Date.now();
-    // Initialize telemetry client with auth token if provided
-    if (authToken) {
-        initializeTelemetryClient(authToken);
+  const {
+    teamId,
+    teammateId,
+    teammateName,
+    model,
+    cwd,
+    parentConversationId,
+    teamName,
+    authToken,
+    preloadedConfig,
+    preloadedServerTools
+  } = data;
+  const modelId = MODEL_MAP[model] || MODEL_MAP.opus; // Inherit parent default
+  const startTime = Date.now();
+
+  // Initialize telemetry client with auth token if provided (do first for early spans)
+  if (authToken) {
+    initializeTelemetryClient(authToken);
+  }
+
+  // Use pre-loaded config from parent if available (avoids redundant DB call per child).
+  // Falls back to direct DB load if parent didn't pre-load.
+  if (preloadedConfig?.context_config) {
+    const cc = preloadedConfig.context_config;
+    TEAMMATE_MAX_TURNS_PER_TASK = cc.subagent_max_turns ?? TEAMMATE_MAX_TURNS_PER_TASK;
+    TEAMMATE_MAX_OUTPUT_TOKENS = cc.subagent_max_tokens ?? TEAMMATE_MAX_OUTPUT_TOKENS;
+    TEAMMATE_MAX_DURATION_MS = cc.max_duration_ms ?? TEAMMATE_MAX_DURATION_MS;
+    TEAMMATE_MAX_TOTAL_TURNS = cc.teammate_max_total_turns ?? TEAMMATE_MAX_TOTAL_TURNS;
+    API_TIMEOUT_MS = cc.api_timeout_ms ?? API_TIMEOUT_MS;
+    TOOL_TIMEOUT_MS = cc.tool_timeout_ms ?? TOOL_TIMEOUT_MS;
+    resolvedTeammateConfig = resolveAgentLoopConfig(preloadedConfig, "sse");
+  } else {
+    await resolveTeammateConfig();
+  }
+
+  // Each teammate gets its own conversation_id (separate trace)
+  // but links to parent via parent_conversation_id
+  const teammateConversationId = getConversationId(); // Worker's own ID
+
+  // Create trace context for this teammate
+  const teammateTraceId = generateTraceId();
+  const teammateSpanId = generateSpanId();
+
+  // Log teammate start - links to parent for tree hierarchy
+  logSpan({
+    action: "team.teammate_start",
+    durationMs: 0,
+    context: {
+      traceId: teammateTraceId,
+      spanId: teammateSpanId,
+      conversationId: teammateConversationId,
+      source: "claude_code",
+      serviceName: "whale-cli",
+      serviceVersion: PKG_VERSION,
+      model: modelId
+    },
+    details: {
+      is_team: true,
+      is_teammate: true,
+      team_id: teamId,
+      teammate_id: teammateId,
+      teammate_name: teammateName,
+      team_name: teamName,
+      parent_conversation_id: parentConversationId,
+      // Link to parent trace
+      model: model,
+      display_name: teammateName,
+      display_icon: "person.fill",
+      display_color: "#3B82F6"
     }
-    // Each teammate gets its own conversation_id (separate trace)
-    // but links to parent via parent_conversation_id
-    const teammateConversationId = getConversationId(); // Worker's own ID
-    // Create trace context for this teammate
-    const teammateTraceId = generateTraceId();
-    const teammateSpanId = generateSpanId();
-    // Log teammate start - links to parent for tree hierarchy
+  });
+  const report = msg => {
+    if (process.send) {
+      process.send(msg);
+    }
+  };
+
+  // Report early — let parent know we're alive before async init
+  report({
+    type: "progress",
+    teammateId,
+    content: `${teammateName} initializing...`
+  });
+
+  // Get all tools (local + server + team)
+  const localTools = LOCAL_TOOL_DEFINITIONS.map(t => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.input_schema
+  }));
+
+  // Use pre-loaded server tools from parent if available (avoids redundant API call per child)
+  let serverTools = preloadedServerTools || [];
+  if (!preloadedServerTools) {
+    try {
+      serverTools = await loadServerToolDefinitions();
+    } catch {/* server tools unavailable — continue with local tools only */}
+  }
+
+  // Deduplicate: local tools take priority, then server tools, then team tools
+  const allTools = deduplicateTools([...localTools, ...serverTools, ...TEAM_TOOLS]);
+  assertUniqueToolNames(allTools);
+  const loopDetector = resolvedTeammateConfig ? LoopDetector.fromResolved(resolvedTeammateConfig) : new LoopDetector();
+  let totalIn = 0;
+  let totalOut = 0;
+  let currentTaskId = null;
+  let currentTaskModelId = modelId; // Per-task model (defaults to team model)
+  let currentTaskThinking = false; // Per-task thinking toggle
+  let messages = [];
+  let tasksCompleted = 0;
+  report({
+    type: "progress",
+    teammateId,
+    content: `${teammateName} ready (${allTools.length} tools)`
+  });
+
+  // Helper to log teammate completion
+  const logTeammateComplete = reason => {
+    const teammateCost = estimateCostUsd(totalIn, totalOut, modelId);
     logSpan({
-        action: "team.teammate_start",
-        durationMs: 0,
-        context: {
+      action: "team.teammate_done",
+      durationMs: Date.now() - startTime,
+      context: {
+        traceId: teammateTraceId,
+        spanId: generateSpanId(),
+        parentSpanId: teammateSpanId,
+        conversationId: teammateConversationId,
+        source: "claude_code",
+        serviceName: "whale-cli",
+        serviceVersion: PKG_VERSION,
+        model: modelId,
+        inputTokens: totalIn,
+        outputTokens: totalOut,
+        totalCost: teammateCost
+      },
+      details: {
+        is_team: true,
+        is_teammate: true,
+        team_id: teamId,
+        teammate_id: teammateId,
+        teammate_name: teammateName,
+        team_name: teamName,
+        parent_conversation_id: parentConversationId,
+        tasks_completed: tasksCompleted,
+        completion_reason: reason,
+        "gen_ai.request.model": modelId,
+        "gen_ai.usage.input_tokens": totalIn,
+        "gen_ai.usage.output_tokens": totalOut,
+        "gen_ai.usage.cost": teammateCost,
+        display_name: `${teammateName} done`,
+        display_icon: "checkmark.circle.fill",
+        display_color: "#10B981"
+      }
+    });
+  };
+
+  // Main work loop - keep working until no more tasks
+  let outerTurn = 0;
+  while (true) {
+    // Safety: max turns guard (0 = no limit, Claude Code parity)
+    if (TEAMMATE_MAX_TOTAL_TURNS > 0 && ++outerTurn > TEAMMATE_MAX_TOTAL_TURNS) {
+      logTeammateComplete("max_turns_reached");
+      report({
+        type: "done",
+        teammateId,
+        content: `${teammateName} reached max turns (${TEAMMATE_MAX_TOTAL_TURNS})`,
+        tokensUsed: {
+          input: totalIn,
+          output: totalOut
+        }
+      });
+      break;
+    }
+    // Safety: elapsed time guard
+    if (Date.now() - startTime > TEAMMATE_MAX_DURATION_MS) {
+      logTeammateComplete("timeout");
+      report({
+        type: "done",
+        teammateId,
+        content: `${teammateName} timed out after ${Math.round(TEAMMATE_MAX_DURATION_MS / 60_000)}min`,
+        tokensUsed: {
+          input: totalIn,
+          output: totalOut
+        }
+      });
+      break;
+    }
+    const team = loadTeam(teamId);
+    if (!team || team.status !== "active") {
+      logTeammateComplete("team_inactive");
+      report({
+        type: "done",
+        teammateId,
+        content: "Team completed or inactive",
+        tokensUsed: {
+          input: totalIn,
+          output: totalOut
+        }
+      });
+      break;
+    }
+
+    // Find current task or claim a new one
+    const currentTask = currentTaskId ? team.tasks.find(t => t.id === currentTaskId) : null;
+
+    // If no current task, try to claim one
+    if (!currentTask || currentTask.status === "completed") {
+      const available = getAvailableTasks(team);
+      if (available.length === 0) {
+        // No tasks available, check if all done or waiting
+        const inProgress = team.tasks.filter(t => t.status === "in_progress").length;
+        if (inProgress === 0) {
+          logTeammateComplete("all_tasks_done");
+          report({
+            type: "done",
+            teammateId,
+            content: "All tasks completed",
+            tokensUsed: {
+              input: totalIn,
+              output: totalOut
+            }
+          });
+          break;
+        }
+        // Wait and retry
+        await new Promise(r => setTimeout(r, 2000));
+        continue;
+      }
+
+      // Claim first available task
+      const claimed = await claimTask(teamId, available[0].id, teammateId);
+      if (!claimed) {
+        await new Promise(r => setTimeout(r, 1000));
+        continue;
+      }
+      currentTaskId = claimed.id;
+
+      // Resolve per-task model: task-level → team default
+      const taskModel = claimed.model || model;
+      currentTaskModelId = MODEL_MAP[taskModel] || MODEL_MAP[model] || MODEL_MAP.opus;
+
+      // Enable thinking for teammates — with 32K output tokens (matching Claude Code),
+      // adaptive thinking has room to reason without starving code output.
+      currentTaskThinking = true;
+      await updateTeammate(teamId, teammateId, {
+        status: "working",
+        currentTask: currentTaskId
+      });
+      report({
+        type: "task_started",
+        teammateId,
+        taskId: currentTaskId,
+        content: claimed.description
+      });
+
+      // Start fresh conversation for new task
+      messages = [{
+        role: "user",
+        content: `Your task: ${claimed.description}\n\nBegin working on this task. When finished, you MUST call team_complete_task with a summary of changes made. Do not stop without calling team_complete_task.`
+      }];
+    }
+
+    // Build system prompt with current state
+    const freshTeam = loadTeam(teamId);
+    const freshTask = freshTeam.tasks.find(t => t.id === currentTaskId) || null;
+    const systemPrompt = buildTeammatePrompt(teammateName, freshTeam, freshTask, cwd);
+
+    // Agent loop for current task
+    let apiError = null;
+    let lastTurn = 0;
+    // 0 = no limit (agent self-regulates via end_turn, Claude Code parity)
+    const taskTurnLimit = TEAMMATE_MAX_TURNS_PER_TASK === 0 ? Number.MAX_SAFE_INTEGER : TEAMMATE_MAX_TURNS_PER_TASK;
+    for (let turn = 0; turn < taskTurnLimit; turn++) {
+      lastTurn = turn;
+      const apiStart = Date.now();
+      let response;
+      try {
+        response = await callAPI(currentTaskModelId, systemPrompt, messages, allTools, currentTaskThinking, () => {
+          // Heartbeat during long API calls (thinking/streaming) — keeps parent stall detector alive.
+          // Without this, a 90s API call = 90s silence → parent kills worker at WORKER_STALL_MS.
+          report({
+            type: "progress",
+            teammateId,
+            content: "streaming..."
+          });
+        });
+      } catch (err) {
+        apiError = err.message || String(err);
+        report({
+          type: "progress",
+          teammateId,
+          content: `API error: ${apiError.slice(0, 80)}`
+        });
+        logSpan({
+          action: "claude_api_request",
+          durationMs: Date.now() - apiStart,
+          severity: "error",
+          error: apiError || undefined,
+          context: {
             traceId: teammateTraceId,
-            spanId: teammateSpanId,
+            spanId: generateSpanId(),
+            parentSpanId: teammateSpanId,
             conversationId: teammateConversationId,
             source: "claude_code",
             serviceName: "whale-cli",
-            serviceVersion: "2.1.0",
-            model: modelId,
-        },
-        details: {
+            serviceVersion: PKG_VERSION,
+            model: currentTaskModelId
+          },
+          details: {
             is_team: true,
             is_teammate: true,
             team_id: teamId,
             teammate_id: teammateId,
             teammate_name: teammateName,
-            team_name: teamName,
-            parent_conversation_id: parentConversationId, // Link to parent trace
-            model: model,
-            display_name: teammateName,
-            display_icon: "person.fill",
-            display_color: "#3B82F6",
+            parent_conversation_id: parentConversationId,
+            turn_number: turn + 1,
+            task_id: currentTaskId
+          }
+        });
+        break; // Exit inner loop — force-complete handler below will deal with the task
+      }
+      const apiDuration = Date.now() - apiStart;
+      totalIn += response.usage.input_tokens;
+      totalOut += response.usage.output_tokens;
+
+      // Log Claude API request telemetry — include cache tokens for accurate cost
+      const turnCostUsd = estimateCostUsd(response.usage.input_tokens, response.usage.output_tokens, currentTaskModelId, 0,
+      // thinkingTokens (disabled for teammates)
+      response.usage.cache_read_tokens, response.usage.cache_creation_tokens);
+      logSpan({
+        action: "claude_api_request",
+        durationMs: apiDuration,
+        context: {
+          traceId: teammateTraceId,
+          spanId: generateSpanId(),
+          parentSpanId: teammateSpanId,
+          conversationId: teammateConversationId,
+          source: "claude_code",
+          serviceName: "whale-cli",
+          serviceVersion: PKG_VERSION,
+          model: currentTaskModelId,
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          cacheReadTokens: response.usage.cache_read_tokens,
+          cacheCreationTokens: response.usage.cache_creation_tokens,
+          totalCost: turnCostUsd
         },
-    });
-    const report = (msg) => {
-        if (parentPort) {
-            parentPort.postMessage(msg);
+        details: {
+          is_team: true,
+          is_teammate: true,
+          team_id: teamId,
+          teammate_id: teammateId,
+          teammate_name: teammateName,
+          parent_conversation_id: parentConversationId,
+          turn_number: turn + 1,
+          task_id: currentTaskId,
+          stop_reason: response.stop_reason,
+          "gen_ai.request.model": currentTaskModelId,
+          "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": turnCostUsd
         }
-    };
-    // Report early — let parent know we're alive before async init
-    report({ type: "progress", teammateId, content: `${teammateName} initializing...` });
-    // Get all tools (local + server + team)
-    const localTools = LOCAL_TOOL_DEFINITIONS.map(t => ({
-        name: t.name,
-        description: t.description,
-        input_schema: t.input_schema,
-    }));
-    let serverTools = [];
-    try {
-        serverTools = await loadServerToolDefinitions();
-    }
-    catch { /* server tools unavailable — continue with local tools only */ }
-    // 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));
-    const allTools = [...localTools, ...uniqueServerTools, ...TEAM_TOOLS];
-    const loopDetector = new LoopDetector();
-    let totalIn = 0;
-    let totalOut = 0;
-    let currentTaskId = null;
-    let currentTaskModelId = modelId; // Per-task model (defaults to team model)
-    let currentTaskThinking = false; // Per-task thinking toggle
-    let messages = [];
-    let tasksCompleted = 0;
-    report({ type: "progress", teammateId, content: `${teammateName} ready (${allTools.length} tools)` });
-    // Helper to log teammate completion
-    const logTeammateComplete = (reason) => {
-        const teammateCost = estimateCostUsd(totalIn, totalOut, modelId);
-        logSpan({
-            action: "team.teammate_done",
-            durationMs: Date.now() - startTime,
-            context: {
+      });
+      const textBlocks = extractTextBlocks(response.content);
+      const toolBlocks = extractToolUseBlocks(response.content);
+
+      // Report progress
+      if (textBlocks.length) {
+        report({
+          type: "progress",
+          teammateId,
+          taskId: currentTaskId || undefined,
+          content: textBlocks[0].text.slice(0, 200)
+        });
+      }
+
+      // Compaction handling — API paused after generating context summary.
+      // Replace entire message history with the compaction block (per Anthropic docs).
+      if (response.stop_reason === "compaction") {
+        const compactionBlock = response.content.find(b => b.type === "compaction");
+        if (compactionBlock) {
+          report({
+            type: "progress",
+            teammateId,
+            taskId: currentTaskId || undefined,
+            content: "context compacted"
+          });
+          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;
+        }
+      }
+
+      // No tools = done with this turn
+      if (toolBlocks.length === 0) break;
+
+      // Execute tools using shared executeToolBlocks with team-specific custom executor
+      let taskCompleted = false;
+      const {
+        toolResults
+      } = await executeToolBlocks({
+        toolBlocks,
+        loopDetector,
+        toolTimeoutMs: TOOL_TIMEOUT_MS,
+        customExecutor: async (toolName, input) => {
+          // Only handle team tools; return null to fall through to standard routing
+          if (!TEAM_TOOLS.some(t => t.name === toolName)) return null;
+          const result = await executeTeamTool(toolName, input, teamId, teammateId, currentTaskId);
+
+          // Check if task was completed
+          if (toolName === "team_complete_task" && result.success) {
+            taskCompleted = true;
+            tasksCompleted++;
+            report({
+              type: "task_completed",
+              teammateId,
+              taskId: currentTaskId || undefined,
+              content: result.output
+            });
+
+            // Log task completion to telemetry
+            logSpan({
+              action: "team.task_complete",
+              durationMs: 0,
+              context: {
                 traceId: teammateTraceId,
                 spanId: generateSpanId(),
                 parentSpanId: teammateSpanId,
                 conversationId: teammateConversationId,
                 source: "claude_code",
                 serviceName: "whale-cli",
-                serviceVersion: "2.1.0",
-                model: modelId,
-                inputTokens: totalIn,
-                outputTokens: totalOut,
-                totalCost: teammateCost,
-            },
-            details: {
+                serviceVersion: PKG_VERSION
+              },
+              details: {
                 is_team: true,
                 is_teammate: true,
                 team_id: teamId,
                 teammate_id: teammateId,
                 teammate_name: teammateName,
-                team_name: teamName,
                 parent_conversation_id: parentConversationId,
-                tasks_completed: tasksCompleted,
-                completion_reason: reason,
-                "gen_ai.request.model": modelId,
-                "gen_ai.usage.input_tokens": totalIn,
-                "gen_ai.usage.output_tokens": totalOut,
-                "gen_ai.usage.cost": teammateCost,
-                display_name: `${teammateName} done`,
-                display_icon: "checkmark.circle.fill",
-                display_color: "#10B981",
-            },
-        });
-    };
-    // Main work loop - keep working until no more tasks
-    let outerTurn = 0;
-    while (true) {
-        // Safety: max turns guard
-        if (++outerTurn > MAX_TEAMMATE_TURNS) {
-            logTeammateComplete("max_turns_reached");
-            report({ type: "done", teammateId, content: `${teammateName} reached max turns (${MAX_TEAMMATE_TURNS})`, tokensUsed: { input: totalIn, output: totalOut } });
-            break;
-        }
-        // Safety: elapsed time guard
-        if (Date.now() - startTime > MAX_TEAMMATE_DURATION_MS) {
-            logTeammateComplete("timeout");
-            report({ type: "done", teammateId, content: `${teammateName} timed out after ${Math.round(MAX_TEAMMATE_DURATION_MS / 60_000)}min`, tokensUsed: { input: totalIn, output: totalOut } });
-            break;
-        }
-        const team = loadTeam(teamId);
-        if (!team || team.status !== "active") {
-            logTeammateComplete("team_inactive");
-            report({ type: "done", teammateId, content: "Team completed or inactive", tokensUsed: { input: totalIn, output: totalOut } });
-            break;
-        }
-        // Find current task or claim a new one
-        const currentTask = currentTaskId
-            ? team.tasks.find(t => t.id === currentTaskId)
-            : null;
-        // If no current task, try to claim one
-        if (!currentTask || currentTask.status === "completed") {
-            const available = getAvailableTasks(team);
-            if (available.length === 0) {
-                // No tasks available, check if all done or waiting
-                const inProgress = team.tasks.filter(t => t.status === "in_progress").length;
-                if (inProgress === 0) {
-                    logTeammateComplete("all_tasks_done");
-                    report({ type: "done", teammateId, content: "All tasks completed", tokensUsed: { input: totalIn, output: totalOut } });
-                    break;
-                }
-                // Wait and retry
-                await new Promise(r => setTimeout(r, 2000));
-                continue;
-            }
-            // Claim first available task
-            const claimed = await claimTask(teamId, available[0].id, teammateId);
-            if (!claimed) {
-                await new Promise(r => setTimeout(r, 1000));
-                continue;
-            }
-            currentTaskId = claimed.id;
-            // Resolve per-task model: task-level → team default
-            const taskModel = claimed.model || model;
-            currentTaskModelId = MODEL_MAP[taskModel] || MODEL_MAP[model] || MODEL_MAP.opus;
-            // Disable thinking for teammates — with MAX_OUTPUT_TOKENS=16K, adaptive thinking
-            // burns 8-12K tokens on reasoning per turn, leaving only 4-8K for actual code output.
-            // This caused catastrophic token bloat (359K input tokens per task) and truncated responses.
-            currentTaskThinking = false;
-            await updateTeammate(teamId, teammateId, { status: "working", currentTask: currentTaskId });
-            report({ type: "task_started", teammateId, taskId: currentTaskId, content: claimed.description });
-            // Start fresh conversation for new task
-            messages = [{
-                    role: "user",
-                    content: `Your task: ${claimed.description}\n\nBegin working on this task. Use the available tools to complete it, then use team_complete_task when done.`,
-                }];
-        }
-        // Build system prompt with current state
-        const freshTeam = loadTeam(teamId);
-        const freshTask = freshTeam.tasks.find(t => t.id === currentTaskId) || null;
-        const systemPrompt = buildTeammatePrompt(teammateName, freshTeam, freshTask, cwd);
-        // Agent loop for current task
-        let apiError = null;
-        for (let turn = 0; turn < MAX_TURNS_PER_TASK; turn++) {
-            const apiStart = Date.now();
-            let response;
-            try {
-                response = await callAPI(currentTaskModelId, systemPrompt, messages, allTools, currentTaskThinking);
-            }
-            catch (err) {
-                apiError = err.message || String(err);
-                report({ type: "progress", teammateId, content: `API error: ${apiError.slice(0, 80)}` });
-                logSpan({
-                    action: "claude_api_request",
-                    durationMs: Date.now() - apiStart,
-                    severity: "error",
-                    error: apiError || undefined,
-                    context: {
-                        traceId: teammateTraceId,
-                        spanId: generateSpanId(),
-                        parentSpanId: teammateSpanId,
-                        conversationId: teammateConversationId,
-                        source: "claude_code",
-                        serviceName: "whale-cli",
-                        serviceVersion: "2.1.0",
-                        model: currentTaskModelId,
-                    },
-                    details: {
-                        is_team: true,
-                        is_teammate: true,
-                        team_id: teamId,
-                        teammate_id: teammateId,
-                        teammate_name: teammateName,
-                        parent_conversation_id: parentConversationId,
-                        turn_number: turn + 1,
-                        task_id: currentTaskId,
-                    },
-                });
-                break; // Exit inner loop — force-complete handler below will deal with the task
-            }
-            const apiDuration = Date.now() - apiStart;
-            totalIn += response.usage.input_tokens;
-            totalOut += response.usage.output_tokens;
-            // Log Claude API request telemetry
-            const turnCostUsd = estimateCostUsd(response.usage.input_tokens, response.usage.output_tokens, currentTaskModelId);
-            logSpan({
-                action: "claude_api_request",
-                durationMs: apiDuration,
-                context: {
-                    traceId: teammateTraceId,
-                    spanId: generateSpanId(),
-                    parentSpanId: teammateSpanId,
-                    conversationId: teammateConversationId,
-                    source: "claude_code",
-                    serviceName: "whale-cli",
-                    serviceVersion: "2.1.0",
-                    model: currentTaskModelId,
-                    inputTokens: response.usage.input_tokens,
-                    outputTokens: response.usage.output_tokens,
-                    totalCost: turnCostUsd,
-                },
-                details: {
-                    is_team: true,
-                    is_teammate: true,
-                    team_id: teamId,
-                    teammate_id: teammateId,
-                    teammate_name: teammateName,
-                    parent_conversation_id: parentConversationId,
-                    turn_number: turn + 1,
-                    task_id: currentTaskId,
-                    stop_reason: response.stop_reason,
-                    "gen_ai.request.model": currentTaskModelId,
-                    "gen_ai.usage.input_tokens": response.usage.input_tokens,
-                    "gen_ai.usage.output_tokens": response.usage.output_tokens,
-                    "gen_ai.usage.cost": turnCostUsd,
-                },
+                task_id: currentTaskId,
+                task_result: result.output.slice(0, 500),
+                display_name: "Task completed",
+                display_icon: "checkmark.square.fill",
+                display_color: "#10B981"
+              }
             });
-            const textBlocks = extractTextBlocks(response.content);
-            const toolBlocks = extractToolUseBlocks(response.content);
-            // Report progress
-            if (textBlocks.length) {
-                report({ type: "progress", teammateId, taskId: currentTaskId || undefined, content: textBlocks[0].text.slice(0, 200) });
-            }
-            // No tools = done with this turn
-            if (toolBlocks.length === 0)
-                break;
-            // Execute tools using shared executeToolBlocks with team-specific custom executor
-            let taskCompleted = false;
-            const { toolResults } = await executeToolBlocks({
-                toolBlocks,
-                loopDetector,
-                toolTimeoutMs: TOOL_TIMEOUT_MS,
-                customExecutor: async (toolName, input) => {
-                    // Only handle team tools; return null to fall through to standard routing
-                    if (!TEAM_TOOLS.some(t => t.name === toolName))
-                        return null;
-                    const result = await executeTeamTool(toolName, input, teamId, teammateId, currentTaskId);
-                    // Check if task was completed
-                    if (toolName === "team_complete_task" && result.success) {
-                        taskCompleted = true;
-                        tasksCompleted++;
-                        report({ type: "task_completed", teammateId, taskId: currentTaskId || undefined, content: result.output });
-                        // Log task completion to telemetry
-                        logSpan({
-                            action: "team.task_complete",
-                            durationMs: 0,
-                            context: {
-                                traceId: teammateTraceId,
-                                spanId: generateSpanId(),
-                                parentSpanId: teammateSpanId,
-                                conversationId: teammateConversationId,
-                                source: "claude_code",
-                                serviceName: "whale-cli",
-                                serviceVersion: "2.1.0",
-                            },
-                            details: {
-                                is_team: true,
-                                is_teammate: true,
-                                team_id: teamId,
-                                teammate_id: teammateId,
-                                teammate_name: teammateName,
-                                parent_conversation_id: parentConversationId,
-                                task_id: currentTaskId,
-                                task_result: result.output.slice(0, 500),
-                                display_name: "Task completed",
-                                display_icon: "checkmark.square.fill",
-                                display_color: "#10B981",
-                            },
-                        });
-                    }
-                    return result;
-                },
-                callbacks: {
-                    onToolEnd: (toolName, success, durationMs) => {
-                        // Determine tool category for telemetry
-                        const toolCategory = TEAM_TOOLS.some(t => t.name === toolName) ? "team" : "standard";
-                        logSpan({
-                            action: `tool.${toolName}`,
-                            durationMs,
-                            severity: success ? "info" : "error",
-                            context: {
-                                traceId: teammateTraceId,
-                                spanId: generateSpanId(),
-                                parentSpanId: teammateSpanId,
-                                conversationId: teammateConversationId,
-                                source: "claude_code",
-                                serviceName: "whale-cli",
-                                serviceVersion: "2.1.0",
-                            },
-                            error: success ? undefined : "(see tool result)",
-                            details: {
-                                is_team: true,
-                                is_teammate: true,
-                                team_id: teamId,
-                                teammate_id: teammateId,
-                                teammate_name: teammateName,
-                                parent_conversation_id: parentConversationId,
-                                tool_category: toolCategory,
-                            },
-                        });
-                    },
-                },
+          }
+          return result;
+        },
+        callbacks: {
+          onToolEnd: (toolName, success, durationMs) => {
+            // Heartbeat: report tool activity to parent so stall detector knows we're alive.
+            // Without this, tool-only responses (no text blocks) never update lastMessageTime
+            // and the worker gets false-positive killed after WORKER_STALL_MS.
+            report({
+              type: "progress",
+              teammateId,
+              taskId: currentTaskId || undefined,
+              content: `${toolName} (${durationMs}ms)`
             });
-            // Append to messages
-            messages.push({ role: "assistant", content: response.content });
-            messages.push({ role: "user", content: toolResults });
-            // If task was completed, break out to get next task
-            if (taskCompleted) {
-                currentTaskId = null;
-                await updateTeammate(teamId, teammateId, { status: "idle", currentTask: undefined });
-                break;
-            }
+
+            // Determine tool category for telemetry
+            const toolCategory = TEAM_TOOLS.some(t => t.name === toolName) ? "team" : "standard";
+            logSpan({
+              action: `tool.${toolName}`,
+              durationMs,
+              severity: success ? "info" : "error",
+              context: {
+                traceId: teammateTraceId,
+                spanId: generateSpanId(),
+                parentSpanId: teammateSpanId,
+                conversationId: teammateConversationId,
+                source: "claude_code",
+                serviceName: "whale-cli",
+                serviceVersion: PKG_VERSION
+              },
+              error: success ? undefined : "(see tool result)",
+              details: {
+                is_team: true,
+                is_teammate: true,
+                team_id: teamId,
+                teammate_id: teammateId,
+                teammate_name: teammateName,
+                parent_conversation_id: parentConversationId,
+                tool_category: toolCategory
+              }
+            });
+          }
         }
-        // If inner loop ended without completing the task (exhausted turns, API error, or no-tool response)
-        if (currentTaskId) {
-            const team = loadTeam(teamId);
-            const task = team?.tasks.find(t => t.id === currentTaskId);
-            if (task && task.status === "in_progress") {
-                if (apiError) {
-                    // API failed — mark task as failed, not completed
-                    await failTask(teamId, currentTaskId, apiError);
-                    // Report as progress (not error) — error type causes red flash in UI via handleTeammateFailure double-handling
-                    report({ type: "progress", teammateId, taskId: currentTaskId, content: `Task failed: ${apiError.slice(0, 80)}` });
-                }
-                else if (totalIn === 0 && totalOut === 0) {
-                    // Zero tokens used means no real work was done — fail the task
-                    await failTask(teamId, currentTaskId, "No API response received (0 tokens)");
-                    report({ type: "progress", teammateId, taskId: currentTaskId, content: "Task failed: no API response" });
-                }
-                else {
-                    // Exhausted turns or model stopped — auto-complete with partial result
-                    const lastText = messages.length > 0 ? messages[messages.length - 1] : null;
-                    let partialResult = "Task auto-completed after reaching turn limit.";
-                    if (lastText && typeof lastText === "object" && "content" in lastText) {
-                        const content = lastText.content;
-                        if (typeof content === "string")
-                            partialResult = content.slice(0, 500);
-                        else if (Array.isArray(content)) {
-                            const txt = content.find((b) => b.type === "text");
-                            if (txt && "text" in txt)
-                                partialResult = txt.text.slice(0, 500);
-                        }
-                    }
-                    await completeTask(teamId, currentTaskId, partialResult);
-                    tasksCompleted++;
-                    report({ type: "task_completed", teammateId, taskId: currentTaskId, content: partialResult });
-                }
+      });
+
+      // Append to messages
+      messages.push({
+        role: "assistant",
+        content: response.content
+      });
+      messages.push({
+        role: "user",
+        content: toolResults
+      });
+
+      // Pre-compact: trim large tool results and thinking blocks to prevent context bloat.
+      // Without this, teammate context grows unbounded (same issue as subagent pre-fix).
+      const maxToolResultChars = resolvedTeammateConfig?.maxToolResultChars ?? AGENT_DEFAULTS.maxToolResultChars;
+      const {
+        messages: compactedMessages
+      } = preCompact(messages, {
+        maxToolResultChars,
+        stripThinking: true
+      });
+      messages = compactedMessages;
+
+      // If task was completed, break out to get next task
+      if (taskCompleted) {
+        currentTaskId = null;
+        await updateTeammate(teamId, teammateId, {
+          status: "idle",
+          currentTask: undefined
+        });
+        break;
+      }
+    }
+
+    // If inner loop ended without the model calling team_complete_task (exhausted turns, API error, or model end_turn)
+    if (currentTaskId) {
+      const team = loadTeam(teamId);
+      const task = team?.tasks.find(t => t.id === currentTaskId);
+      if (task && task.status === "in_progress") {
+        if (apiError) {
+          // API failed — mark task as failed, not completed
+          await failTask(teamId, currentTaskId, apiError);
+          // Report as progress (not error) — error type causes red flash in UI via handleTeammateFailure double-handling
+          report({
+            type: "progress",
+            teammateId,
+            taskId: currentTaskId,
+            content: `Task failed: ${apiError.slice(0, 80)}`
+          });
+        } else if (totalIn === 0 && totalOut === 0) {
+          // Zero tokens used means no real work was done — fail the task
+          await failTask(teamId, currentTaskId, "No API response received (0 tokens)");
+          report({
+            type: "progress",
+            teammateId,
+            taskId: currentTaskId,
+            content: "Task failed: no API response"
+          });
+        } else {
+          // Model stopped (end_turn) or exhausted turns — auto-complete with result
+          const hitTurnLimit = lastTurn >= taskTurnLimit - 1;
+          const lastText = messages.length > 0 ? messages[messages.length - 1] : null;
+          let partialResult = hitTurnLimit ? `Task auto-completed after reaching turn limit (${taskTurnLimit} turns).` : "Task completed (model finished).";
+          if (lastText && typeof lastText === "object" && "content" in lastText) {
+            const content = lastText.content;
+            if (typeof content === "string") partialResult = content.slice(0, 500);else if (Array.isArray(content)) {
+              const txt = content.find(b => b.type === "text");
+              if (txt && "text" in txt) partialResult = txt.text.slice(0, 500);
             }
-            currentTaskId = null;
-            await updateTeammate(teamId, teammateId, { status: "idle", currentTask: undefined });
+          }
+          await completeTask(teamId, currentTaskId, partialResult);
+          tasksCompleted++;
+          report({
+            type: "task_completed",
+            teammateId,
+            taskId: currentTaskId,
+            content: partialResult
+          });
         }
+      }
+      currentTaskId = null;
+      await updateTeammate(teamId, teammateId, {
+        status: "idle",
+        currentTask: undefined
+      });
     }
-    // Final update
-    await updateTeammate(teamId, teammateId, {
-        status: "done",
-        currentTask: undefined,
-        tokensUsed: { input: totalIn, output: totalOut },
-    });
+  }
+
+  // Final update
+  await updateTeammate(teamId, teammateId, {
+    status: "done",
+    currentTask: undefined,
+    tokensUsed: {
+      input: totalIn,
+      output: totalOut
+    }
+  });
 }
+
 // ============================================================================
-// WORKER ENTRY POINT
+// CHILD PROCESS ENTRY POINT
 // ============================================================================
-if (!isMainThread && parentPort) {
-    const data = workerData;
-    // Catch ALL errors including module-level and unhandled rejections
-    process.on("uncaughtException", (err) => {
+
+// Detect if we were forked as a child process (process.send exists when IPC channel is open)
+if (process.send && process.argv.includes("--teammate-child")) {
+  // Wait for startup data from parent via IPC
+  process.on("message", msg => {
+    if (msg?.type === "__teammate_start") {
+      const data = msg.data;
+
+      // Catch ALL errors including module-level and unhandled rejections
+      process.on("uncaughtException", err => {
         try {
-            parentPort.postMessage({
-                type: "error",
-                teammateId: data.teammateId,
-                content: `Uncaught exception: ${err.message || String(err)}`,
-            });
-        }
-        catch { /* last resort — nothing we can do */ }
+          process.send({
+            type: "error",
+            teammateId: data.teammateId,
+            content: `Uncaught exception: ${err.message || String(err)}`
+          });
+        } catch {/* last resort — nothing we can do */}
         process.exit(1);
-    });
-    process.on("unhandledRejection", (reason) => {
+      });
+      process.on("unhandledRejection", reason => {
         try {
-            parentPort.postMessage({
-                type: "error",
-                teammateId: data.teammateId,
-                content: `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`,
-            });
-        }
-        catch { /* last resort */ }
-    });
-    runTeammateLoop(data)
-        .catch(err => {
-        parentPort.postMessage({
+          process.send({
             type: "error",
             teammateId: data.teammateId,
-            content: err.message || String(err),
+            content: `Unhandled rejection: ${reason instanceof Error ? reason.message : String(reason)}`
+          });
+        } catch {/* last resort */}
+      });
+      runTeammateLoop(data).catch(err => {
+        process.send({
+          type: "error",
+          teammateId: data.teammateId,
+          content: err.message || String(err)
         });
-    })
-        .finally(() => {
-        // Force-exit the Worker thread — lingering async resources (HTTP connections,
-        // Supabase clients, telemetry timers) prevent natural exit and cause the
-        // team to hang forever waiting for worker.on("exit").
-        setTimeout(() => process.exit(0), 100); // Brief delay for final messages to flush
-    });
+      }).finally(() => {
+        // Flush telemetry spans before exiting
+        flushCliSpans();
+        // Brief delay for final IPC messages and telemetry to flush,
+        // then exit cleanly. With process isolation, OS reclaims all resources.
+        setTimeout(() => process.exit(0), 300);
+      });
+    }
+  });
 }
+
 // ============================================================================
 // SPAWN TEAMMATE (from main thread)
 // ============================================================================
-export async function spawnTeammate(teamId, teammateId, teammateName, model, cwd, parentConversationId, teamName) {
-    const __filename = fileURLToPath(import.meta.url);
-    const workerPath = __filename.replace(".js", ".js"); // Same file
-    // Get auth token to pass to worker for telemetry
-    const authToken = await getValidToken();
-    const worker = new Worker(workerPath, {
-        workerData: {
-            teamId,
-            teammateId,
-            teammateName,
-            model,
-            cwd,
-            parentConversationId,
-            teamName,
-            authToken: authToken || undefined,
-        },
-    });
-    return worker;
+
+export async function spawnTeammate(teamId, teammateId, teammateName, model, cwd, parentConversationId, teamName, preloadedConfig, preloadedServerTools) {
+  const __filename = fileURLToPath(import.meta.url);
+
+  // Get auth token to pass to child for telemetry
+  const authToken = await getValidToken();
+
+  // Fork a child process running this same file with --teammate-child flag
+  const child = fork(__filename, ["--teammate-child"], {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe", "ipc"],
+    // Inherit parent's env so NODE_PATH, API keys etc. are available
+    env: {
+      ...process.env
+    }
+  });
+
+  // Send startup data via IPC (replaces workerData)
+  // Pre-loaded config and tools avoid each child making redundant DB/API calls
+  child.send({
+    type: "__teammate_start",
+    data: {
+      teamId,
+      teammateId,
+      teammateName,
+      model,
+      cwd,
+      parentConversationId,
+      teamName,
+      authToken: authToken || undefined,
+      preloadedConfig: preloadedConfig ?? undefined,
+      preloadedServerTools: preloadedServerTools ?? undefined
+    }
+  });
+  return child;
 }
+//# sourceMappingURL=teammate.js.map