whale-code 6.5.5 → 6.5.7

package/dist/cli/services/team-lead.js

@@ -7,511 +7,782 @@
  * - Monitors progress
  * - Synthesizes results
  */
+
 import { EventEmitter } from "events";
-import { createTeam, loadTeam, saveTeam, addTeammate, addTask, getTeamProgress, setTeamStatus, sendMessage, getUnreadMessages, markMessagesRead, failTask, updateTeammate, } from "./team-state.js";
+import { createTeam, loadTeam, saveTeam, addTeammate, addTask, getTeamProgress, setTeamStatus, sendMessage, getUnreadMessages, markMessagesRead, failTask, updateTeammate, cleanupStaleTeams } from "./team-state.js";
 import { spawnTeammate } from "./teammate.js";
-import { logSpan, generateTraceId, generateSpanId, getConversationId } from "./telemetry.js";
+import { logSpan, generateTraceId, generateSpanId, getConversationId, PKG_VERSION } from "./telemetry.js";
 import { resolveConfig } from "./config-store.js";
 import { getGlobalEmitter } from "./agent-events.js";
+import { AGENT_DEFAULTS } from "../../shared/agent-core.js";
+import { loadCLIAgentConfig } from "./agent-config.js";
+import { MODELS } from "../../shared/constants.js";
 import { getModelShortName } from "./agent-loop.js";
 import { decomposeTask, sanitizePrompts } from "./task-decomposer.js";
-import { callWithRetry } from "./api-retry.js";
+import { loadServerToolDefinitions } from "./server-tools.js";
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
 // ============================================================================
 // TEAM LEAD CLASS
 // ============================================================================
-const TEAM_TIMEOUT_MS = 5 * 60 * 1000; // 5 min total
-const WORKER_STALL_MS = 2 * 60 * 1000; // 2 min no messages
+
+let TEAM_TIMEOUT_MS = AGENT_DEFAULTS.teamTimeoutMs;
+let WORKER_STALL_MS = AGENT_DEFAULTS.workerStallMs;
+let TEAM_REVIEW_MAX_TOKENS = AGENT_DEFAULTS.teamReviewMaxTokens;
+
+// ============================================================================
+// RUNNING TEAMS REGISTRY — task_output / task_stop use this to access teams
+// ============================================================================
+
+const runningTeams = new Map();
+export function getRunningTeam(teamId) {
+  return runningTeams.get(teamId);
+}
+/** Shorter timeout for worker initialization — if no IPC message within this window,
+ *  the child likely crashed during module loading or startup. Much shorter than
+ *  WORKER_STALL_MS (which guards against stalls *during work*). */
+const WORKER_INIT_TIMEOUT_MS = 30_000;
 export class TeamLead extends EventEmitter {
-    teamId = null;
-    workers = new Map();
-    lastMessageTime = new Map();
-    teamTimer = null;
-    stallInterval = null;
-    resolveTeam = null;
-    traceId;
-    spanId;
-    startTime = 0;
-    constructor() {
-        super();
-        this.traceId = generateTraceId();
-        this.spanId = generateSpanId();
+  teamId = null;
+  workers = new Map();
+  lastMessageTime = new Map();
+  /** Tracks whether each worker has sent at least one IPC message. */
+  workerInitialized = new Set();
+  teamTimer = null;
+  stallInterval = null;
+  resolveTeam = null;
+  startTime = 0;
+  constructor() {
+    super();
+    this.traceId = generateTraceId();
+    this.spanId = generateSpanId();
+  }
+
+  /**
+   * Generate meaningful teammate names from task descriptions
+   * Extracts key action words to create role-based names
+   */
+  generateTeammateNames(tasks, count) {
+    const roles = ["Researcher", "Analyst", "Writer", "Reviewer", "Coordinator", "Specialist", "Explorer", "Synthesizer"];
+
+    // Extract keywords from task descriptions
+    const names = [];
+    const usedRoles = new Set();
+    for (let i = 0; i < count; i++) {
+      if (i < tasks.length) {
+        const desc = tasks[i].description.toLowerCase();
+
+        // Match task keywords to roles
+        let role;
+        if (desc.includes("research") || desc.includes("search") || desc.includes("find")) {
+          role = "Researcher";
+        } else if (desc.includes("analyze") || desc.includes("analysis") || desc.includes("review")) {
+          role = "Analyst";
+        } else if (desc.includes("write") || desc.includes("create") || desc.includes("draft")) {
+          role = "Writer";
+        } else if (desc.includes("compile") || desc.includes("combine") || desc.includes("synthesize")) {
+          role = "Synthesizer";
+        } else if (desc.includes("explore") || desc.includes("investigate")) {
+          role = "Explorer";
+        } else {
+          // Use a generic role
+          role = roles[i % roles.length];
+        }
+
+        // Avoid duplicate names by adding number if needed
+        if (usedRoles.has(role)) {
+          let suffix = 2;
+          while (usedRoles.has(`${role} ${suffix}`)) suffix++;
+          role = `${role} ${suffix}`;
+        }
+        usedRoles.add(role);
+        names.push(role);
+      } else {
+        // More teammates than tasks - use generic names
+        names.push(roles[i % roles.length]);
+      }
     }
-    /**
-     * Generate meaningful teammate names from task descriptions
-     * Extracts key action words to create role-based names
-     */
-    generateTeammateNames(tasks, count) {
-        const roles = [
-            "Researcher", "Analyst", "Writer", "Reviewer",
-            "Coordinator", "Specialist", "Explorer", "Synthesizer"
-        ];
-        // Extract keywords from task descriptions
-        const names = [];
-        const usedRoles = new Set();
-        for (let i = 0; i < count; i++) {
-            if (i < tasks.length) {
-                const desc = tasks[i].description.toLowerCase();
-                // Match task keywords to roles
-                let role;
-                if (desc.includes("research") || desc.includes("search") || desc.includes("find")) {
-                    role = "Researcher";
-                }
-                else if (desc.includes("analyze") || desc.includes("analysis") || desc.includes("review")) {
-                    role = "Analyst";
-                }
-                else if (desc.includes("write") || desc.includes("create") || desc.includes("draft")) {
-                    role = "Writer";
-                }
-                else if (desc.includes("compile") || desc.includes("combine") || desc.includes("synthesize")) {
-                    role = "Synthesizer";
-                }
-                else if (desc.includes("explore") || desc.includes("investigate")) {
-                    role = "Explorer";
-                }
-                else {
-                    // Use a generic role
-                    role = roles[i % roles.length];
-                }
-                // Avoid duplicate names by adding number if needed
-                if (usedRoles.has(role)) {
-                    let suffix = 2;
-                    while (usedRoles.has(`${role} ${suffix}`))
-                        suffix++;
-                    role = `${role} ${suffix}`;
-                }
-                usedRoles.add(role);
-                names.push(role);
-            }
-            else {
-                // More teammates than tasks - use generic names
-                names.push(roles[i % roles.length]);
-            }
+    return names;
+  }
+
+  // ============================================================================
+  // TEAM CREATION
+  // ============================================================================
+
+  async createTeam(config) {
+    this.startTime = Date.now();
+
+    // Clean up zombie teams from previous crashed sessions
+    cleanupStaleTeams();
+
+    // Create team
+    const team = createTeam(config.name, "lead");
+    this.teamId = team.id;
+
+    // Register so task_output/task_stop can access running teams
+    runningTeams.set(team.id, this);
+    this.emit("team_created", {
+      teamId: team.id,
+      name: config.name
+    });
+
+    // Emit to global emitter for UI
+    const emitter = getGlobalEmitter();
+    emitter.emitTeamStart(team.id, config.name, config.teammateCount, config.tasks.length);
+
+    // Log team creation
+    logSpan({
+      action: "team.create",
+      durationMs: 0,
+      context: {
+        traceId: this.traceId,
+        spanId: this.spanId,
+        conversationId: getConversationId(),
+        source: "claude_code",
+        serviceName: "whale-cli",
+        serviceVersion: PKG_VERSION
+      },
+      storeId: resolveConfig().storeId || undefined,
+      details: {
+        // Team identification (for blackops detection)
+        is_team: true,
+        is_team_coordinator: true,
+        team_id: team.id,
+        team_name: config.name,
+        teammate_count: config.teammateCount,
+        task_count: config.tasks.length,
+        model: config.model || getModelShortName(),
+        // Display metadata
+        display_name: `Team: ${config.name}`,
+        display_icon: "person.3.fill",
+        display_color: "#10B981"
+      }
+    });
+
+    // Create tasks
+    const taskIdMap = new Map(); // description -> id
+    for (const taskConfig of config.tasks) {
+      const task = await addTask(team.id, {
+        description: taskConfig.description,
+        files: taskConfig.files,
+        model: taskConfig.model
+      });
+      if (task) {
+        taskIdMap.set(taskConfig.description, task.id);
+        this.emit("task_created", {
+          taskId: task.id,
+          description: taskConfig.description
+        });
+      }
+    }
+
+    // Set up dependencies (now that we have IDs)
+    const freshTeam = loadTeam(team.id);
+    for (const taskConfig of config.tasks) {
+      if (taskConfig.dependencies?.length) {
+        const task = freshTeam.tasks.find(t => t.description === taskConfig.description);
+        if (task) {
+          task.dependencies = taskConfig.dependencies.map(dep => taskIdMap.get(dep)).filter(Boolean);
         }
-        return names;
+      }
     }
-    // ============================================================================
-    // TEAM CREATION
-    // ============================================================================
-    async createTeam(config) {
-        this.startTime = Date.now();
-        // Create team
-        const team = createTeam(config.name, "lead");
-        this.teamId = team.id;
-        this.emit("team_created", { teamId: team.id, name: config.name });
-        // Emit to global emitter for UI
-        const emitter = getGlobalEmitter();
-        emitter.emitTeamStart(team.id, config.name, config.teammateCount, config.tasks.length);
-        // Log team creation
-        logSpan({
-            action: "team.create",
-            durationMs: 0,
-            context: {
-                traceId: this.traceId,
-                spanId: this.spanId,
-                conversationId: getConversationId(),
-                source: "claude_code",
-                serviceName: "whale-cli",
-                serviceVersion: "2.1.0",
-            },
-            storeId: resolveConfig().storeId || undefined,
-            details: {
-                // Team identification (for blackops detection)
-                is_team: true,
-                is_team_coordinator: true,
-                team_id: team.id,
-                team_name: config.name,
-                teammate_count: config.teammateCount,
-                task_count: config.tasks.length,
-                model: config.model || getModelShortName(),
-                // Display metadata
-                display_name: `Team: ${config.name}`,
-                display_icon: "person.3.fill",
-                display_color: "#10B981",
-            },
+    saveTeam(freshTeam);
+
+    // Create teammates with meaningful names
+    const model = config.model || getModelShortName();
+
+    // Generate teammate names from tasks if not provided
+    const teammateNames = config.teammateNames || this.generateTeammateNames(config.tasks, config.teammateCount);
+    for (let i = 0; i < config.teammateCount; i++) {
+      const name = teammateNames[i] || `Agent ${i + 1}`;
+      const id = `teammate-${i + 1}-${Date.now()}`;
+      await addTeammate(team.id, {
+        id,
+        name,
+        model,
+        status: "idle"
+      });
+      this.emit("teammate_created", {
+        teammateId: id,
+        name
+      });
+    }
+    return team.id;
+  }
+
+  // ============================================================================
+  // TEAM EXECUTION
+  // ============================================================================
+
+  async runTeam() {
+    if (!this.teamId) {
+      throw new Error("No team created. Call createTeam first.");
+    }
+
+    // Resolve config from DB (single source of truth) before starting
+    const dbAgent = await loadCLIAgentConfig();
+    if (dbAgent?.context_config) {
+      const cc = dbAgent.context_config;
+      TEAM_TIMEOUT_MS = cc.team_timeout_ms ?? TEAM_TIMEOUT_MS;
+      WORKER_STALL_MS = cc.worker_stall_ms ?? WORKER_STALL_MS;
+      TEAM_REVIEW_MAX_TOKENS = cc.team_review_max_tokens ?? TEAM_REVIEW_MAX_TOKENS;
+    }
+    const team = loadTeam(this.teamId);
+    const cwd = process.cwd();
+    this.emit("team_started", {
+      teamId: this.teamId,
+      teammateCount: team.teammates.length
+    });
+
+    // Pre-load config and server tools ONCE — avoids N redundant DB/API calls from children.
+    // This is the main optimization for team launch speed (was 2-3 min, now seconds).
+    const [preloadedConfig, preloadedServerTools] = await Promise.all([loadCLIAgentConfig(), loadServerToolDefinitions().catch(() => [])]);
+
+    // Spawn ALL child processes in parallel (fork is fast, sequential await was wasteful)
+    const parentConversationId = getConversationId();
+    const spawned = await Promise.all(team.teammates.map(async teammate => ({
+      teammate,
+      child: await spawnTeammate(this.teamId, teammate.id, teammate.name, teammate.model, cwd, parentConversationId, team.name, preloadedConfig, preloadedServerTools)
+    })));
+
+    // Wire up IPC handlers after all processes are spawned
+    for (const {
+      teammate,
+      child
+    } of spawned) {
+      this.lastMessageTime.set(teammate.id, Date.now());
+
+      // Handle messages from child process via IPC
+      child.on("message", msg => {
+        this.lastMessageTime.set(msg.teammateId, Date.now());
+        this.workerInitialized.add(msg.teammateId);
+        this.handleTeammateMessage(msg);
+      });
+      child.on("error", err => {
+        this.emit("teammate_error", {
+          teammateId: teammate.id,
+          error: err.message
         });
-        // Create tasks
-        const taskIdMap = new Map(); // description -> id
-        for (const taskConfig of config.tasks) {
-            const task = await addTask(team.id, {
-                description: taskConfig.description,
-                files: taskConfig.files,
-                model: taskConfig.model,
-            });
-            if (task) {
-                taskIdMap.set(taskConfig.description, task.id);
-                this.emit("task_created", { taskId: task.id, description: taskConfig.description });
-            }
+        // Fail any in-progress task when child crashes
+        this.handleTeammateFailure(teammate.id, err.message);
+      });
+      child.on("exit", (code, signal) => {
+        if (code !== 0 && code !== null) {
+          this.emit("teammate_exit", {
+            teammateId: teammate.id,
+            code
+          });
+          // Fail any in-progress task on non-zero exit
+          this.handleTeammateFailure(teammate.id, `Process exited with code ${code}`);
+        } else if (signal) {
+          this.emit("teammate_exit", {
+            teammateId: teammate.id,
+            signal
+          });
+          this.handleTeammateFailure(teammate.id, `Process killed by signal ${signal}`);
         }
-        // Set up dependencies (now that we have IDs)
-        const freshTeam = loadTeam(team.id);
-        for (const taskConfig of config.tasks) {
-            if (taskConfig.dependencies?.length) {
-                const task = freshTeam.tasks.find(t => t.description === taskConfig.description);
-                if (task) {
-                    task.dependencies = taskConfig.dependencies
-                        .map(dep => taskIdMap.get(dep))
-                        .filter(Boolean);
-                }
-            }
+        this.workers.delete(teammate.id);
+        this.checkCompletion();
+      });
+      this.workers.set(teammate.id, child);
+    }
+
+    // Wait for all workers to complete — with adaptive timeout and stall detection
+    return new Promise(resolve => {
+      this.resolveTeam = resolve;
+      const cleanup = () => {
+        if (this.teamTimer) {
+          clearTimeout(this.teamTimer);
+          this.teamTimer = null;
         }
-        saveTeam(freshTeam);
-        // Create teammates with meaningful names
-        const model = config.model || getModelShortName();
-        // Generate teammate names from tasks if not provided
-        const teammateNames = config.teammateNames || this.generateTeammateNames(config.tasks, config.teammateCount);
-        for (let i = 0; i < config.teammateCount; i++) {
-            const name = teammateNames[i] || `Agent ${i + 1}`;
-            const id = `teammate-${i + 1}-${Date.now()}`;
-            await addTeammate(team.id, {
-                id,
-                name,
-                model,
-                status: "idle",
-            });
-            this.emit("teammate_created", { teammateId: id, name });
+        if (this.stallInterval) {
+          clearInterval(this.stallInterval);
+          this.stallInterval = null;
         }
-        return team.id;
-    }
-    // ============================================================================
-    // TEAM EXECUTION
-    // ============================================================================
-    async runTeam() {
-        if (!this.teamId) {
-            throw new Error("No team created. Call createTeam first.");
+      };
+      const forceComplete = reason => {
+        cleanup();
+        this.resolveTeam = null; // Prevent double-resolve from checkCompletion
+        // Kill all remaining child processes
+        for (const [id, child] of this.workers) {
+          this.emit("teammate_timeout", {
+            teammateId: id,
+            reason
+          });
+          this.handleTeammateFailure(id, `Terminated: ${reason}`);
+          child.kill();
         }
-        const team = loadTeam(this.teamId);
-        const cwd = process.cwd();
-        this.emit("team_started", { teamId: this.teamId, teammateCount: team.teammates.length });
-        // Spawn worker threads for each teammate
-        const parentConversationId = getConversationId();
-        for (const teammate of team.teammates) {
-            const worker = await spawnTeammate(this.teamId, teammate.id, teammate.name, teammate.model, cwd, parentConversationId, team.name);
-            this.lastMessageTime.set(teammate.id, Date.now());
-            // Handle messages from worker
-            worker.on("message", (msg) => {
-                this.lastMessageTime.set(msg.teammateId, Date.now());
-                this.handleTeammateMessage(msg);
-            });
-            worker.on("error", (err) => {
-                this.emit("teammate_error", { teammateId: teammate.id, error: err.message });
-                // Fail any in-progress task when worker crashes
-                this.handleTeammateFailure(teammate.id, err.message);
+        this.workers.clear();
+        this.workerInitialized.clear();
+        if (this.teamId) setTeamStatus(this.teamId, "completed");
+        resolve(this.buildResult());
+      };
+
+      // No global team timeout (Claude Code parity) — teams run until done.
+      // Per-worker stall detection (below) is the safety guard for hung processes.
+      // TEAM_TIMEOUT_MS > 0 enables optional adaptive timeout for server/workflow paths.
+      if (TEAM_TIMEOUT_MS > 0) {
+        const resetTeamTimer = () => {
+          if (this.teamTimer) clearTimeout(this.teamTimer);
+          this.teamTimer = setTimeout(() => {
+            if (this.workers.size > 0) {
+              forceComplete(`Team timeout (no progress for ${TEAM_TIMEOUT_MS / 1000}s)`);
+            }
+          }, TEAM_TIMEOUT_MS);
+        };
+        // Only reset on meaningful progress — task starts and completions.
+        // Plain progress messages (polling, status updates) should NOT reset the timer,
+        // otherwise a spinning teammate prevents the timeout from ever firing.
+        this.on("task_started", () => resetTeamTimer());
+        this.on("task_completed", () => resetTeamTimer());
+        resetTeamTimer();
+      }
+
+      // Stall detection — check every 5s for stalled or uninitialized workers
+      this.stallInterval = setInterval(() => {
+        if (this.workers.size === 0) {
+          cleanup();
+          return;
+        }
+        const now = Date.now();
+        for (const [id, child] of this.workers) {
+          const lastMsg = this.lastMessageTime.get(id) || 0;
+          const elapsed = now - lastMsg;
+
+          // Uninitialized workers get a shorter deadline — if the child process
+          // never sent any IPC message, it likely crashed during module loading.
+          if (!this.workerInitialized.has(id) && elapsed > WORKER_INIT_TIMEOUT_MS) {
+            this.emit("teammate_timeout", {
+              teammateId: id,
+              reason: "init_timeout"
             });
-            worker.on("exit", (code) => {
-                if (code !== 0) {
-                    this.emit("teammate_exit", { teammateId: teammate.id, code });
-                    // Fail any in-progress task on non-zero exit
-                    this.handleTeammateFailure(teammate.id, `Worker exited with code ${code}`);
-                }
-                this.workers.delete(teammate.id);
-                this.checkCompletion();
+            this.handleTeammateFailure(id, `Worker never initialized (no IPC messages for ${WORKER_INIT_TIMEOUT_MS / 1000}s)`);
+            child.kill();
+            this.workers.delete(id);
+            continue;
+          }
+
+          // Initialized workers get the standard stall timeout
+          if (this.workerInitialized.has(id) && elapsed > WORKER_STALL_MS) {
+            this.emit("teammate_timeout", {
+              teammateId: id,
+              reason: "stall"
             });
-            this.workers.set(teammate.id, worker);
+            this.handleTeammateFailure(id, `Process stalled (no messages for ${WORKER_STALL_MS / 1000}s)`);
+            child.kill();
+            this.workers.delete(id);
+          }
         }
-        // Wait for all workers to complete — with timeout and stall detection
-        return new Promise((resolve) => {
-            this.resolveTeam = resolve;
-            const cleanup = () => {
-                if (this.teamTimer) {
-                    clearTimeout(this.teamTimer);
-                    this.teamTimer = null;
-                }
-                if (this.stallInterval) {
-                    clearInterval(this.stallInterval);
-                    this.stallInterval = null;
-                }
-            };
-            const forceComplete = (reason) => {
-                cleanup();
-                this.resolveTeam = null; // Prevent double-resolve from checkCompletion
-                // Terminate all remaining workers
-                for (const [id, worker] of this.workers) {
-                    this.emit("teammate_timeout", { teammateId: id, reason });
-                    this.handleTeammateFailure(id, `Terminated: ${reason}`);
-                    worker.terminate();
-                }
-                this.workers.clear();
-                if (this.teamId)
-                    setTeamStatus(this.teamId, "completed");
-                resolve(this.buildResult());
-            };
-            // Global team timeout
-            this.teamTimer = setTimeout(() => {
-                if (this.workers.size > 0) {
-                    forceComplete(`Team timeout after ${TEAM_TIMEOUT_MS / 1000}s`);
-                }
-            }, TEAM_TIMEOUT_MS);
-            // Stall detection — check every 15s for stalled workers
-            this.stallInterval = setInterval(() => {
-                if (this.workers.size === 0) {
-                    cleanup();
-                    return;
-                }
-                const now = Date.now();
-                for (const [id, worker] of this.workers) {
-                    const lastMsg = this.lastMessageTime.get(id) || 0;
-                    if (now - lastMsg > WORKER_STALL_MS) {
-                        this.emit("teammate_timeout", { teammateId: id, reason: "stall" });
-                        this.handleTeammateFailure(id, `Worker stalled (no messages for ${WORKER_STALL_MS / 1000}s)`);
-                        worker.terminate();
-                        this.workers.delete(id);
-                    }
-                }
-            }, 15_000);
+      }, 5_000);
+    });
+  }
+
+  // ============================================================================
+  // MESSAGE HANDLING
+  // ============================================================================
+
+  handleTeammateMessage(msg) {
+    const emitter = getGlobalEmitter();
+    const team = this.teamId ? loadTeam(this.teamId) : null;
+    const teammate = team?.teammates.find(t => t.id === msg.teammateId);
+    const teammateName = teammate?.name || msg.teammateId;
+    switch (msg.type) {
+      case "progress":
+        this.emit("teammate_progress", {
+          teammateId: msg.teammateId,
+          taskId: msg.taskId,
+          content: msg.content
         });
-    }
-    // ============================================================================
-    // MESSAGE HANDLING
-    // ============================================================================
-    handleTeammateMessage(msg) {
-        const emitter = getGlobalEmitter();
-        const team = this.teamId ? loadTeam(this.teamId) : null;
-        const teammate = team?.teammates.find(t => t.id === msg.teammateId);
-        const teammateName = teammate?.name || msg.teammateId;
-        switch (msg.type) {
-            case "progress":
-                this.emit("teammate_progress", {
-                    teammateId: msg.teammateId,
-                    taskId: msg.taskId,
-                    content: msg.content,
-                });
-                // Emit to global emitter for UI
-                if (this.teamId) {
-                    emitter.emitTeamProgress(this.teamId, msg.teammateId, teammateName, msg.content, msg.taskId);
-                }
-                break;
-            case "task_started":
-                this.emit("task_started", {
-                    teammateId: msg.teammateId,
-                    taskId: msg.taskId,
-                    content: msg.content,
-                });
-                // Emit to global emitter for UI
-                if (this.teamId && msg.taskId) {
-                    emitter.emitTeamTask(this.teamId, msg.teammateId, msg.taskId, msg.content, "started");
-                }
-                break;
-            case "task_completed":
-                this.emit("task_completed", {
-                    teammateId: msg.teammateId,
-                    taskId: msg.taskId,
-                    content: msg.content,
-                });
-                // Emit to global emitter for UI
-                if (this.teamId && msg.taskId) {
-                    emitter.emitTeamTask(this.teamId, msg.teammateId, msg.taskId, msg.content, "completed", msg.content);
-                }
-                break;
-            case "message_sent":
-                this.emit("message_sent", {
-                    teammateId: msg.teammateId,
-                    content: msg.content,
-                });
-                break;
-            case "done": {
-                this.emit("teammate_done", {
-                    teammateId: msg.teammateId,
-                    content: msg.content,
-                    tokensUsed: msg.tokensUsed,
-                });
-                // Emit UI event so TeamPanel shows "done" (overrides any prior "failed" from task errors)
-                const teammateName = this.teamId
-                    ? loadTeam(this.teamId)?.teammates.find(t => t.id === msg.teammateId)?.name
-                    : undefined;
-                emitter.emitTeamProgress(this.teamId, msg.teammateId, teammateName || msg.teammateId, "done");
-                break;
-            }
-            case "error":
-                this.emit("teammate_error", {
-                    teammateId: msg.teammateId,
-                    content: msg.content,
-                });
-                // Fail any in-progress task when teammate reports error
-                this.handleTeammateFailure(msg.teammateId, msg.content);
-                break;
-        }
-    }
-    // ============================================================================
-    // FAILURE HANDLING
-    // ============================================================================
-    async handleTeammateFailure(teammateId, errorMessage) {
-        if (!this.teamId)
-            return;
-        const team = loadTeam(this.teamId);
-        if (!team)
-            return;
-        const teammate = team.teammates.find(t => t.id === teammateId);
-        if (!teammate)
-            return;
-        // Find and fail the task this teammate was working on
-        const inProgressTask = team.tasks.find(t => t.status === "in_progress" && t.assignedTo === teammateId);
-        if (inProgressTask) {
-            await failTask(this.teamId, inProgressTask.id, errorMessage);
-            this.emit("task_failed", {
-                teammateId,
-                taskId: inProgressTask.id,
-                error: errorMessage,
-            });
-            // Emit to global emitter for UI
-            const emitter = getGlobalEmitter();
-            emitter.emitTeamTask(this.teamId, teammateId, inProgressTask.id, inProgressTask.description, "failed", errorMessage);
+        // Emit to global emitter for UI
+        if (this.teamId) {
+          emitter.emitTeamProgress(this.teamId, msg.teammateId, teammateName, msg.content, msg.taskId);
         }
-        // Update teammate status (use "done" since "error" isn't a valid status)
-        await updateTeammate(this.teamId, teammateId, {
-            status: "done",
-            currentTask: undefined,
+        break;
+      case "task_started":
+        this.emit("task_started", {
+          teammateId: msg.teammateId,
+          taskId: msg.taskId,
+          content: msg.content
         });
-    }
-    // ============================================================================
-    // COMPLETION
-    // ============================================================================
-    checkCompletion() {
-        if (this.workers.size === 0 && this.teamId) {
-            // Clean up timers
-            if (this.teamTimer) {
-                clearTimeout(this.teamTimer);
-                this.teamTimer = null;
-            }
-            if (this.stallInterval) {
-                clearInterval(this.stallInterval);
-                this.stallInterval = null;
-            }
-            setTeamStatus(this.teamId, "completed");
-            this.emit("team_completed", { teamId: this.teamId });
-            // Resolve the runTeam() promise
-            if (this.resolveTeam) {
-                this.resolveTeam(this.buildResult());
-                this.resolveTeam = null;
-            }
+        // Emit to global emitter for UI
+        if (this.teamId && msg.taskId) {
+          emitter.emitTeamTask(this.teamId, msg.teammateId, msg.taskId, msg.content, "started");
         }
-    }
-    buildResult() {
-        if (!this.teamId) {
-            return {
-                success: false,
-                teamId: "",
-                summary: "No team created",
-                taskResults: [],
-                tokensUsed: { input: 0, output: 0 },
-                durationMs: Date.now() - this.startTime,
-            };
+        break;
+      case "task_completed":
+        this.emit("task_completed", {
+          teammateId: msg.teammateId,
+          taskId: msg.taskId,
+          content: msg.content
+        });
+        // Emit to global emitter for UI
+        if (this.teamId && msg.taskId) {
+          emitter.emitTeamTask(this.teamId, msg.teammateId, msg.taskId, msg.content, "completed", msg.content);
         }
-        const team = loadTeam(this.teamId);
-        const progress = getTeamProgress(team);
-        // Calculate total tokens
-        let totalIn = 0;
-        let totalOut = 0;
-        for (const teammate of team.teammates) {
-            totalIn += teammate.tokensUsed.input;
-            totalOut += teammate.tokensUsed.output;
+        break;
+      case "message_sent":
+        this.emit("message_sent", {
+          teammateId: msg.teammateId,
+          content: msg.content
+        });
+        break;
+      case "done":
+        {
+          this.emit("teammate_done", {
+            teammateId: msg.teammateId,
+            content: msg.content,
+            tokensUsed: msg.tokensUsed
+          });
+          // Persist tokens from IPC message — the child also writes these, but this
+          // guards against the child crashing after sending the IPC "done" message
+          // but before its own updateTeammate() completes (race condition).
+          if (this.teamId && msg.tokensUsed) {
+            updateTeammate(this.teamId, msg.teammateId, {
+              status: "done",
+              currentTask: undefined,
+              tokensUsed: msg.tokensUsed
+            });
+          }
+          // Emit UI event so TeamPanel shows "done" (overrides any prior "failed" from task errors)
+          const teammateName2 = this.teamId ? loadTeam(this.teamId)?.teammates.find(t => t.id === msg.teammateId)?.name : undefined;
+          emitter.emitTeamProgress(this.teamId, msg.teammateId, teammateName2 || msg.teammateId, "done");
+          break;
         }
-        // Build task results
-        const taskResults = team.tasks.map(t => ({
-            description: t.description,
-            result: t.result || t.error || "Not completed",
-            status: t.status === "completed" ? "completed" : "failed",
-        }));
-        const durationMs = Date.now() - this.startTime;
-        const success = progress.blocked === 0 && progress.completed === progress.total;
-        // Log team completion
-        logSpan({
-            action: "team.complete",
-            durationMs,
-            context: {
-                traceId: this.traceId,
-                spanId: generateSpanId(),
-                parentSpanId: this.spanId,
-                source: "claude_code",
-                serviceName: "whale-cli",
-                serviceVersion: "2.1.0",
-                inputTokens: totalIn,
-                outputTokens: totalOut,
-            },
-            storeId: resolveConfig().storeId || undefined,
-            details: {
-                // Team identification (for blackops detection)
-                is_team: true,
-                is_team_coordinator: true,
-                team_id: this.teamId,
-                team_name: team.name,
-                // Metrics
-                tasks_total: progress.total,
-                tasks_completed: progress.completed,
-                tasks_failed: progress.blocked,
-                teammates: team.teammates.length,
-                percent_complete: progress.percentComplete,
-                // Display metadata
-                display_name: `Team Complete: ${team.name}`,
-                display_icon: "checkmark.circle.fill",
-                display_color: success ? "#10B981" : "#EF4444",
-            },
+      case "error":
+        this.emit("teammate_error", {
+          teammateId: msg.teammateId,
+          content: msg.content
         });
-        // Emit team done to global emitter for UI
-        const emitter = getGlobalEmitter();
-        emitter.emitTeamDone(this.teamId, success, `${progress.completed}/${progress.total} tasks completed`, progress.completed, progress.total, { input: totalIn, output: totalOut }, durationMs);
-        return {
-            success,
-            teamId: this.teamId,
-            summary: `${progress.completed}/${progress.total} tasks completed (${progress.percentComplete}%)`,
-            taskResults,
-            tokensUsed: { input: totalIn, output: totalOut },
-            durationMs,
-        };
+        // Fail any in-progress task when teammate reports error
+        this.handleTeammateFailure(msg.teammateId, msg.content);
+        break;
     }
-    // ============================================================================
-    // CONTROL METHODS
-    // ============================================================================
-    async sendToTeammate(teammateId, message) {
-        if (!this.teamId)
-            return false;
-        const result = await sendMessage(this.teamId, "lead", teammateId, message);
-        return !!result;
+  }
+
+  // ============================================================================
+  // FAILURE HANDLING
+  // ============================================================================
+
+  async handleTeammateFailure(teammateId, errorMessage) {
+    if (!this.teamId) return;
+    const team = loadTeam(this.teamId);
+    if (!team) return;
+    const teammate = team.teammates.find(t => t.id === teammateId);
+    if (!teammate) return;
+
+    // Find and fail the task this teammate was working on
+    const inProgressTask = team.tasks.find(t => t.status === "in_progress" && t.assignedTo === teammateId);
+    if (inProgressTask) {
+      await failTask(this.teamId, inProgressTask.id, errorMessage);
+      this.emit("task_failed", {
+        teammateId,
+        taskId: inProgressTask.id,
+        error: errorMessage
+      });
+
+      // Emit to global emitter for UI
+      const emitter = getGlobalEmitter();
+      emitter.emitTeamTask(this.teamId, teammateId, inProgressTask.id, inProgressTask.description, "failed", errorMessage);
     }
-    async broadcast(message) {
-        if (!this.teamId)
-            return false;
-        const result = await sendMessage(this.teamId, "lead", "all", message);
-        return !!result;
+
+    // Update teammate status (use "done" since "error" isn't a valid status)
+    await updateTeammate(this.teamId, teammateId, {
+      status: "done",
+      currentTask: undefined
+    });
+  }
+
+  // ============================================================================
+  // COMPLETION
+  // ============================================================================
+
+  checkCompletion() {
+    if (this.workers.size === 0 && this.teamId) {
+      // Clean up timers
+      if (this.teamTimer) {
+        clearTimeout(this.teamTimer);
+        this.teamTimer = null;
+      }
+      if (this.stallInterval) {
+        clearInterval(this.stallInterval);
+        this.stallInterval = null;
+      }
+      setTeamStatus(this.teamId, "completed");
+      runningTeams.delete(this.teamId);
+      this.emit("team_completed", {
+        teamId: this.teamId
+      });
+      // Resolve the runTeam() promise
+      if (this.resolveTeam) {
+        this.resolveTeam(this.buildResult());
+        this.resolveTeam = null;
+      }
     }
-    async getMessages() {
-        if (!this.teamId)
-            return [];
-        const messages = await getUnreadMessages(this.teamId, "lead");
-        if (messages.length > 0) {
-            await markMessagesRead(this.teamId, messages.map(m => m.id));
-        }
-        return messages.map(m => ({ from: m.from, content: m.content }));
+  }
+  buildResult() {
+    if (!this.teamId) {
+      return {
+        success: false,
+        teamId: "",
+        summary: "No team created",
+        taskResults: [],
+        tokensUsed: {
+          input: 0,
+          output: 0
+        },
+        durationMs: Date.now() - this.startTime
+      };
     }
-    getProgress() {
-        if (!this.teamId)
-            return null;
-        const team = loadTeam(this.teamId);
-        if (!team)
-            return null;
-        return getTeamProgress(team);
+    const team = loadTeam(this.teamId);
+    const progress = getTeamProgress(team);
+
+    // Calculate total tokens
+    let totalIn = 0;
+    let totalOut = 0;
+    for (const teammate of team.teammates) {
+      totalIn += teammate.tokensUsed.input;
+      totalOut += teammate.tokensUsed.output;
     }
-    stop() {
-        // Terminate all workers
-        for (const [id, worker] of this.workers) {
-            worker.terminate();
-            this.emit("teammate_stopped", { teammateId: id });
-        }
-        this.workers.clear();
-        if (this.teamId) {
-            setTeamStatus(this.teamId, "failed");
-        }
+
+    // Build task results
+    const taskResults = team.tasks.map(t => ({
+      description: t.description,
+      result: t.result || t.error || "Not completed",
+      status: t.status === "completed" ? "completed" : "failed"
+    }));
+    const durationMs = Date.now() - this.startTime;
+    const success = progress.blocked === 0 && progress.completed === progress.total;
+
+    // Log team completion
+    logSpan({
+      action: "team.complete",
+      durationMs,
+      context: {
+        traceId: this.traceId,
+        spanId: generateSpanId(),
+        parentSpanId: this.spanId,
+        source: "claude_code",
+        serviceName: "whale-cli",
+        serviceVersion: PKG_VERSION,
+        inputTokens: totalIn,
+        outputTokens: totalOut
+      },
+      storeId: resolveConfig().storeId || undefined,
+      details: {
+        // Team identification (for blackops detection)
+        is_team: true,
+        is_team_coordinator: true,
+        team_id: this.teamId,
+        team_name: team.name,
+        // Metrics
+        tasks_total: progress.total,
+        tasks_completed: progress.completed,
+        tasks_failed: progress.blocked,
+        teammates: team.teammates.length,
+        percent_complete: progress.percentComplete,
+        // Display metadata
+        display_name: `Team Complete: ${team.name}`,
+        display_icon: "checkmark.circle.fill",
+        display_color: success ? "#10B981" : "#EF4444"
+      }
+    });
+
+    // Emit team done to global emitter for UI
+    const emitter = getGlobalEmitter();
+    emitter.emitTeamDone(this.teamId, success, `${progress.completed}/${progress.total} tasks completed`, progress.completed, progress.total, {
+      input: totalIn,
+      output: totalOut
+    }, durationMs);
+    return {
+      success,
+      teamId: this.teamId,
+      summary: `${progress.completed}/${progress.total} tasks completed (${progress.percentComplete}%)`,
+      taskResults,
+      tokensUsed: {
+        input: totalIn,
+        output: totalOut
+      },
+      durationMs
+    };
+  }
+
+  // ============================================================================
+  // CONTROL METHODS
+  // ============================================================================
+
+  async sendToTeammate(teammateId, message) {
+    if (!this.teamId) return false;
+    const result = await sendMessage(this.teamId, "lead", teammateId, message);
+    return !!result;
+  }
+  async broadcast(message) {
+    if (!this.teamId) return false;
+    const result = await sendMessage(this.teamId, "lead", "all", message);
+    return !!result;
+  }
+  async getMessages() {
+    if (!this.teamId) return [];
+    const messages = await getUnreadMessages(this.teamId, "lead");
+    if (messages.length > 0) {
+      await markMessagesRead(this.teamId, messages.map(m => m.id));
+    }
+    return messages.map(m => ({
+      from: m.from,
+      content: m.content
+    }));
+  }
+  getProgress() {
+    if (!this.teamId) return null;
+    const team = loadTeam(this.teamId);
+    if (!team) return null;
+    return getTeamProgress(team);
+  }
+
+  /** Get a detailed snapshot of team state for task_output. */
+  getSnapshot() {
+    if (!this.teamId) return null;
+    const team = loadTeam(this.teamId);
+    if (!team) return null;
+    const progress = getTeamProgress(team);
+    let totalIn = 0,
+      totalOut = 0;
+    for (const tm of team.teammates) {
+      totalIn += tm.tokensUsed.input;
+      totalOut += tm.tokensUsed.output;
+    }
+    const teammates = team.teammates.map(tm => {
+      const task = tm.currentTask ? team.tasks.find(t => t.id === tm.currentTask) : null;
+      return {
+        id: tm.id,
+        name: tm.name,
+        model: tm.model,
+        status: tm.status,
+        currentTask: tm.currentTask,
+        currentTaskDescription: task?.description?.slice(0, 120),
+        tokensUsed: tm.tokensUsed,
+        alive: this.workers.has(tm.id)
+      };
+    });
+    const tasks = team.tasks.map(t => ({
+      id: t.id,
+      description: t.description.slice(0, 150),
+      status: t.status,
+      assignedTo: t.assignedTo,
+      result: t.result?.slice(0, 200),
+      error: t.error?.slice(0, 200)
+    }));
+    return {
+      teamId: this.teamId,
+      teamName: team.name,
+      status: team.status,
+      elapsedMs: Date.now() - this.startTime,
+      progress,
+      teammates,
+      tasks,
+      tokensUsed: {
+        input: totalIn,
+        output: totalOut
+      }
+    };
+  }
+
+  /** Kill a specific teammate by ID. Returns true if found and killed. */
+  stopTeammate(teammateId) {
+    const child = this.workers.get(teammateId);
+    if (!child) return false;
+    child.kill();
+    this.workers.delete(teammateId);
+    this.handleTeammateFailure(teammateId, "Killed by operator");
+    this.emit("teammate_stopped", {
+      teammateId
+    });
+    this.checkCompletion();
+    return true;
+  }
+  stop() {
+    // Kill all child processes
+    for (const [id, child] of this.workers) {
+      child.kill();
+      this.emit("teammate_stopped", {
+        teammateId: id
+      });
+    }
+    this.workers.clear();
+    this.workerInitialized.clear();
+    if (this.teamId) {
+      setTeamStatus(this.teamId, "failed");
+      runningTeams.delete(this.teamId);
     }
+
+    // Clean up timers
+    if (this.teamTimer) {
+      clearTimeout(this.teamTimer);
+      this.teamTimer = null;
+    }
+    if (this.stallInterval) {
+      clearInterval(this.stallInterval);
+      this.stallInterval = null;
+    }
+
+    // Resolve the runTeam() promise to prevent hang
+    if (this.resolveTeam) {
+      this.resolveTeam(this.buildResult());
+      this.resolveTeam = null;
+    }
+  }
 }
+
 // ============================================================================
 // CONVENIENCE FUNCTION
 // ============================================================================
-export async function runAgentTeam(config) {
-    const lead = new TeamLead();
-    // Events are handled via global emitter -> ChatApp UI
-    // No stderr writes here to avoid interfering with Ink rendering
-    await lead.createTeam(config);
-    return lead.runTeam();
+
+/**
+ * Start an agent team in the background. Returns the team ID immediately.
+ * The team runs asynchronously — use getRunningTeam(teamId) to check status.
+ * The TeamResult promise resolves when all teammates finish.
+ */
+export async function startAgentTeam(config, signal) {
+  const lead = new TeamLead();
+  await lead.createTeam(config);
+
+  // Wire signal to stop the team on abort (ESC)
+  if (signal) {
+    if (signal.aborted) {
+      lead.stop();
+      return {
+        teamId: lead["teamId"],
+        resultPromise: Promise.resolve(lead["buildResult"]())
+      };
+    }
+    signal.addEventListener("abort", () => lead.stop(), {
+      once: true
+    });
+  }
+  const resultPromise = lead.runTeam();
+  return {
+    teamId: lead["teamId"],
+    resultPromise
+  };
 }
+
+/**
+ * Legacy blocking API — runs team and waits for completion.
+ * Kept for backward compatibility (team-lead-auto.ts review pass).
+ */
+export async function runAgentTeam(config, signal) {
+  const {
+    resultPromise
+  } = await startAgentTeam(config, signal);
+  return resultPromise;
+}
+
+// ============================================================================
+// AUTO-DECOMPOSE + REVIEW
+// ============================================================================
+
 /**
  * Auto-decompose a task into sub-tasks and run them as a team.
  *
@@ -520,73 +791,137 @@ export async function runAgentTeam(config) {
  * a lightweight review pass to summarize results and flag issues.
  */
 export async function runAutoTeam(task, opts = {}) {
-    const maxTeammates = opts.maxTeammates ?? 4;
-    const model = opts.model || "sonnet";
-    const workingDirectory = opts.workingDirectory || process.cwd();
-    const shouldReview = opts.review !== false;
-    // 1. Decompose
-    const decomposition = await decomposeTask(task, {
-        maxCells: maxTeammates,
-        apiKey: opts.apiKey,
-        workingDirectory,
-    });
-    // 2. Sanitize prompts
-    const warnings = sanitizePrompts(decomposition.sub_tasks);
-    if (warnings.length > 0) {
-        console.warn(`[team] Sanitization warnings:\n${warnings.join("\n")}`);
-    }
-    // 3. Map sub-tasks to TeamConfig
-    const tasks = decomposition.sub_tasks.map(st => ({
-        description: st.prompt,
-        files: extractFiles(st.prompt),
-    }));
-    const config = {
-        name: decomposition.summary.slice(0, 60) || "Auto Team",
-        teammateCount: tasks.length,
-        model,
-        tasks,
+  const maxTeammates = opts.maxTeammates ?? 4;
+  const model = opts.model || "sonnet";
+  const workingDirectory = opts.workingDirectory || process.cwd();
+  const shouldReview = opts.review !== false;
+
+  // 1. Decompose
+  const decomposition = await decomposeTask(task, {
+    maxCells: maxTeammates,
+    workingDirectory
+  });
+
+  // 2. Sanitize prompts
+  const warnings = sanitizePrompts(decomposition.sub_tasks);
+  if (warnings.length > 0) {
+    console.warn(`[team] Sanitization warnings:\n${warnings.join("\n")}`);
+  }
+
+  // 3. Map sub-tasks to TeamConfig (pre-embed reference file content)
+  const tasks = await Promise.all(decomposition.sub_tasks.map(async st => {
+    const files = extractFiles(st.prompt);
+    const embedded = await preReadFiles(files, workingDirectory);
+    return {
+      description: st.prompt + embedded,
+      files
     };
-    // 4. Run team
-    const result = await runAgentTeam(config);
-    // 5. Optional review
-    let review;
-    if (shouldReview && result.taskResults.length > 0) {
-        review = await reviewResults(task, result, opts.apiKey);
-    }
-    return { ...result, review, warnings: warnings.length > 0 ? warnings : undefined };
+  }));
+  const config = {
+    name: decomposition.summary.slice(0, 60) || "Auto Team",
+    teammateCount: tasks.length,
+    model,
+    tasks
+  };
+
+  // 4. Run team
+  const result = await runAgentTeam(config, opts.signal);
+
+  // 5. Optional review
+  let review;
+  if (shouldReview && result.taskResults.length > 0) {
+    review = await reviewResults(task, result);
+  }
+  return {
+    ...result,
+    review,
+    warnings: warnings.length > 0 ? warnings : undefined
+  };
 }
+
 /** Extract file paths mentioned in a sub-task prompt. */
 function extractFiles(prompt) {
-    const matches = prompt.match(/(?:^|\s)((?:src|lib|app|pages|components|test|spec|public)\/[\w./-]+)/gm);
-    return matches ? [...new Set(matches.map(m => m.trim()))] : [];
+  const matches = prompt.match(/(?:^|\s)((?:src|lib|app|pages|components|test|spec|public)\/[\w./-]+)/gm);
+  return matches ? [...new Set(matches.map(m => m.trim()))] : [];
 }
-/** Lightweight review of team results using Claude haiku. */
-async function reviewResults(originalTask, result, apiKey) {
-    const key = apiKey || process.env.ANTHROPIC_API_KEY;
-    if (!key)
-        return undefined;
+const MAX_FILE_PREVIEW_CHARS = 2000; // Per file
+const MAX_TOTAL_EMBED_CHARS = 8000; // Per task
+
+/** Pre-read files mentioned in task prompts and return their content for embedding. */
+async function preReadFiles(files, cwd) {
+  if (files.length === 0) return "";
+  const {
+    readFileSync,
+    statSync
+  } = await import("fs");
+  const {
+    join
+  } = await import("path");
+  const sections = [];
+  let totalChars = 0;
+  for (const file of files) {
+    if (totalChars >= MAX_TOTAL_EMBED_CHARS) break;
+    const fullPath = file.startsWith("/") ? file : join(cwd, file);
     try {
-        const Anthropic = (await import("@anthropic-ai/sdk")).default;
-        const client = new Anthropic({ apiKey: key });
-        const taskSummaries = result.taskResults
-            .map((t, i) => `Task ${i + 1} [${t.status}]: ${t.description.slice(0, 100)}\nResult: ${t.result.slice(0, 200)}`)
-            .join("\n\n");
-        const response = await callWithRetry(() => client.messages.create({
-            model: "claude-haiku-4-5-20251001",
-            max_tokens: 1024,
-            system: "You are a code review assistant. Given the original task and the results from parallel agents, provide a brief (2-4 sentence) assessment: were the goals met? Any conflicts or gaps between agents' work? Any follow-up needed?",
-            messages: [{
-                    role: "user",
-                    content: `Original task: ${originalTask}\n\nTeam results (${result.taskResults.length} agents):\n${taskSummaries}`,
-                }],
-        }), { label: "team-review", maxRetries: 1 });
-        const text = response.content
-            .filter((b) => b.type === "text")
-            .map((b) => b.text)
-            .join("");
-        return text || undefined;
-    }
-    catch {
-        return undefined;
+      const stat = statSync(fullPath);
+      if (!stat.isFile() || stat.size > 50_000) continue; // Skip dirs and huge files
+      const content = readFileSync(fullPath, "utf-8");
+      const preview = content.slice(0, MAX_FILE_PREVIEW_CHARS);
+      const truncated = preview.length < content.length ? "\n... (truncated)" : "";
+      sections.push(`### ${file}\n\`\`\`\n${preview}${truncated}\n\`\`\``);
+      totalChars += preview.length;
+    } catch {
+      // File doesn't exist or can't be read — skip silently
     }
+  }
+  if (sections.length === 0) return "";
+  return `\n\n## Reference Files (pre-loaded — no need to re-read these)\n${sections.join("\n\n")}`;
+}
+
+/** Lightweight review of team results using Claude haiku via proxy. */
+async function reviewResults(originalTask, result) {
+  const {
+    getValidToken
+  } = await import("./auth-service.js");
+  const {
+    getProxyUrl
+  } = await import("./config-store.js");
+  const {
+    callServerProxy,
+    buildAPIRequest
+  } = await import("../../shared/api-client.js");
+  const {
+    parseSSEStream,
+    collectStreamResult
+  } = await import("../../shared/sse-parser.js");
+  const token = await getValidToken();
+  if (!token) return undefined;
+  try {
+    const taskSummaries = result.taskResults.map((t, i) => `Task ${i + 1} [${t.status}]: ${t.description.slice(0, 100)}\nResult: ${t.result.slice(0, 200)}`).join("\n\n");
+    const apiConfig = buildAPIRequest({
+      model: MODELS.HAIKU,
+      contextProfile: "subagent"
+    });
+    const stream = await callServerProxy({
+      proxyUrl: getProxyUrl(),
+      token,
+      model: MODELS.HAIKU,
+      system: [{
+        type: "text",
+        text: "You are a code review assistant. Given the original task and the results from parallel agents, provide a brief (2-4 sentence) assessment: were the goals met? Any conflicts or gaps between agents' work? Any follow-up needed?"
+      }],
+      messages: [{
+        role: "user",
+        content: `Original task: ${originalTask}\n\nTeam results (${result.taskResults.length} agents):\n${taskSummaries}`
+      }],
+      tools: [],
+      apiConfig,
+      timeoutMs: 15_000
+    });
+    const collected = await collectStreamResult(parseSSEStream(stream));
+    return collected.text || undefined;
+  } catch {
+    return undefined;
+  }
 }
+//# sourceMappingURL=team-lead.js.map