@kendoo.agentdesk/agentdesk 0.7.3 → 0.8.0

package/bin/agentdesk.mjs

@@ -65,6 +65,7 @@ if (!command || command === "help" || command === "--help") {
   Options:
     --description, -d    Task description or requirements
     --cwd                Working directory (defaults to current)
+    --legacy             Use single-process mode (cheaper, less independent)
 
   How it works:
     With a tracker (Linear, Jira, GitHub Issues):
@@ -100,10 +101,11 @@ else if (command === "init") {
 }
 
 else if (command === "team") {
-  // Parse options first to find -d and --cwd
+  // Parse options first to find -d, --cwd, --legacy
   let description = "";
   let cwd = process.cwd();
   let taskId = null;
+  let legacy = false;
   const remaining = args.slice(1);
 
   for (let i = 0; i < remaining.length; i++) {
@@ -111,6 +113,8 @@ else if (command === "team") {
       description = remaining[++i];
     } else if (remaining[i] === "--cwd" && remaining[i + 1]) {
       cwd = remaining[++i];
+    } else if (remaining[i] === "--legacy") {
+      legacy = true;
     } else if (!taskId && !remaining[i].startsWith("-")) {
       taskId = remaining[i];
     }
@@ -123,7 +127,7 @@ else if (command === "team") {
   }
 
   const { runTeam } = await import("../cli/team.mjs");
-  const code = await runTeam(taskId, { description, cwd });
+  const code = await runTeam(taskId, { description, cwd, legacy });
   process.exit(code);
 }
 

package/cli/agent-prompts.mjs

@@ -0,0 +1,161 @@
+// Per-agent prompt generator for sub-agent architecture
+
+import { generateContext } from "./detect.mjs";
+
+const PHASE_INSTRUCTIONS = {
+  intake: {
+    Jane: `You are leading the intake for this task. Your job:
+1. Understand the task requirements from the description and/or tracker.
+2. Check for existing branches: \`git branch -a | grep <task-id>\`
+3. Check for existing PRs: \`gh pr list --search <task-id> --json number,title,state\`
+4. Explore the codebase briefly to understand what we're working with.
+5. Summarize: what needs to be done, what already exists, and what the starting point is.
+6. Recommend which phase to start from (BRAINSTORM for new work, EXECUTION if branch exists).`,
+  },
+
+  brainstorm: {
+    _default: (agent) => `Share your perspective on this task from your role as ${agent.role}.
+Focus on: ${agent.brainstorm?.focus || "your area of expertise"}.
+Use [${agent.brainstorm?.tag || "SAY"}] tag.
+Be specific. If you disagree with anything in the conversation so far, use [ARGUE] and explain why.
+If you agree, still add value — don't just say "I agree."`,
+  },
+
+  planning: {
+    _default: (agent) => `Present your plan for this task from your role as ${agent.role}.
+Your expected output: ${agent.planning || "Your role-specific plan."}
+Be concrete — name files, approaches, specific concerns.`,
+  },
+
+  "planning-review": {
+    _default: () => `Review all the plans presented by the team.
+If you see problems, conflicts, or missing considerations, use [ARGUE] and explain.
+If everything looks good, acknowledge with [AGREE] and note why.`,
+  },
+
+  execution: {
+    _default: (agent) => {
+      if (!agent.execution) return "This task has no execution step for your role. Skip this phase.";
+      return `Complete your execution tasks:
+${agent.execution.tasks.map((t, i) => `${i + 1}. ${t}`).join("\n")}
+
+Work carefully. Use tools as needed. Narrate what you're doing.`;
+    },
+  },
+
+  "execution-review": {
+    _default: (agent) => `Review the changes made so far.
+From your perspective as ${agent.role}:
+${agent.groundRules || "Review for issues in your area of expertise."}
+If you find issues, describe them specifically with file paths and line numbers.
+If everything looks good, confirm with [AGREE].`,
+  },
+
+  review: {
+    _default: (agent) => `The session is wrapping up. Provide your final notes:
+- Any remaining concerns?
+- Anything the team should watch out for?
+- Overall assessment from your perspective as ${agent.role}.
+Keep it brief.`,
+    Jane: `The session is wrapping up. Provide the final summary:
+1. What was accomplished
+2. Any remaining concerns from the team
+3. What the next steps should be
+Keep it concise.`,
+  },
+};
+
+export function buildAgentPrompt(agent, { phase, task, project, conversation, inboxUrl, sessionUrl }) {
+  const parts = [];
+
+  // Identity
+  parts.push(`You are ${agent.name}, ${agent.role} on a software development team.`);
+  parts.push("");
+
+  // Role
+  parts.push("## Your Role");
+  parts.push(agent.description);
+  if (agent.groundRules) parts.push(`\nGround rules: ${agent.groundRules}`);
+  if (agent.codePrinciple) parts.push(`\nCode principle: ${agent.codePrinciple}`);
+  parts.push("");
+
+  // Communication
+  parts.push("## Communication");
+  parts.push(`Prefix your output with your badge: ${agent.badge}`);
+  parts.push("Use these tags in your messages:");
+  parts.push("- [SAY] — Normal statements, announcements, questions");
+  parts.push("- [THINK] — Internal reasoning, analysis");
+  parts.push("- [ACT] — When using tools or taking actions");
+  parts.push("- [ARGUE] — When you disagree or see problems");
+  parts.push("- [AGREE] — When you agree (but still add value)");
+  parts.push("");
+
+  // Task
+  parts.push("## Task");
+  parts.push(`Task ID: ${task.id}`);
+  if (task.link) parts.push(`Task link: ${task.link}`);
+  if (task.description) parts.push(`\nDescription: ${task.description}`);
+  parts.push("");
+
+  // Project context
+  if (project) {
+    const context = generateContext(project);
+    parts.push("## Project Context");
+    parts.push(context);
+    parts.push("");
+  }
+
+  // Conversation so far
+  if (conversation && conversation.length > 0) {
+    parts.push("## Conversation So Far");
+    for (const msg of conversation) {
+      if (msg.type === "phase") {
+        parts.push(`\n--- ${msg.phase} ---\n`);
+      } else if (msg.agent && msg.message) {
+        parts.push(`${msg.agent} [${msg.tag || "SAY"}]: ${msg.message}`);
+      }
+    }
+    parts.push("");
+  }
+
+  // Phase instructions
+  parts.push(`## Current Phase: ${phase.toUpperCase()}`);
+  const phaseConfig = PHASE_INSTRUCTIONS[phase] || {};
+  const agentInstr = phaseConfig[agent.name] || (phaseConfig._default ? phaseConfig._default(agent) : "Contribute from your area of expertise.");
+  parts.push(agentInstr);
+  parts.push("");
+
+  // Inbox (Jane only)
+  if (agent.name === "Jane" && inboxUrl) {
+    parts.push("## User Messages");
+    parts.push(`Before starting, check for user messages: \`curl -s ${inboxUrl}\``);
+    parts.push("If the response is not empty ([]), read the messages and incorporate the user's input.");
+    parts.push("");
+  }
+
+  // Session URL
+  if (sessionUrl) {
+    parts.push(`Session: ${sessionUrl}`);
+  }
+
+  // Time
+  const now = new Date();
+  parts.push(`\nCurrent date/time: ${now.toLocaleDateString("en-US", { weekday: "long", year: "numeric", month: "long", day: "numeric" })} ${now.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" })}`);
+
+  return parts.join("\n");
+}
+
+// Get tool list for an agent
+const AGENT_TOOLS = {
+  Jane:   ["Bash", "Read"],
+  Dennis: ["Bash", "Read", "Edit", "Write", "Glob", "Grep"],
+  Sam:    ["Read", "Glob", "Grep"],
+  Bart:   ["Bash", "Read", "Glob", "Grep"],
+  Vera:   ["Bash", "Read", "Edit", "Write", "Glob", "Grep"],
+  Luna:   ["Read", "Glob"],
+  Mark:   ["Read", "Glob"],
+};
+
+export function getAgentTools(agentName) {
+  return AGENT_TOOLS[agentName] || ["Bash", "Read", "Edit", "Write", "Glob", "Grep"];
+}

package/cli/agent-runner.mjs

@@ -0,0 +1,148 @@
+// Spawns a single Claude process for one agent and parses its output
+
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+
+export async function runAgent(agentName, {
+  prompt,
+  allowedTools = ["Bash", "Read", "Edit", "Write", "Glob", "Grep"],
+  cwd,
+  env,
+  onMessage,
+  onToolUse,
+  onToolResult,
+}) {
+  const messages = [];
+  const toolUses = [];
+  let rawOutput = "";
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let steps = 0;
+  let hadArgue = false;
+
+  const child = spawn(
+    "claude",
+    [
+      "-p", prompt,
+      "--allowedTools", allowedTools.join(","),
+      "--verbose",
+      "--output-format", "stream-json",
+    ],
+    {
+      stdio: ["pipe", "pipe", "inherit"],
+      shell: false,
+      env: env || process.env,
+      cwd,
+    }
+  );
+
+  child.stdin.end();
+
+  const rl = createInterface({ input: child.stdout });
+
+  for await (const line of rl) {
+    try {
+      const event = JSON.parse(line);
+
+      // Track tokens
+      if (event.usage) {
+        if (event.usage.input_tokens) inputTokens = Math.max(inputTokens, event.usage.input_tokens);
+        if (event.usage.output_tokens) outputTokens += (event.usage.output_tokens_delta || 0);
+      }
+      if (event.message?.usage) {
+        if (event.message.usage.input_tokens) inputTokens = Math.max(inputTokens, event.message.usage.input_tokens);
+        if (event.message.usage.output_tokens) outputTokens = Math.max(outputTokens, event.message.usage.output_tokens);
+      }
+
+      // Text output
+      if (event.type === "assistant" && event.message?.content) {
+        for (const block of event.message.content) {
+          if (block.type === "text" && block.text.trim()) {
+            const text = block.text.trim();
+            rawOutput += text + "\n";
+
+            // Detect tags
+            let tag = "SAY";
+            if (/\[ARGUE\]/i.test(text)) { tag = "ARGUE"; hadArgue = true; }
+            else if (/\[AGREE\]/i.test(text)) tag = "AGREE";
+            else if (/\[THINK\]/i.test(text)) tag = "THINK";
+            else if (/\[ACT\]/i.test(text)) tag = "ACT";
+
+            const cleanMsg = text.replace(/\[(SAY|ACT|THINK|AGREE|ARGUE)\]\s*/gi, "").replace(/\*+/g, "");
+            const msg = { agent: agentName, tag, message: cleanMsg };
+            messages.push(msg);
+            onMessage?.(msg);
+          }
+        }
+      }
+
+      // Tool use
+      if (event.type === "tool_use") {
+        const name = event.name || event.tool_name;
+        steps++;
+
+        let description = "Running command...";
+        if (name === "Bash") {
+          const cmd = event.input?.command || "";
+          if (cmd.includes("curl") && cmd.includes("linear")) description = "Calling Linear API...";
+          else if (cmd.includes("curl")) description = "Making API request...";
+          else {
+            const shortCmd = cmd.length > 80 ? cmd.slice(0, 80) + "..." : cmd;
+            description = `$ ${shortCmd}`;
+          }
+        } else if (name === "Read") {
+          const shortPath = (event.input?.file_path || "").split("/").slice(-3).join("/");
+          description = `Reading ${shortPath}`;
+        } else if (name === "Edit" || name === "Write") {
+          const shortPath = (event.input?.file_path || "").split("/").slice(-3).join("/");
+          description = `${name === "Edit" ? "Editing" : "Writing"} ${shortPath}`;
+        } else if (name === "Glob" || name === "Grep") {
+          description = `Searching ${event.input?.pattern || ""}`;
+        }
+
+        const use = { agent: agentName, tool: name, description };
+        toolUses.push(use);
+        onToolUse?.(use);
+      }
+
+      // Tool result
+      if (event.type === "tool_result") {
+        const output = event.content || event.output;
+        let text = "";
+        if (typeof output === "string") text = output.trim();
+        else if (Array.isArray(output)) {
+          text = output.filter(b => b.type === "text").map(b => b.text.trim()).join("\n");
+        }
+        const hasError = text && (text.toLowerCase().includes("error") || text.toLowerCase().includes("failed"));
+        const summary = text?.length > 300 ? `Done (${text.length} chars)` : text || "Done";
+        onToolResult?.({ success: !hasError, summary });
+      }
+
+      // Final result
+      if (event.type === "result") {
+        if (event.usage) {
+          if (event.usage.input_tokens) inputTokens = Math.max(inputTokens, event.usage.input_tokens);
+          if (event.usage.output_tokens) outputTokens = Math.max(outputTokens, event.usage.output_tokens);
+        }
+      }
+    } catch {
+      // skip non-JSON
+    }
+  }
+
+  const exitCode = await new Promise(resolve => {
+    child.on("close", (code) => resolve(code || 0));
+  });
+
+  return {
+    agent: agentName,
+    messages,
+    toolUses,
+    rawOutput,
+    inputTokens,
+    outputTokens,
+    steps,
+    hadArgue,
+    exitCode,
+  };
+}

package/cli/daemon.mjs

@@ -12,6 +12,7 @@ import { getStoredApiKey } from "./login.mjs";
 import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
 import { buildPrompt } from "./prompt.mjs";
 import { createStreamParser } from "./stream-parser.mjs";
+import { runOrchestrator } from "./orchestrator.mjs";
 import { getRegisteredProjects, registerLocalProject } from "./projects.mjs";
 
 const CONFIG_DIR = join(process.env.HOME || process.env.USERPROFILE, ".agentdesk");
@@ -236,7 +237,8 @@ export async function runDaemon() {
       ws = new WebSocket(DAEMON_URL);
 
       ws.on("open", () => {
-        send({ type: "auth", apiKey });
+        // Send auth directly — send() requires connected=true which isn't set yet
+        ws.send(JSON.stringify({ type: "auth", apiKey }));
       });
 
       ws.on("message", (raw) => {
@@ -358,113 +360,36 @@ export async function runDaemon() {
       const inboxUrl = `${agentdeskServer}/api/sessions/${sessionId}/inbox`;
       const sessionUrl = `${agentdeskServer}/sessions/${sessionId}`;
 
-      // Build prompt
-      const fullPrompt = buildPrompt({
+      // Run orchestrator (sub-agent mode)
+      const result = await runOrchestrator({
         taskId, taskLink,
         description: prompt || "",
         createTask: false,
         tracker, config,
-        project: detected,
-        teamSections, inboxUrl, sessionUrl,
-      });
-
-      // Send session:start
-      sendBuffered(sessionId, {
-        type: "session:start",
-        taskId, taskLink,
-        title: prompt || taskId,
-        project: project.name,
-        sessionNumber: 1,
-        agents: teamSections.names,
-      });
-
-      sendBuffered(sessionId, { type: "phase:change", phase: "INTAKE" });
-
-      // Spawn Claude — NEVER uses --dangerously-skip-permissions
-      const child = spawn(
-        "claude",
-        [
-          "-p", fullPrompt,
-          "--allowedTools", "Bash,Read,Edit,Write,Glob,Grep",
-          "--verbose",
-          "--output-format", "stream-json",
-        ],
-        {
-          stdio: ["pipe", "pipe", "inherit"],
-          shell: false,
-          env: { ...process.env, ...loadDotEnv(project.path) },
-          cwd: project.path,
-        }
-      );
-
-      // Close stdin so claude doesn't wait for input
-      child.stdin.end();
-
-      activeSession.child = child;
-
-      // Parse stream
-      const { parseLine } = createStreamParser({
-        teamNames: teamSections.names,
-        callbacks: {
-          onPhaseChange({ phase }) {
-            sendBuffered(sessionId, { type: "phase:change", phase });
-          },
-          onAgentMessage({ agent, tag, message }) {
-            sendBuffered(sessionId, { type: "agent:message", agent, tag, message });
-          },
-          onToolUse({ agent, tool, description }) {
-            sendBuffered(sessionId, { type: "tool:use", agent, tool, description });
-            // Track file paths for metadata logging
-            const pathMatch = description.match(/(?:Reading|Editing|Writing)\s+(.+)/);
+        project: detected, team, teamSections,
+        inboxUrl, sessionUrl,
+        cwd: project.path,
+        onEvent(event) {
+          sendBuffered(sessionId, event);
+          // Track file paths for metadata logging
+          if (event.type === "tool:use" && event.description) {
+            const pathMatch = event.description.match(/(?:Reading|Editing|Writing)\s+(.+)/);
             if (pathMatch) filePathsTouched.add(pathMatch[1]);
-          },
-          onToolResult({ success, summary }) {
-            sendBuffered(sessionId, { type: "tool:result", success, summary });
-          },
-          onSessionUpdate({ taskId: newTaskId }) {
-            sendBuffered(sessionId, { type: "session:update", taskId: newTaskId });
-          },
-          onSessionEnd({ duration, steps, inputTokens, outputTokens }) {
-            sendBuffered(sessionId, { type: "session:end", duration, steps, inputTokens, outputTokens });
-            console.log(`  ${green}Session complete${reset} ${dim}${sessionId}${reset} (${duration}, ${steps} steps)`);
-
-            // Log metadata
-            logSessionMetadata(sessionId, {
-              sessionId, projectId,
-              startedAt, endedAt: Date.now(),
-              duration, exitCode: 0, steps,
-              filePathsTouched: [...filePathsTouched],
-            });
-
-            activeSession = null;
-          },
+          }
         },
       });
 
-      const rl = createInterface({ input: child.stdout });
-      for await (const line of rl) {
-        parseLine(line);
-      }
+      console.log(`  ${green}Session complete${reset} ${dim}${sessionId}${reset} (${result.duration}, ${result.steps} steps)`);
 
-      // Handle unexpected exit (no "result" event)
-      child.on("close", (code) => {
-        if (activeSession?.sessionId === sessionId) {
-          const duration = `${((Date.now() - startedAt) / 1000).toFixed(1)}s`;
-          console.log(`  ${code ? red : yellow}Session exited${reset} ${dim}${sessionId}${reset} (code ${code})`);
-
-          sendBuffered(sessionId, { type: "session:end", duration, steps: 0, inputTokens: 0, outputTokens: 0 });
-
-          logSessionMetadata(sessionId, {
-            sessionId, projectId,
-            startedAt, endedAt: Date.now(),
-            duration, exitCode: code || 0, steps: 0,
-            filePathsTouched: [...filePathsTouched],
-          });
-
-          activeSession = null;
-        }
+      logSessionMetadata(sessionId, {
+        sessionId, projectId,
+        startedAt, endedAt: Date.now(),
+        duration: result.duration, exitCode: 0, steps: result.steps,
+        filePathsTouched: [...filePathsTouched],
       });
 
+      activeSession = null;
+
     } catch (err) {
       console.log(`  ${red}Failed to start session:${reset} ${err.message}`);
       // Send generic error to server — don't leak internal details (paths, config, etc.)

package/cli/orchestrator.mjs

@@ -0,0 +1,280 @@
+// Orchestrator — manages agent sub-sessions across phases
+
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { runAgent } from "./agent-runner.mjs";
+import { buildAgentPrompt, getAgentTools } from "./agent-prompts.mjs";
+import { detectProject, generateContext } from "./detect.mjs";
+
+function loadDotEnv(dir) {
+  const envPath = join(dir, ".env");
+  if (!existsSync(envPath)) return {};
+  const vars = {};
+  for (const line of readFileSync(envPath, "utf-8").split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    vars[trimmed.slice(0, eq)] = trimmed.slice(eq + 1);
+  }
+  return vars;
+}
+
+function timestamp() {
+  const d = new Date();
+  return [d.getHours(), d.getMinutes(), d.getSeconds()]
+    .map(n => String(n).padStart(2, "0")).join(":");
+}
+
+export async function runOrchestrator({
+  taskId, taskLink, description, createTask, tracker, config,
+  project, team, teamSections, inboxUrl, sessionUrl, cwd,
+  onEvent,
+}) {
+  const state = {
+    task: { id: taskId, link: taskLink, description: description || "" },
+    conversationLog: [],   // { type: "message"|"phase", agent?, tag?, message?, phase? }
+    phaseSummaries: {},
+    totalInputTokens: 0,
+    totalOutputTokens: 0,
+    totalSteps: 0,
+  };
+
+  const env = { ...process.env, ...loadDotEnv(cwd) };
+
+  // Emit event to WebSocket (same protocol as single-process mode)
+  function emit(event) {
+    onEvent?.({ ...event, timestamp: timestamp() });
+  }
+
+  // Add to conversation log
+  function logMessage(agent, tag, message) {
+    state.conversationLog.push({ type: "message", agent, tag, message });
+  }
+
+  function logPhase(phase) {
+    state.conversationLog.push({ type: "phase", phase });
+  }
+
+  // Run a single agent and collect results
+  async function spawnAgent(agentName, agent, phase, extraConversation) {
+    const conversation = extraConversation || state.conversationLog;
+
+    const prompt = buildAgentPrompt(agent, {
+      phase,
+      task: state.task,
+      project,
+      conversation,
+      inboxUrl,
+      sessionUrl,
+    });
+
+    const tools = getAgentTools(agentName);
+
+    const result = await runAgent(agentName, {
+      prompt,
+      allowedTools: tools,
+      cwd,
+      env,
+      onMessage(msg) {
+        emit({ type: "agent:message", agent: msg.agent, tag: msg.tag, message: msg.message });
+        logMessage(msg.agent, msg.tag, msg.message);
+      },
+      onToolUse(use) {
+        emit({ type: "tool:use", agent: use.agent, tool: use.tool, description: use.description });
+      },
+      onToolResult(res) {
+        emit({ type: "tool:result", success: res.success, summary: res.summary });
+      },
+    });
+
+    state.totalInputTokens += result.inputTokens;
+    state.totalOutputTokens += result.outputTokens;
+    state.totalSteps += result.steps;
+
+    return result;
+  }
+
+  // Run multiple agents in parallel
+  async function spawnAgentsParallel(agents, phase, extraConversation) {
+    const conversation = extraConversation || [...state.conversationLog];
+    return Promise.all(
+      agents.map(([name, agent]) => spawnAgent(name, agent, phase, conversation))
+    );
+  }
+
+  // Build summary from agent results
+  function summarizeResults(results) {
+    return results
+      .filter(r => r.messages.length > 0)
+      .map(r => r.messages.map(m => `${m.agent} [${m.tag}]: ${m.message}`).join("\n"))
+      .join("\n\n");
+  }
+
+  // Detect if any agent argued
+  function hasDisagreement(results) {
+    return results.some(r => r.hadArgue);
+  }
+
+  // --- Session start ---
+  const startTime = Date.now();
+  emit({
+    type: "session:start",
+    taskId, taskLink,
+    title: description || taskId,
+    project: project?.name || null,
+    sessionNumber: 1,
+    agents: teamSections.names,
+  });
+
+  // Build agent lookup
+  const agentMap = new Map();
+  for (const agent of team) {
+    agentMap.set(agent.name, agent);
+  }
+
+  // Find specific agents
+  const jane = agentMap.get("Jane");
+  const dennis = agentMap.get("Dennis");
+
+  // ===========================
+  // PHASE 1: INTAKE (Jane only)
+  // ===========================
+  emit({ type: "phase:change", phase: "INTAKE" });
+  logPhase("INTAKE");
+
+  const intakeResult = await spawnAgent("Jane", jane, "intake");
+  state.phaseSummaries.intake = summarizeResults([intakeResult]);
+
+  // ===========================
+  // PHASE 2: BRAINSTORM (parallel, 3-5 rounds)
+  // ===========================
+  emit({ type: "phase:change", phase: "BRAINSTORM" });
+  logPhase("BRAINSTORM");
+
+  const allAgents = [...agentMap.entries()];
+  let brainstormRounds = 0;
+  const MAX_BRAINSTORM_ROUNDS = 5;
+
+  for (let round = 0; round < MAX_BRAINSTORM_ROUNDS; round++) {
+    brainstormRounds++;
+    const results = await spawnAgentsParallel(allAgents, "brainstorm");
+
+    // Check for consensus (no ARGUE tags = consensus)
+    if (!hasDisagreement(results) && round >= 2) {
+      break; // Minimum 3 rounds, then stop on consensus
+    }
+  }
+  state.phaseSummaries.brainstorm = `Brainstorm completed in ${brainstormRounds} rounds.`;
+
+  // ===========================
+  // PHASE 3: PLANNING (parallel + review)
+  // ===========================
+  emit({ type: "phase:change", phase: "PLANNING" });
+  logPhase("PLANNING");
+
+  // Round 1: each agent presents their plan
+  await spawnAgentsParallel(allAgents, "planning");
+
+  // Round 2: review all plans, raise objections
+  const planReviewResults = await spawnAgentsParallel(allAgents, "planning-review");
+  state.phaseSummaries.planning = "Plans finalized.";
+
+  // If there were objections, one more planning round
+  if (hasDisagreement(planReviewResults)) {
+    await spawnAgentsParallel(allAgents, "planning");
+  }
+
+  // ===========================
+  // PHASE 4: EXECUTION (sequential)
+  // ===========================
+  emit({ type: "phase:change", phase: "EXECUTION" });
+  logPhase("EXECUTION");
+
+  // Step 1: Dennis implements
+  if (dennis) {
+    const dennisResult = await spawnAgent("Dennis", dennis, "execution");
+
+    // Step 2: Sam audits (if on team)
+    const sam = agentMap.get("Sam");
+    if (sam) {
+      let fixAttempts = 0;
+      const MAX_FIX_ATTEMPTS = 3;
+
+      while (fixAttempts < MAX_FIX_ATTEMPTS) {
+        const samResult = await spawnAgent("Sam", sam, "execution-review");
+
+        if (!samResult.hadArgue) break; // No issues found
+
+        // Dennis fixes Sam's issues
+        fixAttempts++;
+        if (fixAttempts < MAX_FIX_ATTEMPTS) {
+          await spawnAgent("Dennis", dennis, "execution");
+        }
+      }
+    }
+
+    // Step 3: Luna + Mark review in parallel (if on team)
+    const reviewAgents = [];
+    const luna = agentMap.get("Luna");
+    const mark = agentMap.get("Mark");
+    if (luna) reviewAgents.push(["Luna", luna]);
+    if (mark) reviewAgents.push(["Mark", mark]);
+
+    if (reviewAgents.length > 0) {
+      const reviewResults = await spawnAgentsParallel(reviewAgents, "execution-review");
+
+      // If Luna or Mark found issues, Dennis fixes
+      if (hasDisagreement(reviewResults)) {
+        await spawnAgent("Dennis", dennis, "execution");
+      }
+    }
+
+    // Step 4: Vera writes tests (if on team)
+    const vera = agentMap.get("Vera");
+    if (vera) {
+      await spawnAgent("Vera", vera, "execution");
+    }
+
+    // Step 5: Bart does QA (if on team)
+    const bart = agentMap.get("Bart");
+    if (bart) {
+      await spawnAgent("Bart", bart, "execution");
+    }
+  }
+
+  state.phaseSummaries.execution = "Execution complete.";
+
+  // ===========================
+  // PHASE 5: REVIEW (Jane + parallel)
+  // ===========================
+  emit({ type: "phase:change", phase: "REVIEW" });
+  logPhase("REVIEW");
+
+  // All agents provide final notes in parallel
+  await spawnAgentsParallel(allAgents, "review");
+
+  // Jane wraps up
+  if (jane) {
+    await spawnAgent("Jane", jane, "review");
+  }
+
+  // ===========================
+  // SESSION END
+  // ===========================
+  const duration = `${((Date.now() - startTime) / 1000).toFixed(1)}s`;
+  emit({
+    type: "session:end",
+    duration,
+    steps: state.totalSteps,
+    inputTokens: state.totalInputTokens,
+    outputTokens: state.totalOutputTokens,
+  });
+
+  return {
+    duration,
+    steps: state.totalSteps,
+    inputTokens: state.totalInputTokens,
+    outputTokens: state.totalOutputTokens,
+  };
+}

package/cli/team.mjs

@@ -12,6 +12,7 @@ import { getStoredApiKey } from "./login.mjs";
 import { resolveTeam, generateTeamPrompt } from "./agents.mjs";
 import { buildPrompt } from "./prompt.mjs";
 import { createStreamParser } from "./stream-parser.mjs";
+import { runOrchestrator } from "./orchestrator.mjs";
 
 function loadDotEnv(dir) {
   const envPath = join(dir, ".env");
@@ -30,6 +31,7 @@ function loadDotEnv(dir) {
 export async function runTeam(taskId, opts = {}) {
   const cwd = opts.cwd || process.cwd();
   const description = opts.description || "";
+  const legacy = opts.legacy || false;
 
   // Detect project and resolve API key early (needed for server config fetch)
   const project = detectProject(cwd);
@@ -44,13 +46,11 @@ export async function runTeam(taskId, opts = {}) {
   let createTask = false;
   if (!taskId) {
     if (tracker) {
-      // Tracker configured but no task ID — agents will create a task
       createTask = true;
       taskId = `new-${Date.now().toString(36)}`;
       console.log(`Project: ${project.name || "unknown"} (${project.label})`);
       console.log(`Mode: Create new ${tracker} task from description`);
     } else {
-      // No tracker — generate a label from description
       taskId = description
         .toLowerCase()
         .replace(/[^a-z0-9\s-]/g, "")
@@ -90,12 +90,6 @@ export async function runTeam(taskId, opts = {}) {
   const inboxUrl = `${agentdeskServer}/api/sessions/${sessionId}/inbox`;
   const sessionUrl = `${agentdeskServer}/sessions/${sessionId}`;
 
-  // Build prompt using shared builder
-  const fullPrompt = buildPrompt({
-    taskId, taskLink, description, createTask, tracker, config, project,
-    teamSections, inboxUrl, sessionUrl,
-  });
-
   let vizWs = null;
   let vizConnected = false;
   const vizQueue = [];
@@ -131,19 +125,25 @@ export async function runTeam(taskId, opts = {}) {
           } else {
             console.log("AgentDesk: reconnected");
           }
-          // Always re-send session:start on (re)connect so server knows about the session
-          vizSend({
-            type: "session:start",
-            taskId,
-            taskLink,
-            title: description || taskId,
-            project: project.name || null,
-            sessionNumber: 1,
-            agents: teamSections.names,
-          });
-          sessionStartSent = true;
-          while (vizQueue.length > 0 && vizWs.readyState === WebSocket.OPEN) {
-            vizWs.send(vizQueue.shift());
+          if (!legacy) {
+            // Orchestrator sends its own session:start — just flush queue
+            sessionStartSent = true;
+            while (vizQueue.length > 0 && vizWs.readyState === WebSocket.OPEN) {
+              vizWs.send(vizQueue.shift());
+            }
+          } else {
+            vizSend({
+              type: "session:start",
+              taskId, taskLink,
+              title: description || taskId,
+              project: project.name || null,
+              sessionNumber: 1,
+              agents: teamSections.names,
+            });
+            sessionStartSent = true;
+            while (vizQueue.length > 0 && vizWs.readyState === WebSocket.OPEN) {
+              vizWs.send(vizQueue.shift());
+            }
           }
         } else if (msg.type === "auth:error") {
           console.log("AgentDesk: authentication failed — run 'agentdesk login'");
@@ -155,14 +155,12 @@ export async function runTeam(taskId, opts = {}) {
         vizConnected = false;
         if (code === 4001) {
           console.log("AgentDesk: authentication required — run 'agentdesk login'");
-          return; // Don't reconnect on auth failure
+          return;
         }
-        // Auto-reconnect after 5 seconds
         clearTimeout(reconnectTimer);
         reconnectTimer = setTimeout(connectWs, 5000);
       });
     } catch {
-      // AgentDesk not running — retry in 10s
       clearTimeout(reconnectTimer);
       reconnectTimer = setTimeout(connectWs, 10000);
     }
@@ -170,17 +168,37 @@ export async function runTeam(taskId, opts = {}) {
 
   connectWs();
 
-  // --- Spawn Claude ---
+  console.log(`Mode: ${legacy ? "legacy (single process)" : "sub-agents"}\n`);
+
+  // --- Sub-agent mode (default) ---
+  if (!legacy) {
+    const result = await runOrchestrator({
+      taskId, taskLink, description, createTask, tracker, config,
+      project, team, teamSections, inboxUrl, sessionUrl, cwd,
+      onEvent: vizSend,
+    });
+
+    console.log(`\n━━━ DONE ━━━`);
+    const totalTokens = result.inputTokens + result.outputTokens;
+    console.log(`  ${result.duration}  |  ${result.steps} steps${totalTokens ? `  |  ${totalTokens.toLocaleString()} tokens` : ""}\n`);
+
+    setTimeout(() => { try { vizWs?.close(); } catch {} }, 500);
+    return 0;
+  }
+
+  // --- Legacy mode (single process) ---
+  const fullPrompt = buildPrompt({
+    taskId, taskLink, description, createTask, tracker, config, project,
+    teamSections, inboxUrl, sessionUrl,
+  });
+
   const child = spawn(
     "claude",
     [
-      "-p",
-      fullPrompt,
-      "--allowedTools",
-      "Bash,Read,Edit,Write,Glob,Grep",
+      "-p", fullPrompt,
+      "--allowedTools", "Bash,Read,Edit,Write,Glob,Grep",
       "--verbose",
-      "--output-format",
-      "stream-json",
+      "--output-format", "stream-json",
     ],
     {
       stdio: ["inherit", "pipe", "inherit"],
@@ -193,7 +211,6 @@ export async function runTeam(taskId, opts = {}) {
   process.on("SIGINT", () => { try { child.kill(); } catch {} process.exit(1); });
   process.on("SIGTERM", () => { try { child.kill(); } catch {} process.exit(1); });
 
-  // --- Stream parsing via shared parser ---
   console.log("\n━━━ INTAKE ━━━\n");
   vizSend({ type: "phase:change", phase: "INTAKE" });
 
@@ -215,11 +232,7 @@ export async function runTeam(taskId, opts = {}) {
         vizSend({ type: "agent:message", agent, tag, message });
       },
       onToolUse({ agent, tool, description }) {
-        if (tool === "Bash") {
-          console.log(`  ${agent} [ACT] ${description}`);
-        } else {
-          console.log(`  ${agent} [ACT] ${description}`);
-        }
+        console.log(`  ${agent} [ACT] ${description}`);
         vizSend({ type: "tool:use", agent, tool, description });
       },
       onToolResult({ success, summary }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kendoo.agentdesk/agentdesk",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "description": "AI team orchestrator for Claude Code — run collaborative agent sessions from your terminal",
   "type": "module",
   "bin": {