bit-office 0.2.0 → 1.0.0

package/dist/index.js

@@ -524,8 +524,8 @@ function getErrorMap() {
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path, errorMaps, issueData } = params;
-  const fullPath = [...path, ...issueData.path || []];
+  const { data, path: path6, errorMaps, issueData } = params;
+  const fullPath = [...path6, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -641,11 +641,11 @@ var errorUtil;
 
 // ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path, key) {
+  constructor(parent, value, path6, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path;
+    this._path = path6;
     this._key = key;
   }
   get path() {
@@ -4140,6 +4140,22 @@ var OpenFileCommand = external_exports.object({
   type: external_exports.literal("OPEN_FILE"),
   path: external_exports.string()
 });
+var CreateTeamCommand = external_exports.object({
+  type: external_exports.literal("CREATE_TEAM"),
+  leadPresetIndex: external_exports.number(),
+  memberPresetIndices: external_exports.array(external_exports.number()),
+  backends: external_exports.record(external_exports.string(), external_exports.string()).optional()
+});
+var ServePreviewCommand = external_exports.object({
+  type: external_exports.literal("SERVE_PREVIEW"),
+  filePath: external_exports.string()
+});
+var StopTeamCommand = external_exports.object({
+  type: external_exports.literal("STOP_TEAM")
+});
+var FireTeamCommand = external_exports.object({
+  type: external_exports.literal("FIRE_TEAM")
+});
 var CommandSchema = external_exports.discriminatedUnion("type", [
   RunTaskCommand,
   ApprovalDecisionCommand,
@@ -4147,7 +4163,11 @@ var CommandSchema = external_exports.discriminatedUnion("type", [
   PingCommand,
   CreateAgentCommand,
   FireAgentCommand,
-  OpenFileCommand
+  OpenFileCommand,
+  CreateTeamCommand,
+  ServePreviewCommand,
+  StopTeamCommand,
+  FireTeamCommand
 ]);
 
 // ../../packages/shared/src/events.ts
@@ -4181,16 +4201,20 @@ var ApprovalNeededEvent = external_exports.object({
 });
 var TaskResultPayload = external_exports.object({
   summary: external_exports.string(),
+  fullOutput: external_exports.string().optional(),
   changedFiles: external_exports.array(external_exports.string()),
   diffStat: external_exports.string(),
   testResult: external_exports.enum(["passed", "failed", "unknown"]),
-  nextSuggestion: external_exports.string().optional()
+  nextSuggestion: external_exports.string().optional(),
+  previewUrl: external_exports.string().optional(),
+  previewPath: external_exports.string().optional()
 });
 var TaskDoneEvent = external_exports.object({
   type: external_exports.literal("TASK_DONE"),
   agentId: external_exports.string(),
   taskId: external_exports.string(),
-  result: TaskResultPayload
+  result: TaskResultPayload,
+  isFinalResult: external_exports.boolean().optional()
 });
 var TaskFailedEvent = external_exports.object({
   type: external_exports.literal("TASK_FAILED"),
@@ -4212,12 +4236,38 @@ var AgentCreatedEvent = external_exports.object({
   role: external_exports.string(),
   palette: external_exports.number().optional(),
   personality: external_exports.string().optional(),
-  backend: external_exports.string().optional()
+  backend: external_exports.string().optional(),
+  isTeamLead: external_exports.boolean().optional(),
+  teamId: external_exports.string().optional()
 });
 var AgentFiredEvent = external_exports.object({
   type: external_exports.literal("AGENT_FIRED"),
   agentId: external_exports.string()
 });
+var TaskResultReturnedEvent = external_exports.object({
+  type: external_exports.literal("TASK_RESULT_RETURNED"),
+  fromAgentId: external_exports.string(),
+  toAgentId: external_exports.string(),
+  taskId: external_exports.string(),
+  summary: external_exports.string(),
+  success: external_exports.boolean()
+});
+var TeamChatEvent = external_exports.object({
+  type: external_exports.literal("TEAM_CHAT"),
+  fromAgentId: external_exports.string(),
+  toAgentId: external_exports.string().optional(),
+  message: external_exports.string(),
+  messageType: external_exports.enum(["delegation", "result", "status"]),
+  taskId: external_exports.string().optional(),
+  timestamp: external_exports.number()
+});
+var TaskQueuedEvent = external_exports.object({
+  type: external_exports.literal("TASK_QUEUED"),
+  agentId: external_exports.string(),
+  taskId: external_exports.string(),
+  prompt: external_exports.string(),
+  position: external_exports.number()
+});
 var GatewayEventSchema = external_exports.discriminatedUnion("type", [
   AgentStatusEvent,
   TaskStartedEvent,
@@ -4227,9 +4277,22 @@ var GatewayEventSchema = external_exports.discriminatedUnion("type", [
   TaskFailedEvent,
   TaskDelegatedEvent,
   AgentCreatedEvent,
-  AgentFiredEvent
+  AgentFiredEvent,
+  TaskResultReturnedEvent,
+  TeamChatEvent,
+  TaskQueuedEvent
 ]);
 
+// ../../packages/shared/src/presets.ts
+var AGENT_PRESETS = [
+  { palette: 0, name: "Alex", role: "Frontend Dev", description: "UI components, React/Next.js/CSS", personality: "You speak in a friendly, casual, encouraging, and natural tone." },
+  { palette: 1, name: "Mia", role: "Backend Dev", description: "APIs, database, server logic", personality: "You speak formally, professionally, in an organized and concise manner." },
+  { palette: 2, name: "Leo", role: "Fullstack Dev", description: "End-to-end, frontend + backend", personality: "You are aggressive, action-first, always pursuing speed and efficiency." },
+  { palette: 3, name: "Sophie", role: "Code Reviewer", description: "Review PRs, find bugs, quality", personality: "You teach patiently, explain the reasoning, and guide like a mentor." },
+  { palette: 4, name: "Yuki", role: "QA / Tester", description: "Quick smoke test, verify core works", personality: "You are extremely concise, no fluff, straight to the result. RULES: Only verify core functionality works (max 3-5 checks). Report PASS/FAIL per check with one line of evidence. Do NOT write unit tests or test files unless explicitly asked. Do NOT list improvements, suggestions, or nice-to-haves. Do NOT test edge cases. FORBIDDEN: Do NOT start any HTTP server. Do NOT use agent-browser or any browser automation tool. Do NOT install or run npx packages for testing. Only use file reading, static analysis, and simple CLI commands (like node --check) to verify code. End your report with exactly one line: VERDICT: PASS or VERDICT: FAIL. A FAIL means the feature doesn't start or crashes, not that something could be better." },
+  { palette: 5, name: "Marcus", role: "Architect", description: "System design, refactoring", personality: "You speak formally, professionally, in an organized and concise manner." }
+];
+
 // src/config.ts
 import "dotenv/config";
 import { resolve, dirname } from "path";
@@ -4281,7 +4344,7 @@ function buildConfig() {
   const saved = loadSavedConfig();
   return {
     machineId: getOrCreateMachineId(),
-    defaultWorkspace: process.cwd(),
+    defaultWorkspace: process.env.WORKSPACE || process.cwd(),
     wsPort: 9090,
     ablyApiKey: process.env.ABLY_API_KEY || saved.ablyApiKey || void 0,
     webDir: resolveWebDir(),
@@ -4566,24 +4629,163 @@ var ablyChannel = {
 
 // src/telegram-channel.ts
 import TelegramBot from "node-telegram-bot-api";
-
-// src/agent-session.ts
-import { spawn, execSync as execSync2 } from "child_process";
 import { nanoid } from "nanoid";
+var PRESETS = [
+  { name: "Alex", role: "Frontend Dev", palette: 0, personality: "You speak in a friendly, casual, encouraging, and natural tone." },
+  { name: "Mia", role: "Backend Dev", palette: 1, personality: "You speak formally, professionally, in an organized and concise manner." },
+  { name: "Leo", role: "Fullstack Dev", palette: 2, personality: "You are aggressive, action-first, always pursuing speed and efficiency." },
+  { name: "Sophie", role: "Code Reviewer", palette: 3, personality: "You teach patiently, explain the reasoning, and guide like a mentor." },
+  { name: "Yuki", role: "QA / Tester", palette: 4, personality: "You are extremely concise, no fluff, straight to the result." },
+  { name: "Marcus", role: "Architect", palette: 5, personality: "You speak formally, professionally, in an organized and concise manner." }
+];
+var botAgents = [];
+function formatEvent(event, agentId) {
+  if (event.type === "TASK_STARTED" && event.agentId === agentId) {
+    return `\u{1F527} Working on it...`;
+  }
+  if (event.type === "TASK_DONE" && event.agentId === agentId) {
+    const r = event.result;
+    let msg = `\u2705 Task completed
+
+${r.summary}`;
+    if (r.changedFiles.length > 0) {
+      msg += `
+
+\u{1F4C1} Changed files:
+${r.changedFiles.map((f) => `\u2022 ${f}`).join("\n")}`;
+    }
+    return msg;
+  }
+  if (event.type === "TASK_FAILED" && event.agentId === agentId) {
+    return `\u274C Task failed
+
+${event.error}`;
+  }
+  if (event.type === "APPROVAL_NEEDED" && event.agentId === agentId) {
+    return `\u26A0\uFE0F Approval needed
+
+${event.title}
+${event.summary}
+
+Reply /yes or /no`;
+  }
+  return null;
+}
+var telegramChannel = {
+  name: "Telegram",
+  async init(commandHandler) {
+    const tokens = config.telegramBotTokens;
+    if (!tokens.length || tokens.every((t) => !t)) return false;
+    for (let i = 0; i < tokens.length && i < PRESETS.length; i++) {
+      const token = tokens[i];
+      if (!token) continue;
+      const preset = PRESETS[i];
+      const agentId = `tg-${preset.name.toLowerCase()}`;
+      const bot = new TelegramBot(token, { polling: true });
+      const ba = { bot, preset, agentId, chatIds: /* @__PURE__ */ new Set() };
+      botAgents.push(ba);
+      bot.on("polling_error", (err) => {
+        const code = err?.response?.statusCode ?? err?.code;
+        if (code === 409) {
+          console.warn(
+            `[Telegram] 409 Conflict for @${preset.name}: token is already used by another bot instance. Polling skipped for this token.`
+          );
+          bot.stopPolling();
+          return;
+        }
+        console.error(`[Telegram] Polling error for @${preset.name}:`, err.message ?? err);
+      });
+      commandHandler({
+        type: "CREATE_AGENT",
+        agentId,
+        name: preset.name,
+        role: preset.role,
+        palette: preset.palette,
+        personality: preset.personality
+      });
+      const botInfo = await bot.getMe();
+      console.log(`[Telegram] @${botInfo.username} \u2192 ${preset.name} (${preset.role})`);
+      bot.on("message", (msg) => {
+        if (!msg.text) return;
+        ba.chatIds.add(msg.chat.id);
+        const text = msg.text.trim();
+        if (text === "/yes") {
+          commandHandler({ type: "APPROVAL_DECISION", approvalId: "__all__", decision: "yes" });
+          return;
+        }
+        if (text === "/no") {
+          commandHandler({ type: "APPROVAL_DECISION", approvalId: "__all__", decision: "no" });
+          return;
+        }
+        if (text === "/cancel") {
+          commandHandler({ type: "CANCEL_TASK", agentId, taskId: "" });
+          bot.sendMessage(msg.chat.id, `\u{1F6D1} Cancelled ${preset.name}'s current task`);
+          return;
+        }
+        if (text === "/status") {
+          commandHandler({ type: "PING" });
+          return;
+        }
+        if (text.startsWith("/")) return;
+        const taskId = nanoid();
+        commandHandler({
+          type: "RUN_TASK",
+          agentId,
+          taskId,
+          prompt: text,
+          name: preset.name,
+          role: preset.role,
+          personality: preset.personality
+        });
+      });
+    }
+    console.log(`[Telegram] ${botAgents.length} bot(s) active`);
+    return botAgents.length > 0;
+  },
+  broadcast(event) {
+    for (const ba of botAgents) {
+      const text = formatEvent(event, ba.agentId);
+      if (!text) continue;
+      for (const chatId of ba.chatIds) {
+        ba.bot.sendMessage(chatId, text).catch((err) => {
+          console.error(`[Telegram] Send failed:`, err.message);
+        });
+      }
+    }
+  },
+  destroy() {
+    for (const ba of botAgents) {
+      ba.bot.stopPolling();
+    }
+    botAgents.length = 0;
+  }
+};
 
-// src/ai-backends.ts
+// src/setup.ts
+import { createInterface } from "readline";
+
+// src/backends.ts
 import { execSync } from "child_process";
 var backends = [
   {
     id: "claude",
     name: "Claude Code",
     command: "claude",
+    supportsStdin: true,
     buildArgs(prompt, opts) {
-      const args = ["-p", prompt, "--output-format", "text", "--dangerously-skip-permissions"];
-      if (opts.continue) args.push("--continue");
+      const args = ["-p", prompt, "--output-format", "stream-json", "--verbose", "--dangerously-skip-permissions"];
+      if (!opts.skipResume) {
+        if (opts.resumeSessionId) {
+          args.push("--resume", opts.resumeSessionId);
+        } else if (opts.continue) {
+          args.push("--continue");
+        }
+      }
+      if (opts.noTools) args.push("--tools", "");
+      if (opts.model) args.push("--model", opts.model);
       return args;
     },
-    deleteEnv: ["CLAUDECODE"]
+    deleteEnv: ["CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"]
   },
   {
     id: "codex",
@@ -4625,6 +4827,9 @@ var backendMap = new Map(backends.map((b) => [b.id, b]));
 function getBackend(id) {
   return backendMap.get(id);
 }
+function getAllBackends() {
+  return backends;
+}
 function detectBackends() {
   const detected = [];
   for (const backend of backends) {
@@ -4637,7 +4842,148 @@ function detectBackends() {
   return detected;
 }
 
-// src/agent-session.ts
+// src/setup.ts
+function ask(rl, question) {
+  return new Promise((resolve2) => {
+    const onClose = () => resolve2("");
+    rl.once("close", onClose);
+    rl.question(question, (answer) => {
+      rl.removeListener("close", onClose);
+      resolve2(answer.trim());
+    });
+  });
+}
+async function runSetup() {
+  console.log("[Setup] Detecting AI backends...");
+  const detected = detectBackends();
+  const detectedNames = detected.map((id) => getBackend(id)?.name ?? id).join(", ");
+  console.log(`[Setup] Found: ${detectedNames || "none"}`);
+  if (!process.stdin.isTTY) {
+    saveConfig({ detectedBackends: detected, defaultBackend: detected[0] ?? "claude", sandboxMode: "full" });
+    console.log("\u2713 Default config saved to ~/.bit-office/config.json");
+    console.log("  Run with --setup in a terminal to configure.\n");
+    return;
+  }
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  console.log("");
+  console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+  console.log("\u2551        Bit Office \u2014 First Setup       \u2551");
+  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  console.log("");
+  console.log("Press Enter to skip any step.\n");
+  console.log("\u2500\u2500 Remote Access (Ably) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("Enables access from outside your LAN.");
+  const ablyApiKey = await ask(rl, "Ably API Key (optional): ");
+  let defaultBackend = detected[0] ?? "claude";
+  if (detected.length > 1) {
+    console.log("\n\u2500\u2500 AI Backends \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log(`Detected: ${detectedNames}`);
+    const choices = detected.map((id, i) => `${i + 1}=${getBackend(id)?.name ?? id}`).join(", ");
+    const pick = await ask(rl, `Default backend (${choices}): `);
+    const idx = parseInt(pick, 10) - 1;
+    if (idx >= 0 && idx < detected.length) {
+      defaultBackend = detected[idx];
+    }
+  }
+  console.log("\n\u2500\u2500 Agent Permissions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log("1 = Full access (agents can access entire machine)");
+  console.log("2 = Sandbox (agents restricted to working directory)");
+  const sandboxPick = await ask(rl, "Permission mode (1/2, default=1): ");
+  const sandboxMode = sandboxPick === "2" ? "safe" : "full";
+  rl.close();
+  saveConfig({
+    ablyApiKey: ablyApiKey || void 0,
+    detectedBackends: detected,
+    defaultBackend,
+    sandboxMode
+  });
+  console.log("\n\u2713 Config saved to ~/.bit-office/config.json");
+  if (ablyApiKey) console.log("  \u2022 Ably: enabled");
+  console.log(`  \u2022 Default AI: ${getBackend(defaultBackend)?.name ?? defaultBackend}`);
+  console.log(`  \u2022 Permissions: ${sandboxMode === "full" ? "Full access" : "Sandbox"}`);
+  console.log("  \u2022 Run with --setup to reconfigure\n");
+}
+
+// ../../packages/orchestrator/src/orchestrator.ts
+import { EventEmitter } from "events";
+import { nanoid as nanoid4 } from "nanoid";
+
+// ../../packages/orchestrator/src/agent-session.ts
+import { spawn as spawn2, execSync as execSync2 } from "child_process";
+import path2 from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+
+// ../../packages/orchestrator/src/preview-server.ts
+import { spawn } from "child_process";
+import path from "path";
+var PREVIEW_PORT = 9100;
+var PreviewServer = class {
+  process = null;
+  currentDir = null;
+  /**
+   * Serve a directory on a fixed port. Kills any existing serve process first.
+   * Returns the preview URL for the given file.
+   */
+  serve(filePath) {
+    const dir = path.dirname(filePath);
+    const fileName = path.basename(filePath);
+    this.stop();
+    try {
+      this.process = spawn("npx", ["serve", dir, "-l", String(PREVIEW_PORT), "--no-clipboard"], {
+        stdio: "ignore",
+        detached: true
+      });
+      this.process.unref();
+      this.currentDir = dir;
+      const url = `http://localhost:${PREVIEW_PORT}/${fileName}`;
+      console.log(`[PreviewServer] Serving ${dir} on port ${PREVIEW_PORT}`);
+      return url;
+    } catch (e) {
+      console.log(`[PreviewServer] Failed to start: ${e}`);
+      return void 0;
+    }
+  }
+  /** Kill the current serve process */
+  stop() {
+    if (this.process) {
+      try {
+        this.process.kill("SIGTERM");
+      } catch {
+      }
+      this.process = null;
+      this.currentDir = null;
+      console.log(`[PreviewServer] Stopped`);
+    }
+  }
+};
+var previewServer = new PreviewServer();
+
+// ../../packages/orchestrator/src/agent-session.ts
+import { nanoid as nanoid2 } from "nanoid";
+var SESSION_FILE = path2.join(homedir2(), ".bit-office", "agent-sessions.json");
+function loadSessionMap() {
+  try {
+    if (existsSync2(SESSION_FILE)) return JSON.parse(readFileSync2(SESSION_FILE, "utf-8"));
+  } catch {
+  }
+  return {};
+}
+function saveSessionId(agentId, sessionId) {
+  const dir = path2.dirname(SESSION_FILE);
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+  const map = loadSessionMap();
+  if (sessionId) {
+    map[agentId] = sessionId;
+  } else {
+    delete map[agentId];
+  }
+  writeFileSync2(SESSION_FILE, JSON.stringify(map), "utf-8");
+}
 var AgentSession = class {
   agentId;
   name;
@@ -4647,6 +4993,8 @@ var AgentSession = class {
   palette;
   process = null;
   currentTaskId = null;
+  taskTimeout = null;
+  idleTimer = null;
   currentCwd = null;
   _status = "idle";
   get status() {
@@ -4654,36 +5002,90 @@ var AgentSession = class {
   }
   pendingApprovals = /* @__PURE__ */ new Map();
   workspace;
+  sandboxMode;
   stdoutBuffer = "";
   stderrBuffer = "";
-  hasHistory = false;
+  hasHistory;
+  sessionId;
+  taskQueue = [];
+  onEvent;
+  _renderPrompt;
+  timedOut = false;
+  _isTeamLead;
+  _lastResult = null;
+  /** Original user-facing task prompt (for leader state-summary mode) */
+  originalTask = null;
   onDelegation = null;
-  constructor(agentId, name, role, personality, workspace, resumeHistory, backendId) {
-    this.agentId = agentId;
-    this.name = name;
-    this.role = role;
-    this.personality = personality ?? "";
-    this.workspace = workspace ?? config.defaultWorkspace;
-    this.hasHistory = resumeHistory ?? false;
-    this.backend = getBackend(backendId ?? config.defaultBackend) ?? getBackend("claude");
-  }
-  async runTask(taskId, prompt, repoPath) {
+  onTaskComplete = null;
+  /** Whether the last failure was a timeout (not retryable) */
+  get wasTimeout() {
+    return this.timedOut;
+  }
+  get isTeamLead() {
+    return this._isTeamLead;
+  }
+  /** Short summary of last completed/failed task (for roster context) */
+  get lastResult() {
+    return this._lastResult;
+  }
+  _lastResultText = null;
+  set isTeamLead(v) {
+    this._isTeamLead = v;
+  }
+  /** Current working directory of the running task (used by worktree logic) */
+  get currentWorkingDir() {
+    return this.currentCwd;
+  }
+  /** Worktree path if task is running in one (set externally by orchestrator) */
+  worktreePath = null;
+  worktreeBranch = null;
+  teamId;
+  constructor(opts) {
+    this.agentId = opts.agentId;
+    this.name = opts.name;
+    this.role = opts.role;
+    this.personality = opts.personality ?? "";
+    this.workspace = opts.workspace;
+    this.sessionId = loadSessionMap()[opts.agentId] ?? null;
+    this.hasHistory = opts.resumeHistory ?? !!this.sessionId;
+    this.backend = opts.backend;
+    this.sandboxMode = opts.sandboxMode ?? "full";
+    this._isTeamLead = opts.isTeamLead ?? false;
+    this.teamId = opts.teamId;
+    this.onEvent = opts.onEvent;
+    this._renderPrompt = opts.renderPrompt;
+  }
+  async runTask(taskId, prompt, repoPath, teamContext, isUserInitiated = false) {
+    if (this._userCancelled && !isUserInitiated) {
+      console.log(`[Agent ${this.name}] Ignoring internal task restart \u2014 agent was cancelled by user`);
+      return;
+    }
+    if (isUserInitiated) {
+      this._userCancelled = false;
+    }
     if (this.process) {
-      publishEvent({
-        type: "TASK_FAILED",
+      const position = this.taskQueue.length + 1;
+      this.taskQueue.push({ taskId, prompt, repoPath, teamContext });
+      this.onEvent({
+        type: "task:queued",
         agentId: this.agentId,
         taskId,
-        error: "Agent is working hard, please wait..."
+        prompt,
+        position
       });
       return;
     }
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
     this.currentTaskId = taskId;
     const cwd = repoPath ?? this.workspace;
     this.currentCwd = cwd;
     this.stdoutBuffer = "";
     this.stderrBuffer = "";
-    publishEvent({
-      type: "TASK_STARTED",
+    this.onEvent({
+      type: "task:started",
       agentId: this.agentId,
       taskId,
       prompt
@@ -4694,129 +5096,422 @@ var AgentSession = class {
       for (const key of this.backend.deleteEnv ?? []) {
         delete cleanEnv[key];
       }
-      const personalityClause = this.personality ? `${this.personality}
-
-` : "";
-      const delegationHint = "To delegate a task to another agent, output on its own line: @AgentName: <task description>\n\n";
-      const identityPrompt = `Your name is ${this.name}, your role is ${this.role}. ${personalityClause}${delegationHint}${prompt}`;
-      const fullAccess = config.sandboxMode === "full";
-      const args = this.backend.buildArgs(identityPrompt, { continue: this.hasHistory, fullAccess });
-      this.process = spawn(this.backend.command, args, {
+      const templateVars = {
+        name: this.name,
+        role: this._isTeamLead ? "Team Lead" : this.role,
+        personality: this.personality ? `${this.personality}` : "",
+        teamRoster: teamContext ?? "",
+        originalTask: this._isTeamLead ? this.originalTask ?? prompt : "",
+        prompt
+      };
+      let fullPrompt;
+      if (this._isTeamLead) {
+        fullPrompt = this._renderPrompt(this.hasHistory ? "leader-continue" : "leader-initial", templateVars);
+      } else {
+        fullPrompt = this._renderPrompt(this.hasHistory ? "worker-continue" : "worker-initial", templateVars);
+      }
+      const fullAccess = this.sandboxMode === "full";
+      const verbose = !!process.env.DEBUG;
+      const args = this.backend.buildArgs(fullPrompt, {
+        continue: this.hasHistory,
+        resumeSessionId: this.sessionId ?? void 0,
+        fullAccess,
+        noTools: this._isTeamLead,
+        model: this._isTeamLead ? "sonnet" : void 0,
+        verbose,
+        skipResume: this._isTeamLead && this.hasHistory
+      });
+      try {
+        const whichPath = execSync2(`which ${this.backend.command}`, { env: cleanEnv, encoding: "utf-8", timeout: 3e3 }).trim();
+        console.log(`[Agent ${this.name}] Binary: ${whichPath}, CLAUDECODE=${cleanEnv.CLAUDECODE ?? "unset"}, ENTRYPOINT=${cleanEnv.CLAUDE_CODE_ENTRYPOINT ?? "unset"}`);
+      } catch {
+      }
+      console.log(`[Agent ${this.name}] Spawning: ${this.backend.command} ${args.map((a) => a.length > 80 ? a.slice(0, 80) + "..." : a).join(" ")}`);
+      this.process = spawn2(this.backend.command, args, {
         cwd,
         env: cleanEnv,
-        stdio: ["ignore", "pipe", "pipe"]
+        stdio: ["ignore", "pipe", "pipe"],
+        detached: true
       });
-      const DELEGATION_RE = /^@(\w+):\s*(.+)$/;
-      this.process.stdout?.on("data", (data) => {
-        const chunk = data.toString();
-        this.stdoutBuffer += chunk;
-        const lines = chunk.split("\n").filter((l) => l.trim());
+      this.timedOut = false;
+      const TASK_TIMEOUT_MS = this._isTeamLead ? 3 * 60 * 1e3 : 8 * 60 * 1e3;
+      this.taskTimeout = setTimeout(() => {
+        if (this.process?.pid) {
+          console.log(`[Agent ${this.agentId}] Task timed out after ${TASK_TIMEOUT_MS / 1e3}s, killing`);
+          this.timedOut = true;
+          try {
+            process.kill(-this.process.pid, "SIGKILL");
+          } catch {
+            this.process.kill("SIGKILL");
+          }
+        }
+      }, TASK_TIMEOUT_MS);
+      const DELEGATION_RE = /^\s*(?:[-*>]\s*)?(?:\*\*)?@(\w+)(?:\*\*)?:\s*(.+)$/;
+      const isSystemNoise = (line) => {
+        const t = line.trim().toLowerCase();
+        if (!t) return true;
+        if (t.includes("mcp") && (t.startsWith("[") || t.includes("server") || t.includes("connect") || t.includes("tool"))) return true;
+        if (/^\s*>?\s*(fetching|loaded|reading|writing|searching|running|executing|checking)\s/i.test(line)) return true;
+        if (/^[\s⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏✓✗•·…\-]+$/.test(line.trim())) return true;
+        if (/^\s*[\w./\\-]+\.(ts|tsx|js|jsx|json|md|css|py)\s*$/.test(line)) return true;
+        return false;
+      };
+      const handleTextLine = (text) => {
+        const lines = text.split("\n").filter((l) => l.trim());
+        const visibleLines = [];
         for (const line of lines) {
-          const match = line.match(DELEGATION_RE);
+          const trimmed = line.trim();
+          console.log(`[Agent ${this.name}] ${trimmed.slice(0, 200)}`);
+          const match = trimmed.match(DELEGATION_RE);
           if (match && this.onDelegation) {
             const [, targetName, delegatedPrompt] = match;
-            this.onDelegation(this.agentId, targetName, delegatedPrompt);
+            console.log(`[Delegation detected] ${this.name} -> @${targetName}: ${delegatedPrompt.slice(0, 60)}`);
+            this.onDelegation(this.agentId, targetName, delegatedPrompt.replace(/\*\*$/, "").trim());
+          }
+          if (!isSystemNoise(line)) {
+            visibleLines.push(trimmed);
           }
         }
-        if (lines.length > 0) {
-          publishEvent({
-            type: "LOG_APPEND",
+        if (visibleLines.length > 0) {
+          this.onEvent({
+            type: "log:append",
             agentId: this.agentId,
             taskId,
             stream: "stdout",
-            chunk: lines[lines.length - 1]
+            chunk: visibleLines.slice(-3).join("\n")
           });
         }
+      };
+      let jsonLineBuf = "";
+      let stdoutChunkCount = 0;
+      let seenFirstJson = false;
+      this.process.stdout?.on("data", (data) => {
+        const raw = data.toString();
+        stdoutChunkCount++;
+        if (stdoutChunkCount <= 3) {
+          console.log(`[Agent ${this.name} raw-stdout #${stdoutChunkCount}] ${raw.slice(0, 150)}`);
+        }
+        jsonLineBuf += raw;
+        let nlIdx;
+        while ((nlIdx = jsonLineBuf.indexOf("\n")) !== -1) {
+          const line = jsonLineBuf.slice(0, nlIdx).trim();
+          jsonLineBuf = jsonLineBuf.slice(nlIdx + 1);
+          if (!line) continue;
+          if (line.startsWith("{")) {
+            try {
+              const msg = JSON.parse(line);
+              seenFirstJson = true;
+              if (msg.type === "system" && msg.session_id) {
+                this.sessionId = msg.session_id;
+                console.log(`[Agent ${this.name}] Session ID: ${msg.session_id}`);
+              }
+              if (msg.type === "assistant" && msg.message?.content) {
+                for (const block of msg.message.content) {
+                  if (block.type === "text" && block.text) {
+                    this.stdoutBuffer += block.text + "\n";
+                    handleTextLine(block.text);
+                  }
+                  if (block.type === "thinking" && block.thinking) {
+                    console.log(`[Agent ${this.name} thinking] ${block.thinking.slice(0, 120)}...`);
+                  }
+                }
+              } else if (msg.type === "result" && msg.result) {
+                if (!this.stdoutBuffer) {
+                  this.stdoutBuffer = msg.result;
+                  handleTextLine(msg.result);
+                }
+                this._lastResultText = msg.result;
+              }
+              continue;
+            } catch {
+            }
+          }
+          if (!seenFirstJson) {
+            seenFirstJson = true;
+          }
+          this.stdoutBuffer += line + "\n";
+          handleTextLine(line);
+        }
       });
       this.process.stderr?.on("data", (data) => {
         const chunk = data.toString();
         this.stderrBuffer += chunk;
-        const lines = chunk.split("\n").filter((l) => l.trim());
-        if (lines.length > 0) {
-          publishEvent({
-            type: "LOG_APPEND",
-            agentId: this.agentId,
-            taskId,
-            stream: "stderr",
-            chunk: lines[lines.length - 1]
-          });
+        for (const line of chunk.split("\n")) {
+          if (line.trim()) console.log(`[Agent ${this.name} stderr] ${line.slice(0, 200)}`);
         }
       });
       this.process.on("close", (code) => {
         this.process = null;
+        if (this.taskTimeout) {
+          clearTimeout(this.taskTimeout);
+          this.taskTimeout = null;
+        }
+        const remaining = jsonLineBuf.trim();
+        if (remaining) {
+          jsonLineBuf = "";
+          for (const chunk of remaining.split("\n")) {
+            const line = chunk.trim();
+            if (!line) continue;
+            if (line.startsWith("{")) {
+              try {
+                const msg = JSON.parse(line);
+                if (msg.type === "assistant" && msg.message?.content) {
+                  for (const block of msg.message.content) {
+                    if (block.type === "text" && block.text) {
+                      this.stdoutBuffer += block.text + "\n";
+                      handleTextLine(block.text);
+                    }
+                  }
+                } else if (msg.type === "result" && msg.result) {
+                  this._lastResultText = msg.result;
+                  if (!this.stdoutBuffer) {
+                    this.stdoutBuffer = msg.result;
+                    handleTextLine(msg.result);
+                  }
+                }
+              } catch {
+              }
+            } else {
+              seenFirstJson = true;
+              this.stdoutBuffer += line + "\n";
+              handleTextLine(line);
+            }
+          }
+        }
         const completedTaskId = this.currentTaskId ?? taskId;
         this.currentTaskId = null;
         const wasCancelled = this.cancelled;
         this.cancelled = false;
-        console.log(`[Agent ${this.agentId}] ${this.backend.name} exited: code=${code}, cancelled=${wasCancelled}`);
+        console.log(`[Agent ${this.agentId}] ${this.backend.name} exited: code=${code}, cancelled=${wasCancelled}, stdout=${this.stdoutBuffer.length}ch`);
         try {
           if (wasCancelled) {
-            this.setStatus("idle");
+            this.dequeueNext();
+            return;
           } else if (code === 0) {
             this.hasHistory = true;
-            const summary = this.stdoutBuffer.slice(0, 1e3) || "Task completed";
+            saveSessionId(this.agentId, this.sessionId);
+            const { summary, fullOutput, changedFiles } = this.extractResult();
+            const { previewUrl, previewPath } = this._isTeamLead ? { previewUrl: void 0, previewPath: void 0 } : this.detectPreview();
+            this._lastResult = `done: ${summary.slice(0, 120)}`;
             this.setStatus("done");
-            publishEvent({
-              type: "TASK_DONE",
+            this.onEvent({
+              type: "task:done",
               agentId: this.agentId,
               taskId: completedTaskId,
-              result: { summary, changedFiles: [], diffStat: "", testResult: "unknown" }
+              result: { summary, fullOutput, changedFiles, diffStat: "", testResult: "unknown", previewUrl, previewPath }
             });
-            setTimeout(() => this.setStatus("idle"), 5e3);
+            this.onTaskComplete?.(this.agentId, completedTaskId, summary, true);
+            this.idleTimer = setTimeout(() => {
+              this.idleTimer = null;
+              this.setStatus("idle");
+            }, 5e3);
           } else {
+            const errorMsg = this.stdoutBuffer.slice(0, 300) || this.stderrBuffer.slice(-300) || `Process exited with code ${code}`;
+            this._lastResult = `failed: ${errorMsg.slice(0, 120)}`;
             this.setStatus("error");
-            publishEvent({
-              type: "TASK_FAILED",
+            this.onEvent({
+              type: "task:failed",
               agentId: this.agentId,
               taskId: completedTaskId,
-              error: this.stdoutBuffer.slice(0, 300) || this.stderrBuffer.slice(-300) || `Process exited with code ${code}`
+              error: errorMsg
             });
-            setTimeout(() => this.setStatus("idle"), 3e3);
+            this.onTaskComplete?.(this.agentId, completedTaskId, errorMsg, false);
+            this.idleTimer = setTimeout(() => {
+              this.idleTimer = null;
+              this.setStatus("idle");
+            }, 3e3);
           }
+          this.dequeueNext();
         } catch (err) {
           console.error(`[Agent ${this.agentId}] Error in close handler:`, err);
           this.setStatus("idle");
+          this.dequeueNext();
         }
       });
       this.process.on("error", (err) => {
         this.process = null;
         this.currentTaskId = null;
         this.setStatus("error");
-        publishEvent({
-          type: "TASK_FAILED",
+        this.onEvent({
+          type: "task:failed",
           agentId: this.agentId,
           taskId,
           error: err.message
         });
-        setTimeout(() => this.setStatus("idle"), 3e3);
+        this.idleTimer = setTimeout(() => {
+          this.idleTimer = null;
+          this.setStatus("idle");
+        }, 3e3);
       });
     } catch (err) {
       this.setStatus("error");
-      publishEvent({
-        type: "TASK_FAILED",
+      this.onEvent({
+        type: "task:failed",
         agentId: this.agentId,
         taskId,
         error: err.message
       });
     }
   }
+  /**
+   * Send a message to the agent's stdin.
+   * NOTE: Currently a no-op because stdin is set to "ignore" (pipe causes Claude Code to hang).
+   * Future: use --input-format stream-json for bidirectional communication.
+   */
+  sendMessage(_message) {
+    return false;
+  }
+  /**
+   * Detect preview URL/path from agent output.
+   * Called directly for workers; called by orchestrator for leader's final result.
+   */
+  detectPreview() {
+    const previewMatch = this.stdoutBuffer.match(/PREVIEW:\s*(https?:\/\/[^\s*)\]>]+)/i);
+    let previewUrl = previewMatch?.[1]?.replace(/[*)\]>]+$/, "");
+    let previewPath;
+    if (!previewUrl) {
+      const localhostMatch = this.stdoutBuffer.match(/https?:\/\/localhost[:\d]*/);
+      previewUrl = localhostMatch?.[0];
+    }
+    if (!previewUrl) {
+      const fileMatch = this.stdoutBuffer.match(/(?:open\s+)?((?:\/[\w./_-]+|[\w./_-]+)\.html?)\b/i);
+      if (fileMatch) {
+        previewPath = path2.isAbsolute(fileMatch[1]) ? fileMatch[1] : path2.join(this.currentCwd ?? this.workspace, fileMatch[1]);
+        previewUrl = previewServer.serve(previewPath);
+      }
+    }
+    if (!previewUrl) {
+      const { changedFiles } = this.extractResult();
+      const htmlFile = changedFiles.find((f) => /\.html?$/i.test(f));
+      if (htmlFile) {
+        previewPath = path2.isAbsolute(htmlFile) ? htmlFile : path2.join(this.currentCwd ?? this.workspace, htmlFile);
+        previewUrl = previewServer.serve(previewPath);
+      }
+    }
+    return { previewUrl, previewPath };
+  }
+  /**
+   * Parse stdoutBuffer for structured result (SUMMARY/STATUS/FILES_CHANGED).
+   * Falls back to a cleaned-up excerpt of the raw output.
+   */
+  extractResult() {
+    const raw = this.stdoutBuffer || this._lastResultText || "";
+    const fullOutput = raw.slice(0, 3e3);
+    const summaryMatch = raw.match(/SUMMARY:\s*(.+)/i);
+    const filesMatch = raw.match(/FILES_CHANGED:\s*(.+)/i);
+    const changedFiles = [];
+    if (filesMatch) {
+      const fileList = filesMatch[1].trim();
+      for (const f of fileList.split(/[,\n]+/)) {
+        const cleaned = f.trim().replace(/^[-*]\s*/, "");
+        if (cleaned) changedFiles.push(cleaned);
+      }
+    }
+    if (summaryMatch) {
+      return { summary: summaryMatch[1].trim(), fullOutput, changedFiles };
+    }
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const delegationRe = /^@(\w+):/;
+    const noisePatterns = [
+      /^STATUS:\s/i,
+      /^FILES_CHANGED:\s/i,
+      /^SUMMARY:\s/i,
+      /^\[Assigned by /,
+      /^mcp\s/i,
+      /^╔|^║|^╚/,
+      /^\s*[-*]{3,}\s*$/
+    ];
+    const delegationTargets = [];
+    const meaningful = [];
+    for (const l of lines) {
+      const trimmed = l.trim();
+      const dm = trimmed.match(delegationRe);
+      if (dm) {
+        delegationTargets.push(dm[1]);
+      } else if (!noisePatterns.some((p) => p.test(trimmed))) {
+        meaningful.push(l);
+      }
+    }
+    if (meaningful.length === 0 && delegationTargets.length > 0) {
+      return { summary: `Delegated tasks to ${delegationTargets.join(", ")}`, fullOutput, changedFiles };
+    }
+    const lastChunk = meaningful.slice(-5).join("\n").trim();
+    const summary = lastChunk.slice(0, 500) || "Task completed";
+    return { summary, fullOutput, changedFiles };
+  }
+  dequeueNext() {
+    if (this.taskQueue.length === 0) return;
+    const next = this.taskQueue.shift();
+    setTimeout(() => {
+      this.runTask(next.taskId, next.prompt, next.repoPath, next.teamContext);
+    }, 100);
+  }
   cancelled = false;
+  /** Set by cancelTask(); prevents flushResults / delegation from auto-restarting this agent. */
+  _userCancelled = false;
   cancelTask() {
-    if (this.process) {
+    this.taskQueue = [];
+    this._userCancelled = true;
+    if (this.taskTimeout) {
+      clearTimeout(this.taskTimeout);
+      this.taskTimeout = null;
+    }
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    const cancelledTaskId = this.currentTaskId ?? "";
+    if (this.process && this.process.pid) {
       this.cancelled = true;
-      this.process.kill("SIGTERM");
+      this.hasHistory = true;
+      saveSessionId(this.agentId, this.sessionId);
+      this.onTaskComplete?.(this.agentId, cancelledTaskId, "Task cancelled by user", false);
+      const pgid = this.process.pid;
+      try {
+        process.kill(-pgid, "SIGKILL");
+      } catch {
+        try {
+          this.process.kill("SIGKILL");
+        } catch {
+        }
+      }
     }
+    this._lastResult = "cancelled: Task cancelled by user";
+    this.setStatus("error");
+    this.onEvent({
+      type: "task:failed",
+      agentId: this.agentId,
+      taskId: cancelledTaskId,
+      error: "Task cancelled by user"
+    });
+    this.idleTimer = setTimeout(() => {
+      this.idleTimer = null;
+      this.setStatus("idle");
+    }, 3e3);
   }
   destroy() {
-    if (this.process) {
-      this.process.kill("SIGTERM");
+    if (this.taskTimeout) {
+      clearTimeout(this.taskTimeout);
+      this.taskTimeout = null;
+    }
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (this.process?.pid) {
+      try {
+        process.kill(-this.process.pid, "SIGTERM");
+      } catch {
+        this.process.kill("SIGTERM");
+      }
       this.process = null;
     }
     this.pendingApprovals.clear();
+    saveSessionId(this.agentId, null);
   }
   resolveApproval(approvalId, decision) {
     if (approvalId === "__all__") {
-      for (const [id, pending2] of this.pendingApprovals) {
+      for (const [, pending2] of this.pendingApprovals) {
         pending2.resolve(decision);
       }
       this.pendingApprovals.clear();
@@ -4829,11 +5524,11 @@ var AgentSession = class {
     }
   }
   async requestApproval(title, summary, riskLevel) {
-    const approvalId = nanoid();
+    const approvalId = nanoid2();
     const taskId = this.currentTaskId ?? "unknown";
     this.setStatus("waiting_approval");
-    publishEvent({
-      type: "APPROVAL_NEEDED",
+    this.onEvent({
+      type: "approval:needed",
       approvalId,
       agentId: this.agentId,
       taskId,
@@ -4845,50 +5540,54 @@ var AgentSession = class {
       this.pendingApprovals.set(approvalId, { approvalId, resolve: resolve2 });
     });
   }
-  generateResultSummary(cwd) {
-    const summary = this.stdoutBuffer.slice(0, 1e3) || "Task completed";
-    let changedFiles = [];
-    let diffStat = "";
-    try {
-      const nameOnly = execSync2("git diff --name-only HEAD~1 2>/dev/null || git diff --name-only", { cwd, encoding: "utf-8", timeout: 3e3 }).trim();
-      changedFiles = nameOnly ? nameOnly.split("\n") : [];
-    } catch {
-    }
-    if (changedFiles.length > 0) {
-      try {
-        diffStat = execSync2("git diff --stat HEAD~1 2>/dev/null || git diff --stat", { cwd, encoding: "utf-8", timeout: 3e3 }).trim();
-      } catch {
-      }
-    }
-    return {
-      summary,
-      changedFiles,
-      diffStat,
-      testResult: "unknown"
-    };
-  }
   setStatus(status) {
+    if (status === "idle" && this.process) return;
     this._status = status;
-    publishEvent({
-      type: "AGENT_STATUS",
+    this.onEvent({
+      type: "agent:status",
       agentId: this.agentId,
       status
     });
   }
 };
 
-// src/agent-manager.ts
+// ../../packages/orchestrator/src/agent-manager.ts
 var AgentManager = class {
   agents = /* @__PURE__ */ new Map();
-  create(agentId, name, role, personality, workspace, resumeHistory, backendId, palette) {
-    const existing = this.agents.get(agentId);
+  _teamLeadId = null;
+  setTeamLead(id) {
+    this._teamLeadId = id;
+  }
+  getTeamLead() {
+    return this._teamLeadId;
+  }
+  isTeamLead(id) {
+    return this._teamLeadId === id;
+  }
+  getTeamRoster() {
+    const lines = [];
+    for (const session of this.agents.values()) {
+      const lead = this.isTeamLead(session.agentId) ? " (Team Lead)" : "";
+      const result = session.lastResult ? ` \u2014 ${session.lastResult}` : "";
+      lines.push(`- ${session.name} (${session.role}) [${session.status}]${lead}${result}`);
+    }
+    return lines.join("\n");
+  }
+  getTeamMembers() {
+    return Array.from(this.agents.values()).map((s) => ({
+      name: s.name,
+      role: s.role,
+      status: s.status,
+      isLead: this.isTeamLead(s.agentId),
+      lastResult: s.lastResult
+    }));
+  }
+  add(session) {
+    const existing = this.agents.get(session.agentId);
     if (existing) {
       existing.destroy();
     }
-    const session = new AgentSession(agentId, name, role, personality, workspace, resumeHistory, backendId);
-    session.palette = palette;
-    this.agents.set(agentId, session);
-    return session;
+    this.agents.set(session.agentId, session);
   }
   delete(agentId) {
     const session = this.agents.get(agentId);
@@ -4912,226 +5611,1048 @@ var AgentManager = class {
     return void 0;
   }
 };
-var agentManager = new AgentManager();
 
-// src/telegram-channel.ts
-import { nanoid as nanoid2 } from "nanoid";
-var PRESETS = [
-  { name: "Alex", role: "Frontend Dev", palette: 0, personality: "You speak in a friendly, casual, encouraging, and natural tone." },
-  { name: "Mia", role: "Backend Dev", palette: 1, personality: "You speak formally, professionally, in an organized and concise manner." },
-  { name: "Leo", role: "Fullstack Dev", palette: 2, personality: "You are aggressive, action-first, always pursuing speed and efficiency." },
-  { name: "Sophie", role: "Code Reviewer", palette: 3, personality: "You teach patiently, explain the reasoning, and guide like a mentor." },
-  { name: "Yuki", role: "QA / Tester", palette: 4, personality: "You are extremely concise, no fluff, straight to the result." },
-  { name: "Marcus", role: "Architect", palette: 5, personality: "You speak formally, professionally, in an organized and concise manner." }
-];
-var botAgents = [];
-function formatEvent(event, agentId) {
-  if (event.type === "TASK_STARTED" && event.agentId === agentId) {
-    return `\u{1F527} Working on it...`;
+// ../../packages/orchestrator/src/delegation.ts
+import { nanoid as nanoid3 } from "nanoid";
+var MAX_DELEGATION_DEPTH = 5;
+var MAX_TOTAL_DELEGATIONS = 20;
+var DELEGATION_BUDGET_ROUNDS = 5;
+var HARD_CEILING_ROUNDS = 10;
+var RESULT_BATCH_WINDOW_MS = 2e4;
+var DelegationRouter = class {
+  /** taskId → fromAgentId */
+  delegationOrigin = /* @__PURE__ */ new Map();
+  /** taskId → delegation depth (how many hops from original user task) */
+  delegationDepth = /* @__PURE__ */ new Map();
+  /** agentId → taskId of the delegated task currently assigned TO this agent */
+  assignedTask = /* @__PURE__ */ new Map();
+  /** Total delegations in current team session (reset on clearAll) */
+  totalDelegations = 0;
+  /** How many times the leader has been invoked to process results */
+  leaderRounds = 0;
+  /** When true, all new delegations and result forwarding are blocked */
+  stopped = false;
+  /** TaskIds created by flushResults — only these can produce a final result */
+  resultTaskIds = /* @__PURE__ */ new Set();
+  /** Tracks the totalDelegations count when a resultTask started, so we can detect if new delegations were created */
+  delegationsAtResultStart = /* @__PURE__ */ new Map();
+  /** Batch result forwarding: originAgentId → pending results + timer */
+  pendingResults = /* @__PURE__ */ new Map();
+  agentManager;
+  promptEngine;
+  emitEvent;
+  constructor(agentManager, promptEngine, emitEvent) {
+    this.agentManager = agentManager;
+    this.promptEngine = promptEngine;
+    this.emitEvent = emitEvent;
   }
-  if (event.type === "TASK_DONE" && event.agentId === agentId) {
-    const r = event.result;
-    let msg = `\u2705 Task completed
+  /**
+   * Wire delegation and result forwarding callbacks onto a session.
+   */
+  wireAgent(session) {
+    this.wireDelegation(session);
+    this.wireResultForwarding(session);
+  }
+  /**
+   * Check if a taskId was delegated (has an origin).
+   */
+  isDelegated(taskId) {
+    return this.delegationOrigin.has(taskId);
+  }
+  /**
+   * True if this taskId was created by flushResults (leader processing worker results).
+   * Only result-processing tasks are eligible to be marked as isFinalResult.
+   */
+  isResultTask(taskId) {
+    return this.resultTaskIds.has(taskId);
+  }
+  /**
+   * True when the delegation budget is exhausted — leader should finalize even
+   * if the current task is not a "resultTask" (safety net for convergence).
+   */
+  isBudgetExhausted() {
+    return this.leaderRounds >= DELEGATION_BUDGET_ROUNDS;
+  }
+  /**
+   * True if the given resultTask completed WITHOUT creating any new delegations.
+   * This means the leader decided to summarize/finish rather than delegate more work.
+   */
+  resultTaskDidNotDelegate(taskId) {
+    const startCount = this.delegationsAtResultStart.get(taskId);
+    if (startCount === void 0) return false;
+    return this.totalDelegations === startCount;
+  }
+  /**
+   * Check if there are any pending delegated tasks originating from a given agent.
+   */
+  hasPendingFrom(agentId) {
+    for (const origin of this.delegationOrigin.values()) {
+      if (origin === agentId) return true;
+    }
+    return false;
+  }
+  /**
+   * Remove all delegation tracking for a specific agent (on fire/cancel).
+   */
+  clearAgent(agentId) {
+    for (const [taskId, origin] of this.delegationOrigin) {
+      if (origin === agentId) {
+        this.delegationOrigin.delete(taskId);
+        this.delegationDepth.delete(taskId);
+      }
+    }
+  }
+  /**
+   * Block all future delegations and result forwarding. Call before cancelling tasks.
+   */
+  stop() {
+    this.stopped = true;
+    for (const pending of this.pendingResults.values()) {
+      clearTimeout(pending.timer);
+    }
+    this.pendingResults.clear();
+  }
+  /**
+   * Reset all delegation state (on new team task).
+   */
+  clearAll() {
+    this.delegationOrigin.clear();
+    this.delegationDepth.clear();
+    this.assignedTask.clear();
+    this.resultTaskIds.clear();
+    this.delegationsAtResultStart.clear();
+    this.totalDelegations = 0;
+    this.leaderRounds = 0;
+    this.stopped = false;
+    for (const pending of this.pendingResults.values()) {
+      clearTimeout(pending.timer);
+    }
+    this.pendingResults.clear();
+  }
+  wireDelegation(session) {
+    session.onDelegation = (fromAgentId, targetName, prompt) => {
+      if (this.stopped) return;
+      if (this.leaderRounds >= DELEGATION_BUDGET_ROUNDS) {
+        console.log(`[Delegation] BLOCKED: delegation budget exhausted (round ${this.leaderRounds}/${DELEGATION_BUDGET_ROUNDS})`);
+        return;
+      }
+      const target = this.agentManager.findByName(targetName);
+      if (!target) {
+        console.log(`[Delegation] Target agent "${targetName}" not found, ignoring`);
+        return;
+      }
+      if (this.totalDelegations >= MAX_TOTAL_DELEGATIONS) {
+        console.log(`[Delegation] BLOCKED: total delegation limit (${MAX_TOTAL_DELEGATIONS}) reached`);
+        this.emitEvent({
+          type: "team:chat",
+          fromAgentId,
+          message: `Delegation blocked: total limit of ${MAX_TOTAL_DELEGATIONS} delegations reached. Summarize current results for the user.`,
+          messageType: "status",
+          timestamp: Date.now()
+        });
+        return;
+      }
+      const myTaskId = this.assignedTask.get(fromAgentId);
+      const parentDepth = myTaskId ? this.delegationDepth.get(myTaskId) ?? 0 : 0;
+      const newDepth = parentDepth + 1;
+      if (newDepth > MAX_DELEGATION_DEPTH) {
+        console.log(`[Delegation] BLOCKED: depth ${newDepth} exceeds max ${MAX_DELEGATION_DEPTH}`);
+        this.emitEvent({
+          type: "team:chat",
+          fromAgentId,
+          message: `Delegation blocked: chain depth (${newDepth}) exceeds limit. Complete current work directly.`,
+          messageType: "status",
+          timestamp: Date.now()
+        });
+        return;
+      }
+      const taskId = nanoid3();
+      this.delegationOrigin.set(taskId, fromAgentId);
+      this.delegationDepth.set(taskId, newDepth);
+      this.totalDelegations++;
+      const fromSession = this.agentManager.get(fromAgentId);
+      const fromName = fromSession?.name ?? fromAgentId;
+      const fromRole = fromSession?.role ?? "Team Lead";
+      const fullPrompt = this.promptEngine.render("delegation-prefix", { fromName, fromRole, prompt });
+      console.log(`[Delegation] ${fromAgentId} -> ${target.agentId} (${targetName}) depth=${newDepth} total=${this.totalDelegations}: ${prompt.slice(0, 80)}`);
+      this.emitEvent({
+        type: "task:delegated",
+        fromAgentId,
+        toAgentId: target.agentId,
+        taskId,
+        prompt
+      });
+      this.emitEvent({
+        type: "team:chat",
+        fromAgentId,
+        toAgentId: target.agentId,
+        message: prompt,
+        messageType: "delegation",
+        taskId,
+        timestamp: Date.now()
+      });
+      this.assignedTask.set(target.agentId, taskId);
+      target.runTask(taskId, fullPrompt);
+    };
+  }
+  wireResultForwarding(session) {
+    session.onTaskComplete = (agentId, taskId, summary, success) => {
+      if (this.stopped) return;
+      const originAgentId = this.delegationOrigin.get(taskId);
+      if (!originAgentId) return;
+      this.delegationOrigin.delete(taskId);
+      this.delegationDepth.delete(taskId);
+      if (this.assignedTask.get(agentId) === taskId) {
+        this.assignedTask.delete(agentId);
+      }
+      const originSession = this.agentManager.get(originAgentId);
+      if (!originSession) return;
+      const fromSession = this.agentManager.get(agentId);
+      const fromName = fromSession?.name ?? agentId;
+      const statusWord = success ? "completed successfully" : "failed";
+      console.log(`[ResultForward] ${agentId} -> ${originAgentId}: ${summary.slice(0, 80)} (success=${success})`);
+      this.emitEvent({
+        type: "task:result-returned",
+        fromAgentId: agentId,
+        toAgentId: originAgentId,
+        taskId,
+        summary,
+        success
+      });
+      this.emitEvent({
+        type: "team:chat",
+        fromAgentId: agentId,
+        toAgentId: originAgentId,
+        message: summary.slice(0, 400),
+        messageType: "result",
+        taskId,
+        timestamp: Date.now()
+      });
+      this.enqueueResult(originAgentId, { fromName, statusWord, summary: summary.slice(0, 400) });
+    };
+  }
+  /**
+   * Queue a result for batched forwarding to the origin agent.
+   * Flush only when ALL delegated tasks from this origin have returned.
+   * The timer is a safety net — if a worker somehow disappears without returning,
+   * we don't want the leader to wait forever.
+   */
+  enqueueResult(originAgentId, result) {
+    let pending = this.pendingResults.get(originAgentId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      pending.results.push(result);
+    } else {
+      pending = { results: [result], timer: null };
+      this.pendingResults.set(originAgentId, pending);
+    }
+    if (!this.hasPendingFrom(originAgentId)) {
+      console.log(`[ResultBatch] All delegated tasks returned for ${originAgentId}, flushing ${pending.results.length} result(s)`);
+      this.flushResults(originAgentId);
+      return;
+    }
+    console.log(`[ResultBatch] ${originAgentId} still has pending delegations, waiting (safety timeout: ${RESULT_BATCH_WINDOW_MS / 1e3}s)`);
+    pending.timer = setTimeout(() => {
+      console.log(`[ResultBatch] Safety timeout reached for ${originAgentId}, flushing ${pending.results.length} partial result(s)`);
+      this.flushResults(originAgentId);
+    }, RESULT_BATCH_WINDOW_MS);
+  }
+  /** Flush all pending results for an origin agent as a single leader prompt. */
+  flushResults(originAgentId) {
+    if (this.stopped) return;
+    const pending = this.pendingResults.get(originAgentId);
+    if (!pending || pending.results.length === 0) return;
+    this.pendingResults.delete(originAgentId);
+    clearTimeout(pending.timer);
+    const originSession = this.agentManager.get(originAgentId);
+    if (!originSession) return;
+    this.leaderRounds++;
+    if (this.leaderRounds > HARD_CEILING_ROUNDS) {
+      console.log(`[ResultBatch] Hard ceiling reached (${HARD_CEILING_ROUNDS} rounds). Force-completing.`);
+      const resultLines2 = pending.results.map(
+        (r) => `- ${r.fromName} (${r.statusWord}): ${r.summary}`
+      ).join("\n");
+      this.emitEvent({
+        type: "team:chat",
+        fromAgentId: originAgentId,
+        message: `Team work auto-completed after ${HARD_CEILING_ROUNDS} rounds.`,
+        messageType: "status",
+        timestamp: Date.now()
+      });
+      this.emitEvent({
+        type: "task:done",
+        agentId: originAgentId,
+        taskId: `auto-complete-${Date.now()}`,
+        result: {
+          summary: `Auto-completed after ${HARD_CEILING_ROUNDS} rounds.
+${resultLines2}`,
+          changedFiles: [],
+          diffStat: "",
+          testResult: "unknown"
+        },
+        isFinalResult: true
+      });
+      return;
+    }
+    let roundInfo;
+    const budgetExhausted = this.leaderRounds >= DELEGATION_BUDGET_ROUNDS;
+    if (budgetExhausted) {
+      roundInfo = `DELEGATION BUDGET REACHED (round ${this.leaderRounds}). No more delegations will be accepted. You MUST summarize the current results and report to the user NOW. Accept the work as-is \u2014 the user can request improvements later.`;
+    } else if (this.leaderRounds >= DELEGATION_BUDGET_ROUNDS - 1) {
+      roundInfo = `Round ${this.leaderRounds}/${DELEGATION_BUDGET_ROUNDS} \u2014 LAST delegation round. Only delegate if something is critically broken. Prefer to accept and summarize.`;
+    } else {
+      roundInfo = `Round ${this.leaderRounds}/${DELEGATION_BUDGET_ROUNDS}`;
+    }
+    const resultLines = pending.results.map(
+      (r) => `- ${r.fromName} (${r.statusWord}): ${r.summary}`
+    ).join("\n\n");
+    const followUpTaskId = nanoid3();
+    this.resultTaskIds.add(followUpTaskId);
+    this.delegationsAtResultStart.set(followUpTaskId, this.totalDelegations);
+    const teamContext = this.agentManager.isTeamLead(originAgentId) ? this.agentManager.getTeamRoster() : void 0;
+    const batchPrompt = this.promptEngine.render("leader-result", {
+      fromName: pending.results.length === 1 ? pending.results[0].fromName : `${pending.results.length} team members`,
+      resultStatus: pending.results.every((r) => r.statusWord.includes("success")) ? "completed successfully" : "mixed results",
+      resultSummary: resultLines,
+      originalTask: originSession.originalTask ?? "",
+      roundInfo
+    });
+    console.log(`[ResultBatch] Flushing ${pending.results.length} result(s) to ${originAgentId} (round ${this.leaderRounds}, budget=${DELEGATION_BUDGET_ROUNDS}, ceiling=${HARD_CEILING_ROUNDS})`);
+    originSession.runTask(followUpTaskId, batchPrompt, void 0, teamContext);
+  }
+};
 
-${r.summary}`;
-    if (r.changedFiles.length > 0) {
-      msg += `
+// ../../packages/orchestrator/src/prompt-templates.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import path3 from "path";
+var PROMPT_DEFAULTS = {
+  "leader-initial": `You are {{name}}, the Team Lead. {{personality}}
+You CANNOT write code, run commands, or use any tools. You can ONLY delegate.
 
-\u{1F4C1} Changed files:
-${r.changedFiles.map((f) => `\u2022 ${f}`).join("\n")}`;
+Team:
+{{teamRoster}}
+
+Delegate using this exact format (one per line):
+@AgentName: [project-dir] task description
+
+IMPORTANT: Every delegation MUST start with [project-dir] \u2014 the subdirectory path relative to the workspace root where this agent should focus. Example: @Alex: [game/] Fix the CSS overlay in game/styles.css. ALL team members MUST work in the same project directory. Identify the target project first, then use it consistently.
+
+Execution phases:
+1. BUILD: Assign coding tasks to developers now. Include file paths and specific instructions.
+2. VALIDATE (one round, parallel): When dev results come back, assign Code Reviewer AND QA Tester at the same time in a single response. Both run in parallel \u2014 do NOT wait for one before assigning the other.
+3. REPORT: After both review and QA report back, summarize and finish. Done.
+
+Rules:
+- Never write code yourself. Only delegate.
+- Each delegation must be specific and bounded: include exact file paths, function names, and expected output. Vague delegations ("improve the UI") cause scope creep.
+- Phase 1 (this round): Assign developers ONLY. Do NOT assign QA or code review yet \u2014 there is no code to test.
+- Phase 2 (one round only): Assign Code Reviewer AND QA Tester simultaneously in one response. This saves a full round.
+- Skip QA entirely for trivial changes (config tweaks, typo fixes, renaming, comment-only changes).
+- Keep the total number of rounds to 2-3. Ship working code now \u2014 the user can request improvements later.
+
+Task: {{prompt}}`,
+  "leader-continue": `You are {{name}}, the Team Lead. {{personality}}
+You CANNOT write code, run commands, or use any tools. You can ONLY delegate.
+
+Team status:
+{{teamRoster}}
+
+{{originalTask}}
+
+Delegate using: @AgentName: task description
+
+{{prompt}}`,
+  "leader-result": `You are the Team Lead. You CANNOT write or fix code. You can ONLY delegate using @Name: [project-dir] <task>.
+
+Original user task: {{originalTask}}
+
+{{roundInfo}}
+
+Team status:
+{{teamRoster}}
+
+New result from {{fromName}} ({{resultStatus}}):
+{{resultSummary}}
+
+Decision priority (choose the FIRST that applies):
+1. ALL SUCCEEDED \u2192 Summarize the outcome for the user. You are DONE.
+2. Dev succeeded + this is a substantial change (new feature, significant logic change) + neither QA nor Code Reviewer has run yet \u2192 Assign BOTH @CodeReviewer AND @QATester simultaneously in ONE response (parallel). Skip this step for trivial changes.
+3. Dev succeeded + trivial change (config, rename, typo, style-only) \u2192 Summarize and you are DONE. No QA needed.
+4. QA or Code Review results received \u2192 Accept ALL findings as informational. Summarize and you are DONE. NEVER delegate fixes based on QA or review results.
+5. FAILED + critically broken (won't run, crash on start) \u2192 delegate ONE targeted fix to the original developer.
+6. FAILED + permanent blocker (auth error, service down, missing dependency) \u2192 report the blocker to the user.
+7. Same error repeated \u2192 STOP and report to the user.
+
+CRITICAL RULES:
+- QA/testing findings are ALWAYS informational. NEVER delegate fixes based on QA results. Note them and finish.
+- Code review comments are ALWAYS informational. Only delegate a fix if the code literally doesn't compile or run.
+- When assigning parallel QA + Review (rule 2): write BOTH @Name: lines in one response. Do not wait for one to finish.
+- Maximum ONE fix round after a failure. After that, accept and summarize.
+- Prefer DONE over more delegation. The user can request improvements later.`,
+  "worker-initial": `Your name is {{name}}, your role is {{role}}. {{personality}}
+
+CONVERGENCE RULES (follow strictly):
+- Do the MINIMUM needed to satisfy the task. Simple and working beats perfect and slow.
+- Only touch files directly required by this task. Do NOT refactor, clean up, or "improve" unrelated code.
+- If you are uncertain between two approaches, choose the simpler one and note it in SUMMARY.
+- Do NOT add features, error handling, or improvements that were not explicitly asked for.
+- Sub-delegate (@AgentName:) when you need a teammate's specialized expertise (e.g. frontend dev asking backend dev for an API contract, or asking QA to verify a specific behavior). Natural peer collaboration is encouraged \u2014 just keep it focused.
+
+HARD LIMITS:
+- Do NOT start any dev server, HTTP server, or file server (no npx serve, no python -m http.server, no live-server, etc.). The system handles preview automatically.
+- Do NOT install new dependencies unless the task explicitly requires it. Note any missing deps in SUMMARY instead.
+
+Start with one sentence describing your approach (e.g. "I'll add the API route in routes.ts and wire it to the existing handler."). Then do the work.
+
+When you finish, report your result in this exact format:
+STATUS: done | failed
+FILES_CHANGED: (list of files you created or modified, one per line)
+SUMMARY: (one sentence \u2014 what you did and why it satisfies the task)
+
+{{prompt}}`,
+  "worker-continue": `{{prompt}}`,
+  "delegation-prefix": `[Assigned by {{fromName}} ({{fromRole}})]
+{{prompt}}`,
+  "delegation-hint": `To delegate a task to another agent, output on its own line: @AgentName: <task description>`
+};
+var PromptEngine = class {
+  templates = { ...PROMPT_DEFAULTS };
+  promptsDir;
+  constructor(promptsDir) {
+    this.promptsDir = promptsDir;
+  }
+  /**
+   * Initialize prompt templates on startup.
+   * Creates promptsDir with defaults if it doesn't exist,
+   * then loads all .md files (falling back to defaults for missing ones).
+   */
+  init() {
+    if (!this.promptsDir) {
+      console.log(`[Prompts] No promptsDir configured, using ${Object.keys(PROMPT_DEFAULTS).length} default templates`);
+      return;
     }
-    return msg;
+    if (!existsSync3(this.promptsDir)) {
+      mkdirSync3(this.promptsDir, { recursive: true });
+      for (const [name, content] of Object.entries(PROMPT_DEFAULTS)) {
+        writeFileSync3(path3.join(this.promptsDir, `${name}.md`), content, "utf-8");
+      }
+      console.log(`[Prompts] Created ${this.promptsDir} with ${Object.keys(PROMPT_DEFAULTS).length} default templates`);
+    }
+    this.reload();
   }
-  if (event.type === "TASK_FAILED" && event.agentId === agentId) {
-    return `\u274C Task failed
+  /**
+   * Re-read all templates from disk. Missing files fall back to built-in defaults.
+   */
+  reload() {
+    const merged = { ...PROMPT_DEFAULTS };
+    let loaded = 0;
+    let defaulted = 0;
+    if (this.promptsDir) {
+      for (const name of Object.keys(PROMPT_DEFAULTS)) {
+        const filePath = path3.join(this.promptsDir, `${name}.md`);
+        if (existsSync3(filePath)) {
+          try {
+            merged[name] = readFileSync3(filePath, "utf-8");
+            loaded++;
+          } catch {
+            defaulted++;
+          }
+        } else {
+          defaulted++;
+        }
+      }
+    } else {
+      defaulted = Object.keys(PROMPT_DEFAULTS).length;
+    }
+    this.templates = merged;
+    console.log(`[Prompts] Loaded ${loaded} templates (${defaulted} using defaults)`);
+  }
+  /**
+   * Render a named template with variable substitution.
+   * {{variable}} placeholders are replaced with the provided values.
+   */
+  render(templateName, vars) {
+    const template = this.templates[templateName] ?? PROMPT_DEFAULTS[templateName];
+    if (!template) {
+      console.warn(`[Prompts] Unknown template: ${templateName}`);
+      return vars["prompt"] ?? "";
+    }
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+  }
+};
 
-${event.error}`;
+// ../../packages/orchestrator/src/retry.ts
+var RetryTracker = class {
+  state = /* @__PURE__ */ new Map();
+  maxRetries;
+  escalateToLeader;
+  constructor(maxRetries = 2, escalateToLeader = true) {
+    this.maxRetries = maxRetries;
+    this.escalateToLeader = escalateToLeader;
   }
-  if (event.type === "APPROVAL_NEEDED" && event.agentId === agentId) {
-    return `\u26A0\uFE0F Approval needed
+  /**
+   * Initialize tracking for a task. Call before first attempt.
+   */
+  track(taskId, originalPrompt) {
+    this.state.set(taskId, {
+      taskId,
+      originalPrompt,
+      attempt: 0,
+      maxRetries: this.maxRetries,
+      errors: []
+    });
+  }
+  /**
+   * Check if the task has retries remaining.
+   */
+  shouldRetry(taskId) {
+    const s = this.state.get(taskId);
+    if (!s) return false;
+    return s.attempt < s.maxRetries;
+  }
+  /**
+   * Record a failed attempt. Returns the updated state.
+   */
+  recordAttempt(taskId, error) {
+    const s = this.state.get(taskId);
+    if (!s) return void 0;
+    s.attempt++;
+    s.errors.push(error);
+    return { ...s };
+  }
+  /**
+   * Get the original prompt for retrying (with error context appended).
+   */
+  getRetryPrompt(taskId) {
+    const s = this.state.get(taskId);
+    if (!s) return null;
+    const lastError = s.errors[s.errors.length - 1] ?? "unknown error";
+    return `${s.originalPrompt}
 
-${event.title}
-${event.summary}
+[RETRY \u2014 Attempt ${s.attempt + 1}/${s.maxRetries}]
+Previous attempt failed with:
+${lastError.slice(0, 500)}
 
-Reply /yes or /no`;
+Before retrying, follow this protocol:
+1. DIAGNOSE: Read the error carefully. Identify the root cause, not just the symptom.
+2. FIX: Address the root cause first (missing dependency, wrong path, syntax error, etc.)
+3. VERIFY: After fixing, confirm the fix works before moving on.
+Do NOT repeat the same approach that failed.`;
+  }
+  /**
+   * Get escalation prompt for the team lead (when all retries exhausted).
+   * Returns null if escalation is disabled or task not tracked.
+   */
+  getEscalation(taskId) {
+    if (!this.escalateToLeader) return null;
+    const s = this.state.get(taskId);
+    if (!s) return null;
+    if (s.attempt < s.maxRetries) return null;
+    const errorList = s.errors.map((e, i) => `  Attempt ${i + 1}: ${e.slice(0, 200)}`).join("\n");
+    const sameError = s.errors.length >= 2 && s.errors.every((e) => {
+      const key = e.slice(0, 80).toLowerCase();
+      return key === s.errors[0].slice(0, 80).toLowerCase();
+    });
+    return {
+      prompt: `[ESCALATION] A task has failed after ${s.attempt} attempts and needs your decision.
+
+Original task: "${s.originalPrompt.slice(0, 300)}"
+
+Failure history:
+${errorList}
+${sameError ? "\n\u26A0\uFE0F All attempts failed with the SAME error. This is likely a PERMANENT blocker (missing credentials, API limits, service unavailable). Do NOT reassign \u2014 report to user.\n" : ""}
+Options (choose ONE):
+1. If the error is FIXABLE (code bug, wrong path): Reassign to a DIFFERENT team member with revised instructions
+2. If the task is too large: Break into smaller pieces and delegate each part
+3. If the error is PERMANENT (auth failure, service down, insufficient balance, missing API key): Report the blocker to the user. Do NOT reassign.
+
+IMPORTANT: If the same error keeps repeating, choose option 3. Do not waste resources retrying.`
+    };
+  }
+  /**
+   * Remove tracking for a completed/cancelled task.
+   */
+  clear(taskId) {
+    this.state.delete(taskId);
+  }
+};
+
+// ../../packages/orchestrator/src/worktree.ts
+import { execSync as execSync3 } from "child_process";
+import path4 from "path";
+var TIMEOUT = 5e3;
+function isGitRepo(cwd) {
+  try {
+    execSync3("git rev-parse --is-inside-work-tree", { cwd, stdio: "ignore", timeout: TIMEOUT });
+    return true;
+  } catch {
+    return false;
   }
-  return null;
 }
-var telegramChannel = {
-  name: "Telegram",
-  async init(commandHandler) {
-    const tokens = config.telegramBotTokens;
-    if (!tokens.length || tokens.every((t) => !t)) return false;
-    for (let i = 0; i < tokens.length && i < PRESETS.length; i++) {
-      const token = tokens[i];
-      if (!token) continue;
-      const preset = PRESETS[i];
-      const agentId = `tg-${preset.name.toLowerCase()}`;
-      const bot = new TelegramBot(token, { polling: true });
-      const ba = { bot, preset, agentId, chatIds: /* @__PURE__ */ new Set() };
-      botAgents.push(ba);
-      if (!agentManager.get(agentId)) {
-        commandHandler({
-          type: "CREATE_AGENT",
+function createWorktree(workspace, agentId, taskId, agentName) {
+  if (!isGitRepo(workspace)) return null;
+  const worktreeDir = path4.join(workspace, ".worktrees");
+  const worktreeName = `${agentId}-${taskId}`;
+  const worktreePath = path4.join(worktreeDir, worktreeName);
+  const branch = `agent/${agentName.toLowerCase().replace(/\s+/g, "-")}/${taskId}`;
+  try {
+    execSync3(`git worktree add "${worktreePath}" -b "${branch}"`, {
+      cwd: workspace,
+      stdio: "pipe",
+      timeout: TIMEOUT
+    });
+    return worktreePath;
+  } catch (err) {
+    console.error(`[Worktree] Failed to create worktree: ${err.message}`);
+    return null;
+  }
+}
+function mergeWorktree(workspace, worktreePath, branch) {
+  try {
+    execSync3(`git merge --no-ff "${branch}"`, {
+      cwd: workspace,
+      stdio: "pipe",
+      timeout: TIMEOUT
+    });
+    try {
+      execSync3(`git worktree remove "${worktreePath}"`, { cwd: workspace, stdio: "pipe", timeout: TIMEOUT });
+    } catch {
+    }
+    try {
+      execSync3(`git branch -d "${branch}"`, { cwd: workspace, stdio: "pipe", timeout: TIMEOUT });
+    } catch {
+    }
+    return { success: true };
+  } catch (err) {
+    let conflictFiles = [];
+    try {
+      const output = execSync3("git diff --name-only --diff-filter=U", {
+        cwd: workspace,
+        encoding: "utf-8",
+        timeout: TIMEOUT
+      }).trim();
+      conflictFiles = output ? output.split("\n") : [];
+      execSync3("git merge --abort", { cwd: workspace, stdio: "pipe", timeout: TIMEOUT });
+    } catch {
+    }
+    return { success: false, conflictFiles };
+  }
+}
+function removeWorktree(worktreePath, branch, workspace) {
+  const cwd = workspace ?? path4.dirname(path4.dirname(worktreePath));
+  try {
+    execSync3(`git worktree remove --force "${worktreePath}"`, { cwd, stdio: "pipe", timeout: TIMEOUT });
+  } catch {
+  }
+  try {
+    execSync3(`git branch -D "${branch}"`, { cwd, stdio: "pipe", timeout: TIMEOUT });
+  } catch {
+  }
+}
+
+// ../../packages/orchestrator/src/orchestrator.ts
+var Orchestrator = class extends EventEmitter {
+  agentManager = new AgentManager();
+  delegationRouter;
+  promptEngine;
+  retryTracker;
+  backends = /* @__PURE__ */ new Map();
+  defaultBackendId;
+  workspace;
+  sandboxMode;
+  worktreeEnabled;
+  worktreeMerge;
+  /** Preview captured from the first dev worker that produces one — not from QA/reviewer */
+  teamPreview = null;
+  constructor(opts) {
+    super();
+    this.workspace = opts.workspace;
+    this.sandboxMode = opts.sandboxMode ?? "full";
+    for (const b of opts.backends) {
+      this.backends.set(b.id, b);
+    }
+    this.defaultBackendId = opts.defaultBackend ?? opts.backends[0]?.id ?? "claude";
+    this.promptEngine = new PromptEngine(opts.promptsDir);
+    this.promptEngine.init();
+    this.delegationRouter = new DelegationRouter(
+      this.agentManager,
+      this.promptEngine,
+      (e) => this.emitEvent(e)
+    );
+    if (opts.retry === false) {
+      this.retryTracker = null;
+    } else {
+      const r = opts.retry ?? {};
+      this.retryTracker = new RetryTracker(r.maxRetries, r.escalateToLeader);
+    }
+    if (opts.worktree === false) {
+      this.worktreeEnabled = false;
+      this.worktreeMerge = false;
+    } else {
+      this.worktreeEnabled = true;
+      this.worktreeMerge = opts.worktree?.mergeOnComplete ?? true;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Agent lifecycle
+  // ---------------------------------------------------------------------------
+  createAgent(opts) {
+    const backend = this.backends.get(opts.backend ?? this.defaultBackendId) ?? this.backends.get(this.defaultBackendId);
+    const session = new AgentSession({
+      agentId: opts.agentId,
+      name: opts.name,
+      role: opts.role,
+      personality: opts.personality,
+      workspace: this.workspace,
+      resumeHistory: opts.resumeHistory,
+      backend,
+      sandboxMode: this.sandboxMode,
+      isTeamLead: this.agentManager.isTeamLead(opts.agentId),
+      teamId: opts.teamId,
+      onEvent: (e) => this.handleSessionEvent(e, opts.agentId),
+      renderPrompt: (name, vars) => this.promptEngine.render(name, vars)
+    });
+    session.palette = opts.palette;
+    this.agentManager.add(session);
+    this.delegationRouter.wireAgent(session);
+    this.emitEvent({
+      type: "agent:created",
+      agentId: opts.agentId,
+      name: opts.name,
+      role: opts.role,
+      palette: opts.palette,
+      personality: opts.personality,
+      backend: backend.id,
+      isTeamLead: this.agentManager.isTeamLead(opts.agentId),
+      teamId: opts.teamId
+    });
+    this.emitEvent({
+      type: "agent:status",
+      agentId: opts.agentId,
+      status: "idle"
+    });
+  }
+  removeAgent(agentId) {
+    this.cancelTask(agentId);
+    this.delegationRouter.clearAgent(agentId);
+    this.agentManager.delete(agentId);
+    this.emitEvent({ type: "agent:fired", agentId });
+  }
+  setTeamLead(agentId) {
+    this.agentManager.setTeamLead(agentId);
+    const session = this.agentManager.get(agentId);
+    if (session) session.isTeamLead = true;
+  }
+  createTeam(opts) {
+    const presets = [
+      { ...opts.memberPresets[opts.leadPresetIndex] ?? opts.memberPresets[0], isLead: true },
+      ...opts.memberPresets.filter((_, i) => i !== opts.leadPresetIndex).map((p) => ({ ...p, isLead: false }))
+    ];
+    let leadAgentId = null;
+    for (const preset of presets) {
+      const agentId = `agent-${nanoid4(6)}`;
+      const backendId = opts.backends?.[String(opts.memberPresets.indexOf(preset))] ?? this.defaultBackendId;
+      this.createAgent({
+        agentId,
+        name: preset.name,
+        role: preset.role,
+        personality: preset.personality,
+        palette: preset.palette,
+        backend: backendId
+      });
+      if (preset.isLead) {
+        leadAgentId = agentId;
+        this.agentManager.setTeamLead(agentId);
+      }
+    }
+    if (leadAgentId) {
+      this.emitEvent({
+        type: "team:chat",
+        fromAgentId: leadAgentId,
+        message: `Team created! ${presets.length} members ready.`,
+        messageType: "status",
+        timestamp: Date.now()
+      });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Task execution
+  // ---------------------------------------------------------------------------
+  runTask(agentId, taskId, prompt, opts) {
+    const session = this.agentManager.get(agentId);
+    if (!session) {
+      this.emitEvent({
+        type: "task:failed",
+        agentId,
+        taskId,
+        error: "Agent not found. Create it first."
+      });
+      return;
+    }
+    if (this.agentManager.isTeamLead(agentId) && !this.delegationRouter.isDelegated(taskId)) {
+      session.originalTask = prompt;
+      this.delegationRouter.clearAll();
+      this.teamPreview = null;
+    }
+    this.retryTracker?.track(taskId, prompt);
+    if (this.worktreeEnabled && !session.worktreePath) {
+      const wt = createWorktree(this.workspace, agentId, taskId, session.name);
+      if (wt) {
+        const branch = `agent/${session.name.toLowerCase().replace(/\s+/g, "-")}/${taskId}`;
+        session.worktreePath = wt;
+        session.worktreeBranch = branch;
+        this.emitEvent({
+          type: "worktree:created",
           agentId,
-          name: preset.name,
-          role: preset.role,
-          palette: preset.palette,
-          personality: preset.personality
+          taskId,
+          worktreePath: wt,
+          branch
         });
       }
-      const botInfo = await bot.getMe();
-      console.log(`[Telegram] @${botInfo.username} \u2192 ${preset.name} (${preset.role})`);
-      bot.on("message", (msg) => {
-        if (!msg.text) return;
-        ba.chatIds.add(msg.chat.id);
-        const text = msg.text.trim();
-        if (text === "/yes") {
-          for (const agent of agentManager.getAll()) {
-            if (agent.agentId === agentId) {
-              agent.resolveApproval("__all__", "yes");
+    }
+    const repoPath = session.worktreePath ?? opts?.repoPath;
+    const teamContext = this.agentManager.isTeamLead(agentId) ? this.agentManager.getTeamRoster() : void 0;
+    session.runTask(
+      taskId,
+      prompt,
+      repoPath,
+      teamContext,
+      true
+      /* isUserInitiated */
+    );
+  }
+  cancelTask(agentId) {
+    const session = this.agentManager.get(agentId);
+    if (!session) return;
+    if (session.worktreePath && session.worktreeBranch) {
+      removeWorktree(session.worktreePath, session.worktreeBranch, this.workspace);
+      session.worktreePath = null;
+      session.worktreeBranch = null;
+    }
+    session.cancelTask();
+  }
+  /**
+   * Stop all team agents — cancel their tasks but keep them alive.
+   * Safe to call before fireTeam, or to just pause work.
+   */
+  stopTeam() {
+    this.delegationRouter.stop();
+    const teamAgents = this.agentManager.getAll().filter((a) => !!a.teamId);
+    for (const agent of teamAgents) {
+      this.cancelTask(agent.agentId);
+    }
+    this.emitEvent({
+      type: "team:chat",
+      fromAgentId: teamAgents.find((a) => this.agentManager.isTeamLead(a.agentId))?.agentId ?? "system",
+      message: "Team work stopped. All tasks cancelled.",
+      messageType: "status",
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Fire the entire team — stop all work silently, then remove all agents.
+   */
+  fireTeam() {
+    this.delegationRouter.stop();
+    const teamAgents = this.agentManager.getAll().filter((a) => !!a.teamId);
+    for (const agent of teamAgents) {
+      this.cancelTask(agent.agentId);
+    }
+    for (const agent of teamAgents) {
+      this.agentManager.delete(agent.agentId);
+      this.emitEvent({ type: "agent:fired", agentId: agent.agentId });
+    }
+  }
+  sendMessage(agentId, message) {
+    const session = this.agentManager.get(agentId);
+    if (!session) return false;
+    return session.sendMessage(message);
+  }
+  resolveApproval(approvalId, decision) {
+    for (const agent of this.agentManager.getAll()) {
+      agent.resolveApproval(approvalId, decision);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Query
+  // ---------------------------------------------------------------------------
+  getAgent(agentId) {
+    const s = this.agentManager.get(agentId);
+    if (!s) return void 0;
+    return { agentId: s.agentId, name: s.name, role: s.role, status: s.status, palette: s.palette, backend: s.backend.id };
+  }
+  getAllAgents() {
+    return this.agentManager.getAll().map((s) => ({
+      agentId: s.agentId,
+      name: s.name,
+      role: s.role,
+      status: s.status,
+      palette: s.palette,
+      backend: s.backend.id,
+      isTeamLead: this.agentManager.isTeamLead(s.agentId),
+      teamId: s.teamId
+    }));
+  }
+  getTeamRoster() {
+    return this.agentManager.getTeamRoster();
+  }
+  isTeamLead(agentId) {
+    return this.agentManager.isTeamLead(agentId);
+  }
+  // ---------------------------------------------------------------------------
+  // Cleanup
+  // ---------------------------------------------------------------------------
+  destroy() {
+    for (const agent of this.agentManager.getAll()) {
+      if (agent.worktreePath && agent.worktreeBranch) {
+        removeWorktree(agent.worktreePath, agent.worktreeBranch, this.workspace);
+      }
+      agent.destroy();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  handleSessionEvent(event, agentId) {
+    if (event.type === "task:failed" && this.retryTracker) {
+      const taskId = event.taskId;
+      const session = this.agentManager.get(agentId);
+      const wasCancelled = event.error === "Task cancelled by user";
+      const wasTimeout = session?.wasTimeout ?? false;
+      if (!wasCancelled && !wasTimeout && this.retryTracker.shouldRetry(taskId) && !this.delegationRouter.isDelegated(taskId)) {
+        const state = this.retryTracker.recordAttempt(taskId, event.error);
+        if (state) {
+          this.emitEvent({
+            type: "task:retrying",
+            agentId,
+            taskId,
+            attempt: state.attempt,
+            maxRetries: state.maxRetries,
+            error: event.error
+          });
+          const retryPrompt = this.retryTracker.getRetryPrompt(taskId);
+          if (retryPrompt) {
+            const session2 = this.agentManager.get(agentId);
+            if (session2) {
+              setTimeout(() => session2.runTask(taskId, retryPrompt), 500);
+              return;
             }
           }
-          return;
         }
-        if (text === "/no") {
-          for (const agent of agentManager.getAll()) {
-            if (agent.agentId === agentId) {
-              agent.resolveApproval("__all__", "no");
-            }
+      }
+      const escalation = wasCancelled ? null : this.retryTracker.getEscalation(taskId);
+      if (escalation) {
+        const leadId = this.agentManager.getTeamLead();
+        if (leadId && leadId !== agentId) {
+          const leadSession = this.agentManager.get(leadId);
+          if (leadSession) {
+            const escalationTaskId = nanoid4();
+            const teamContext = this.agentManager.getTeamRoster();
+            leadSession.runTask(escalationTaskId, escalation.prompt, void 0, teamContext);
           }
-          return;
         }
-        if (text === "/cancel") {
-          const session2 = agentManager.get(agentId);
-          if (session2) {
-            session2.cancelTask();
-            bot.sendMessage(msg.chat.id, `\u{1F6D1} Cancelled ${preset.name}'s current task`);
-          }
-          return;
+      }
+      this.retryTracker.clear(taskId);
+    }
+    if (event.type === "task:done") {
+      const session = this.agentManager.get(agentId);
+      if (session?.worktreePath && session.worktreeBranch) {
+        if (this.worktreeMerge) {
+          const result = mergeWorktree(this.workspace, session.worktreePath, session.worktreeBranch);
+          this.emitEvent({
+            type: "worktree:merged",
+            agentId,
+            taskId: event.taskId,
+            branch: session.worktreeBranch,
+            success: result.success,
+            conflictFiles: result.conflictFiles
+          });
+        } else {
+          removeWorktree(session.worktreePath, session.worktreeBranch, this.workspace);
         }
-        if (text === "/status") {
-          const session2 = agentManager.get(agentId);
-          const status = session2?.status ?? "unknown";
-          bot.sendMessage(msg.chat.id, `${preset.name} (${preset.role}): ${status}`);
-          return;
+        session.worktreePath = null;
+        session.worktreeBranch = null;
+      }
+      this.retryTracker?.clear(event.taskId);
+      if (!this.agentManager.isTeamLead(agentId) && !this.teamPreview) {
+        const role = session?.role?.toLowerCase() ?? "";
+        const isDevWorker = !role.includes("qa") && !role.includes("tester") && !role.includes("review");
+        if (isDevWorker && event.result?.previewUrl) {
+          this.teamPreview = {
+            previewUrl: event.result.previewUrl,
+            previewPath: event.result.previewPath
+          };
+          console.log(`[Orchestrator] Preview captured from ${session?.name}: ${this.teamPreview.previewUrl}`);
         }
-        if (text.startsWith("/")) return;
-        const session = agentManager.get(agentId);
-        if (session?.status === "working") {
-          bot.sendMessage(msg.chat.id, `\u23F3 ${preset.name} is busy. Wait or send /cancel`);
-          return;
+      }
+      if (this.agentManager.isTeamLead(agentId)) {
+        const isResultTask = this.delegationRouter.isResultTask(event.taskId);
+        const leaderDidNotDelegateNewWork = isResultTask && this.delegationRouter.resultTaskDidNotDelegate(event.taskId);
+        const budgetForced = this.delegationRouter.isBudgetExhausted() && !this.delegationRouter.hasPendingFrom(agentId);
+        const shouldFinalize = leaderDidNotDelegateNewWork || budgetForced;
+        if (shouldFinalize) {
+          event.isFinalResult = true;
+          this.delegationRouter.clearAgent(agentId);
+          if (!event.result?.previewUrl && this.teamPreview && event.result) {
+            event.result.previewUrl = this.teamPreview.previewUrl;
+            event.result.previewPath = this.teamPreview.previewPath;
+          }
+          if (!event.result?.previewUrl && event.result) {
+            for (const worker of this.agentManager.getAll()) {
+              if (worker.agentId === agentId) continue;
+              const { previewUrl, previewPath } = worker.detectPreview();
+              if (previewUrl) {
+                event.result.previewUrl = previewUrl;
+                event.result.previewPath = previewPath;
+                break;
+              }
+            }
+          }
+          const summary = event.result?.summary?.slice(0, 200) ?? "All tasks completed.";
+          this.emitEvent({
+            type: "team:chat",
+            fromAgentId: agentId,
+            message: `Project complete: ${summary}`,
+            messageType: "status",
+            timestamp: Date.now()
+          });
+        } else if (!isResultTask && !this.delegationRouter.hasPendingFrom(agentId)) {
+          console.warn(`[Orchestrator] Leader ${agentId} completed initial task with no delegations. Output may have failed to parse.`);
         }
-        const taskId = nanoid2();
-        commandHandler({
-          type: "RUN_TASK",
-          agentId,
-          taskId,
-          prompt: text,
-          name: preset.name,
-          role: preset.role,
-          personality: preset.personality
-        });
-      });
-    }
-    console.log(`[Telegram] ${botAgents.length} bot(s) active`);
-    return botAgents.length > 0;
-  },
-  broadcast(event) {
-    for (const ba of botAgents) {
-      const text = formatEvent(event, ba.agentId);
-      if (!text) continue;
-      for (const chatId of ba.chatIds) {
-        ba.bot.sendMessage(chatId, text).catch((err) => {
-          console.error(`[Telegram] Send failed:`, err.message);
-        });
       }
     }
-  },
-  destroy() {
-    for (const ba of botAgents) {
-      ba.bot.stopPolling();
+    if (event.type === "task:failed") {
+      const session = this.agentManager.get(agentId);
+      if (session?.worktreePath && session.worktreeBranch) {
+        removeWorktree(session.worktreePath, session.worktreeBranch, this.workspace);
+        session.worktreePath = null;
+        session.worktreeBranch = null;
+      }
     }
-    botAgents.length = 0;
+    this.emitEvent(event);
+  }
+  emitEvent(event) {
+    this.emit(event.type, event);
   }
 };
 
-// src/setup.ts
-import { createInterface } from "readline";
-function ask(rl, question) {
-  return new Promise((resolve2) => {
-    const onClose = () => resolve2("");
-    rl.once("close", onClose);
-    rl.question(question, (answer) => {
-      rl.removeListener("close", onClose);
-      resolve2(answer.trim());
-    });
-  });
-}
-async function runSetup() {
-  console.log("[Setup] Detecting AI backends...");
-  const detected = detectBackends();
-  const detectedNames = detected.map((id) => getBackend(id)?.name ?? id).join(", ");
-  console.log(`[Setup] Found: ${detectedNames || "none"}`);
-  if (!process.stdin.isTTY) {
-    saveConfig({ detectedBackends: detected, defaultBackend: detected[0] ?? "claude", sandboxMode: "full" });
-    console.log("\u2713 Default config saved to ~/.bit-office/config.json");
-    console.log("  Run with --setup in a terminal to configure.\n");
-    return;
-  }
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true
-  });
-  console.log("");
-  console.log("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
-  console.log("\u2551        Bit Office \u2014 First Setup       \u2551");
-  console.log("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
-  console.log("");
-  console.log("Press Enter to skip any step.\n");
-  console.log("\u2500\u2500 Remote Access (Ably) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  console.log("Enables access from outside your LAN.");
-  const ablyApiKey = await ask(rl, "Ably API Key (optional): ");
-  let defaultBackend = detected[0] ?? "claude";
-  if (detected.length > 1) {
-    console.log("\n\u2500\u2500 AI Backends \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-    console.log(`Detected: ${detectedNames}`);
-    const choices = detected.map((id, i) => `${i + 1}=${getBackend(id)?.name ?? id}`).join(", ");
-    const pick = await ask(rl, `Default backend (${choices}): `);
-    const idx = parseInt(pick, 10) - 1;
-    if (idx >= 0 && idx < detected.length) {
-      defaultBackend = detected[idx];
-    }
-  }
-  console.log("\n\u2500\u2500 Agent Permissions \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-  console.log("1 = Full access (agents can access entire machine)");
-  console.log("2 = Sandbox (agents restricted to working directory)");
-  const sandboxPick = await ask(rl, "Permission mode (1/2, default=1): ");
-  const sandboxMode = sandboxPick === "2" ? "safe" : "full";
-  rl.close();
-  saveConfig({
-    ablyApiKey: ablyApiKey || void 0,
-    detectedBackends: detected,
-    defaultBackend,
-    sandboxMode
-  });
-  console.log("\n\u2713 Config saved to ~/.bit-office/config.json");
-  if (ablyApiKey) console.log("  \u2022 Ably: enabled");
-  console.log(`  \u2022 Default AI: ${getBackend(defaultBackend)?.name ?? defaultBackend}`);
-  console.log(`  \u2022 Permissions: ${sandboxMode === "full" ? "Full access" : "Sandbox"}`);
-  console.log("  \u2022 Run with --setup to reconfigure\n");
+// ../../packages/orchestrator/src/index.ts
+function createOrchestrator(options) {
+  return new Orchestrator(options);
 }
 
 // src/index.ts
-import { nanoid as nanoid3 } from "nanoid";
-import { exec } from "child_process";
-import { existsSync as existsSync2 } from "fs";
+import { nanoid as nanoid5 } from "nanoid";
+import { execFile } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import path5 from "path";
+import os from "os";
 registerChannel(wsChannel);
 registerChannel(ablyChannel);
 registerChannel(telegramChannel);
+var orc;
 function generatePairCode() {
-  return nanoid3(6).toUpperCase();
+  return nanoid5(6).toUpperCase();
 }
 function showPairCode() {
   const code = generatePairCode();
@@ -5144,25 +6665,45 @@ function showPairCode() {
   console.log(`Open your phone \u2192 enter gateway address + code`);
   console.log("");
 }
-function wireDelegation(session) {
-  if (!session) return;
-  session.onDelegation = (fromAgentId, targetName, prompt) => {
-    const target = agentManager.findByName(targetName);
-    if (!target) {
-      console.log(`[Delegation] Target agent "${targetName}" not found, ignoring`);
-      return;
-    }
-    const taskId = nanoid3();
-    console.log(`[Delegation] ${fromAgentId} -> ${target.agentId} (${targetName}): ${prompt.slice(0, 80)}`);
-    publishEvent({
-      type: "TASK_DELEGATED",
-      fromAgentId,
-      toAgentId: target.agentId,
-      taskId,
-      prompt
-    });
-    target.runTask(taskId, prompt);
-  };
+function mapOrchestratorEvent(e) {
+  switch (e.type) {
+    case "task:started":
+      return { type: "TASK_STARTED", agentId: e.agentId, taskId: e.taskId, prompt: e.prompt };
+    case "task:done":
+      return { type: "TASK_DONE", agentId: e.agentId, taskId: e.taskId, result: e.result, isFinalResult: e.isFinalResult };
+    case "task:failed":
+      return { type: "TASK_FAILED", agentId: e.agentId, taskId: e.taskId, error: e.error };
+    case "task:delegated":
+      return { type: "TASK_DELEGATED", fromAgentId: e.fromAgentId, toAgentId: e.toAgentId, taskId: e.taskId, prompt: e.prompt };
+    case "agent:status":
+      return { type: "AGENT_STATUS", agentId: e.agentId, status: e.status };
+    case "approval:needed":
+      return { type: "APPROVAL_NEEDED", approvalId: e.approvalId, agentId: e.agentId, taskId: e.taskId, title: e.title, summary: e.summary, riskLevel: e.riskLevel };
+    case "log:append":
+      return { type: "LOG_APPEND", agentId: e.agentId, taskId: e.taskId, stream: e.stream, chunk: e.chunk };
+    case "team:chat":
+      return { type: "TEAM_CHAT", fromAgentId: e.fromAgentId, toAgentId: e.toAgentId, message: e.message, messageType: e.messageType, taskId: e.taskId, timestamp: e.timestamp };
+    case "task:queued":
+      return { type: "TASK_QUEUED", agentId: e.agentId, taskId: e.taskId, prompt: e.prompt, position: e.position };
+    case "agent:created":
+      return { type: "AGENT_CREATED", agentId: e.agentId, name: e.name, role: e.role, palette: e.palette, personality: e.personality, backend: e.backend, isTeamLead: e.isTeamLead, teamId: e.teamId };
+    case "agent:fired":
+      return { type: "AGENT_FIRED", agentId: e.agentId };
+    case "task:result-returned":
+      return { type: "TASK_RESULT_RETURNED", fromAgentId: e.fromAgentId, toAgentId: e.toAgentId, taskId: e.taskId, summary: e.summary, success: e.success };
+    // New events (worktree, retry) — log only, no wire protocol equivalent yet
+    case "task:retrying":
+      console.log(`[Retry] Agent ${e.agentId} retrying task ${e.taskId} (attempt ${e.attempt}/${e.maxRetries})`);
+      return null;
+    case "worktree:created":
+      console.log(`[Worktree] Created ${e.worktreePath} for agent ${e.agentId}`);
+      return null;
+    case "worktree:merged":
+      console.log(`[Worktree] Merged branch ${e.branch} for agent ${e.agentId} (success=${e.success})`);
+      return null;
+    default:
+      return null;
+  }
 }
 function handleCommand(parsed) {
   console.log("[Gateway] Received command:", parsed.type, JSON.stringify(parsed));
@@ -5170,50 +6711,39 @@ function handleCommand(parsed) {
     case "CREATE_AGENT": {
       const backendId = parsed.backend ?? config.defaultBackend;
       console.log(`[Gateway] Creating agent: ${parsed.agentId} (${parsed.name} - ${parsed.role}) backend=${backendId}`);
-      const session = agentManager.create(parsed.agentId, parsed.name, parsed.role, parsed.personality, void 0, false, backendId, parsed.palette);
-      wireDelegation(session);
-      publishEvent({
-        type: "AGENT_CREATED",
+      orc.createAgent({
         agentId: parsed.agentId,
         name: parsed.name,
         role: parsed.role,
-        palette: parsed.palette,
         personality: parsed.personality,
-        backend: backendId
-      });
-      publishEvent({
-        type: "AGENT_STATUS",
-        agentId: parsed.agentId,
-        status: "idle"
+        backend: backendId,
+        palette: parsed.palette
       });
       break;
     }
     case "FIRE_AGENT": {
       console.log(`[Gateway] Firing agent: ${parsed.agentId}`);
-      agentManager.delete(parsed.agentId);
-      publishEvent({
-        type: "AGENT_FIRED",
-        agentId: parsed.agentId
-      });
+      orc.removeAgent(parsed.agentId);
       break;
     }
     case "RUN_TASK": {
-      let session = agentManager.get(parsed.agentId);
-      if (!session && parsed.name) {
+      let agent = orc.getAgent(parsed.agentId);
+      if (!agent && parsed.name) {
         const backendId = parsed.backend ?? config.defaultBackend;
         console.log(`[Gateway] Auto-creating agent for RUN_TASK: ${parsed.agentId} backend=${backendId}`);
-        session = agentManager.create(parsed.agentId, parsed.name, parsed.role ?? "", parsed.personality, void 0, true, backendId);
-        wireDelegation(session);
-        publishEvent({
-          type: "AGENT_CREATED",
+        orc.createAgent({
           agentId: parsed.agentId,
           name: parsed.name,
           role: parsed.role ?? "",
-          backend: backendId
+          personality: parsed.personality,
+          backend: backendId,
+          resumeHistory: true
         });
+        agent = orc.getAgent(parsed.agentId);
       }
-      if (session) {
-        session.runTask(parsed.taskId, parsed.prompt, parsed.repoPath);
+      if (agent) {
+        console.log(`[Gateway] RUN_TASK: agent=${parsed.agentId}, isLead=${orc.isTeamLead(parsed.agentId)}, hasTeam=${orc.getAllAgents().length > 1}`);
+        orc.runTask(parsed.agentId, parsed.taskId, parsed.prompt, { repoPath: parsed.repoPath });
       } else {
         publishEvent({
           type: "TASK_FAILED",
@@ -5225,35 +6755,97 @@ function handleCommand(parsed) {
       break;
     }
     case "APPROVAL_DECISION": {
-      for (const agent of agentManager.getAll()) {
-        agent.resolveApproval(parsed.approvalId, parsed.decision);
-      }
+      orc.resolveApproval(parsed.approvalId, parsed.decision);
       break;
     }
     case "CANCEL_TASK": {
-      const session = agentManager.get(parsed.agentId);
-      session?.cancelTask();
+      orc.cancelTask(parsed.agentId);
+      break;
+    }
+    case "SERVE_PREVIEW": {
+      const filePath = parsed.filePath;
+      console.log(`[Gateway] SERVE_PREVIEW: ${filePath}`);
+      previewServer.serve(filePath);
       break;
     }
     case "OPEN_FILE": {
-      const filePath = parsed.path;
-      console.log(`[Gateway] Opening file: ${filePath}`);
-      exec(`open "${filePath}"`, (err) => {
+      const raw = parsed.path;
+      const resolved = path5.resolve(config.defaultWorkspace, raw);
+      const normalized = path5.normalize(resolved);
+      if (!normalized.startsWith(config.defaultWorkspace + path5.sep) && normalized !== config.defaultWorkspace) {
+        console.error(`[Gateway] Blocked OPEN_FILE: path "${raw}" resolves outside workspace`);
+        break;
+      }
+      if (!existsSync4(normalized)) {
+        console.error(`[Gateway] OPEN_FILE: path does not exist: ${normalized}`);
+        break;
+      }
+      console.log(`[Gateway] Opening file: ${normalized}`);
+      execFile("open", [normalized], (err) => {
         if (err) console.error(`[Gateway] Failed to open file: ${err.message}`);
       });
       break;
     }
+    case "CREATE_TEAM": {
+      const { leadPresetIndex, memberPresetIndices, backends: backends2 } = parsed;
+      const allIndices = [leadPresetIndex, ...memberPresetIndices.filter((i) => i !== leadPresetIndex)];
+      console.log(`[Gateway] Creating team: lead=${leadPresetIndex}, members=${memberPresetIndices.join(",")}`);
+      let leadAgentId = null;
+      const teamId = `team-${nanoid5(6)}`;
+      for (const idx of allIndices) {
+        const preset = AGENT_PRESETS[idx];
+        if (!preset) continue;
+        const agentId = `agent-${nanoid5(6)}`;
+        const backendId = backends2?.[String(idx)] ?? config.defaultBackend;
+        if (idx === leadPresetIndex) {
+          leadAgentId = agentId;
+          orc.setTeamLead(agentId);
+        }
+        orc.createAgent({
+          agentId,
+          name: preset.name,
+          role: preset.role,
+          personality: preset.personality,
+          backend: backendId,
+          palette: preset.palette,
+          teamId
+        });
+      }
+      if (leadAgentId) {
+        const leadPreset = AGENT_PRESETS[leadPresetIndex];
+        publishEvent({
+          type: "TEAM_CHAT",
+          fromAgentId: leadAgentId,
+          message: `Team created! ${leadPreset?.name ?? "Lead"} is the Team Lead with ${memberPresetIndices.length} team members.`,
+          messageType: "status",
+          timestamp: Date.now()
+        });
+      }
+      break;
+    }
+    case "STOP_TEAM": {
+      console.log("[Gateway] Stopping team work");
+      orc.stopTeam();
+      break;
+    }
+    case "FIRE_TEAM": {
+      console.log("[Gateway] Firing entire team");
+      orc.fireTeam();
+      break;
+    }
     case "PING": {
       console.log("[Gateway] Received PING, broadcasting agent statuses");
-      for (const agent of agentManager.getAll()) {
+      for (const agent of orc.getAllAgents()) {
         publishEvent({
           type: "AGENT_CREATED",
           agentId: agent.agentId,
           name: agent.name,
           role: agent.role,
           palette: agent.palette,
-          personality: agent.personality,
-          backend: agent.backend.id
+          personality: void 0,
+          backend: agent.backend,
+          isTeamLead: agent.isTeamLead,
+          teamId: agent.teamId
         });
         publishEvent({
           type: "AGENT_STATUS",
@@ -5280,6 +6872,36 @@ async function main() {
       saveConfig({ detectedBackends: detected, defaultBackend: config.defaultBackend });
     }
   }
+  const backendsToUse = getAllBackends();
+  orc = createOrchestrator({
+    workspace: config.defaultWorkspace,
+    backends: backendsToUse,
+    defaultBackend: config.defaultBackend,
+    worktree: false,
+    // disabled by default for now
+    retry: { maxRetries: 2, escalateToLeader: true },
+    promptsDir: path5.join(os.homedir(), ".bit-office", "prompts"),
+    sandboxMode: config.sandboxMode
+  });
+  const forwardEvent = (event) => {
+    const mapped = mapOrchestratorEvent(event);
+    if (mapped) publishEvent(mapped);
+  };
+  orc.on("task:started", forwardEvent);
+  orc.on("task:done", forwardEvent);
+  orc.on("task:failed", forwardEvent);
+  orc.on("task:delegated", forwardEvent);
+  orc.on("task:retrying", forwardEvent);
+  orc.on("agent:status", forwardEvent);
+  orc.on("approval:needed", forwardEvent);
+  orc.on("log:append", forwardEvent);
+  orc.on("team:chat", forwardEvent);
+  orc.on("task:queued", forwardEvent);
+  orc.on("worktree:created", forwardEvent);
+  orc.on("worktree:merged", forwardEvent);
+  orc.on("agent:created", forwardEvent);
+  orc.on("agent:fired", forwardEvent);
+  orc.on("task:result-returned", forwardEvent);
   const backendNames = config.detectedBackends.map((id) => getBackend(id)?.name ?? id).join(", ");
   console.log(`[Gateway] AI backends: ${backendNames || "none detected"} (default: ${getBackend(config.defaultBackend)?.name ?? config.defaultBackend})`);
   console.log(`[Gateway] Permissions: ${config.sandboxMode === "full" ? "Full access" : "Sandbox"}`);
@@ -5288,10 +6910,10 @@ async function main() {
   await initTransports(handleCommand);
   console.log("[Gateway] Listening for commands...");
   console.log("[Gateway] Press 'p' + Enter to generate a new pair code");
-  if (process.env.NODE_ENV !== "development" && existsSync2(config.webDir)) {
+  if (process.env.NODE_ENV !== "development" && existsSync4(config.webDir)) {
     const url = `http://localhost:${config.wsPort}`;
     console.log(`[Gateway] Opening ${url}`);
-    exec(`open "${url}"`);
+    execFile("open", [url]);
   }
   if (process.stdin.isTTY) {
     process.stdin.setEncoding("utf-8");
@@ -5305,9 +6927,8 @@ async function main() {
 }
 function cleanup() {
   console.log("[Gateway] Shutting down...");
-  for (const agent of agentManager.getAll()) {
-    agent.destroy();
-  }
+  previewServer.stop();
+  orc?.destroy();
   destroyTransports();
   process.exit(0);
 }