@maestroai/core 0.1.0

package/dist/index.js

@@ -0,0 +1,3929 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/task/parser.ts
+function normalizePriority(raw) {
+  return raw.toLowerCase();
+}
+function normalizeStatus(raw) {
+  const trimmed = raw.trim();
+  const doneMatch = trimmed.match(/^done:(\S+)$/);
+  if (doneMatch) {
+    return { status: "done", completedAt: doneMatch[1] };
+  }
+  const statusCandidate = trimmed.toLowerCase();
+  if (VALID_STATUSES.includes(statusCandidate)) {
+    return {
+      status: statusCandidate,
+      completedAt: statusCandidate === "done" ? (/* @__PURE__ */ new Date()).toISOString() : null
+    };
+  }
+  return { status: "pending", completedAt: null };
+}
+var TASK_LINE_REGEX, PRIORITY_HEADER_REGEX, PROJECT_HEADER_REGEX, NOTE_REGEX, VALID_STATUSES, TaskParser;
+var init_parser = __esm({
+  "src/task/parser.ts"() {
+    "use strict";
+    TASK_LINE_REGEX = /^- \[(x| )\]\s+(\S+)\s+\|\s+(.+?)\s+\|\s+(@\S+|unassigned)\s+\|\s+deps:\s*(.+?)\s+\|\s+(.+)$/;
+    PRIORITY_HEADER_REGEX = /^##\s+(Critical|High|Medium|Low)\s*$/i;
+    PROJECT_HEADER_REGEX = /^#\s+Project:\s+(.+)$/;
+    NOTE_REGEX = /^\s+>\s?(.*)$/;
+    VALID_STATUSES = ["pending", "in-progress", "done", "blocked", "cancelled"];
+    TaskParser = class {
+      parse(content) {
+        const lines = content.split("\n");
+        let projectName = "";
+        let currentPriority = "medium";
+        const tasks = [];
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const projectMatch = line.match(PROJECT_HEADER_REGEX);
+          if (projectMatch) {
+            projectName = projectMatch[1].trim();
+            continue;
+          }
+          const priorityMatch = line.match(PRIORITY_HEADER_REGEX);
+          if (priorityMatch) {
+            currentPriority = normalizePriority(priorityMatch[1]);
+            continue;
+          }
+          const task = this.parseLine(line, currentPriority);
+          if (task) {
+            while (i + 1 < lines.length) {
+              const noteMatch = lines[i + 1].match(NOTE_REGEX);
+              if (noteMatch) {
+                task.notes.push(noteMatch[1]);
+                i++;
+              } else {
+                break;
+              }
+            }
+            tasks.push(task);
+          }
+        }
+        return { projectName, tasks };
+      }
+      parseLine(line, currentPriority) {
+        const match = line.match(TASK_LINE_REGEX);
+        if (!match) {
+          return null;
+        }
+        const [, checkbox, id, title, assigneeRaw, depsRaw, statusRaw] = match;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const assignee = assigneeRaw === "unassigned" ? null : assigneeRaw.slice(1);
+        const deps = depsRaw.trim().toLowerCase() === "none" ? [] : depsRaw.split(",").map((d) => d.trim()).filter(Boolean);
+        let status;
+        let completedAt = null;
+        if (checkbox === "x") {
+          status = "done";
+          const doneTimestamp = statusRaw.trim().match(/^done:(\S+)$/);
+          completedAt = doneTimestamp ? doneTimestamp[1] : now;
+        } else {
+          const parsed = normalizeStatus(statusRaw);
+          status = parsed.status;
+          completedAt = parsed.completedAt;
+        }
+        return {
+          id,
+          title: title.trim(),
+          description: title.trim(),
+          status,
+          priority: currentPriority,
+          assignee,
+          dependencies: deps,
+          tags: [],
+          createdAt: now,
+          updatedAt: now,
+          completedAt,
+          notes: []
+        };
+      }
+    };
+  }
+});
+
+// src/task/writer.ts
+var PRIORITY_ORDER, PRIORITY_LABELS, TaskWriter;
+var init_writer = __esm({
+  "src/task/writer.ts"() {
+    "use strict";
+    PRIORITY_ORDER = ["critical", "high", "medium", "low"];
+    PRIORITY_LABELS = {
+      critical: "Critical",
+      high: "High",
+      medium: "Medium",
+      low: "Low"
+    };
+    TaskWriter = class {
+      write(projectName, tasks) {
+        const lines = [];
+        lines.push(`# Project: ${projectName}`);
+        lines.push(`# Generated by Maestro | Last updated: ${(/* @__PURE__ */ new Date()).toISOString()}`);
+        lines.push("");
+        for (const priority of PRIORITY_ORDER) {
+          const group = tasks.filter((t) => t.priority === priority);
+          if (group.length === 0) {
+            continue;
+          }
+          lines.push(`## ${PRIORITY_LABELS[priority]}`);
+          for (const task of group) {
+            lines.push(this.formatTask(task));
+          }
+          lines.push("");
+        }
+        return lines.join("\n");
+      }
+      formatTask(task) {
+        const checkbox = task.status === "done" ? "[x]" : "[ ]";
+        const assignee = task.assignee ? `@${task.assignee}` : "unassigned";
+        const deps = task.dependencies.length > 0 ? task.dependencies.join(",") : "none";
+        let statusField;
+        if (task.status === "done" && task.completedAt) {
+          statusField = `done:${task.completedAt}`;
+        } else {
+          statusField = task.status;
+        }
+        const line = `- ${checkbox} ${task.id} | ${task.title} | ${assignee} | deps: ${deps} | ${statusField}`;
+        const noteLines = task.notes.map((note) => `  > ${note}`);
+        return [line, ...noteLines].join("\n");
+      }
+    };
+  }
+});
+
+// src/utils/id.ts
+import { nanoid } from "nanoid";
+function generateId() {
+  return nanoid(12);
+}
+function generateTaskId() {
+  taskCounter++;
+  return `T-${String(taskCounter).padStart(3, "0")}`;
+}
+function resetTaskCounter(startFrom = 0) {
+  taskCounter = startFrom;
+}
+function setTaskCounter(value) {
+  taskCounter = value;
+}
+var taskCounter;
+var init_id = __esm({
+  "src/utils/id.ts"() {
+    "use strict";
+    taskCounter = 0;
+  }
+});
+
+// src/task/lock.ts
+import lockfile from "proper-lockfile";
+import { access, writeFile } from "fs/promises";
+async function ensureFileExists(filePath) {
+  try {
+    await access(filePath);
+  } catch {
+    await writeFile(filePath, "", "utf-8");
+  }
+}
+async function acquireLock(filePath) {
+  await ensureFileExists(filePath);
+  const release = await lockfile.lock(filePath, {
+    stale: 1e4,
+    retries: {
+      retries: 5,
+      minTimeout: 100,
+      maxTimeout: 1e3
+    }
+  });
+  return release;
+}
+async function withLock(filePath, fn) {
+  const release = await acquireLock(filePath);
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+var init_lock = __esm({
+  "src/task/lock.ts"() {
+    "use strict";
+  }
+});
+
+// src/task/manager.ts
+var manager_exports = {};
+__export(manager_exports, {
+  TaskManager: () => TaskManager
+});
+import { readFile, writeFile as writeFile2, access as access2 } from "fs/promises";
+import EventEmitter from "eventemitter3";
+var TaskManager;
+var init_manager = __esm({
+  "src/task/manager.ts"() {
+    "use strict";
+    init_id();
+    init_parser();
+    init_writer();
+    init_lock();
+    TaskManager = class extends EventEmitter {
+      filePath;
+      projectName;
+      parser;
+      writer;
+      constructor(options) {
+        super();
+        this.filePath = options.filePath;
+        this.projectName = options.projectName;
+        this.parser = new TaskParser();
+        this.writer = new TaskWriter();
+      }
+      async ensureFile() {
+        try {
+          await access2(this.filePath);
+        } catch {
+          await writeFile2(this.filePath, "", "utf-8");
+        }
+      }
+      async load() {
+        await this.ensureFile();
+        const content = await readFile(this.filePath, "utf-8");
+        const { tasks } = this.parser.parse(content);
+        return tasks;
+      }
+      async save(tasks) {
+        await withLock(this.filePath, async () => {
+          const content = this.writer.write(this.projectName, tasks);
+          await writeFile2(this.filePath, content, "utf-8");
+        });
+      }
+      async getTask(id) {
+        const tasks = await this.load();
+        return tasks.find((t) => t.id === id);
+      }
+      async getTasks(filter) {
+        const tasks = await this.load();
+        if (!filter) {
+          return tasks;
+        }
+        return tasks.filter((task) => {
+          if (filter.status && filter.status.length > 0) {
+            if (!filter.status.includes(task.status)) {
+              return false;
+            }
+          }
+          if (filter.assignee !== void 0) {
+            if (task.assignee !== filter.assignee) {
+              return false;
+            }
+          }
+          if (filter.priority && filter.priority.length > 0) {
+            if (!filter.priority.includes(task.priority)) {
+              return false;
+            }
+          }
+          if (filter.tags && filter.tags.length > 0) {
+            if (!filter.tags.some((tag) => task.tags.includes(tag))) {
+              return false;
+            }
+          }
+          return true;
+        });
+      }
+      async createTask(data) {
+        const tasks = await this.load();
+        const maxId = this.extractMaxTaskNumber(tasks);
+        setTaskCounter(maxId);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const task = {
+          id: generateTaskId(),
+          title: data.title,
+          description: data.description ?? data.title,
+          status: "pending",
+          priority: data.priority,
+          assignee: null,
+          dependencies: data.dependencies ?? [],
+          tags: data.tags ?? [],
+          createdAt: now,
+          updatedAt: now,
+          completedAt: null,
+          notes: []
+        };
+        tasks.push(task);
+        await this.save(tasks);
+        this.emit("task:created", task);
+        return task;
+      }
+      async updateTask(id, update) {
+        const tasks = await this.load();
+        const index = tasks.findIndex((t) => t.id === id);
+        if (index === -1) {
+          throw new Error(`Task not found: ${id}`);
+        }
+        const task = tasks[index];
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        if (update.status !== void 0) {
+          task.status = update.status;
+          if (update.status === "done") {
+            task.completedAt = now;
+          }
+        }
+        if (update.assignee !== void 0) {
+          task.assignee = update.assignee;
+        }
+        if (update.priority !== void 0) {
+          task.priority = update.priority;
+        }
+        if (update.notes !== void 0) {
+          task.notes = update.notes;
+        }
+        task.updatedAt = now;
+        tasks[index] = task;
+        await this.save(tasks);
+        this.emit("task:updated", task);
+        return task;
+      }
+      async assignTask(id, agentId) {
+        const tasks = await this.load();
+        const index = tasks.findIndex((t) => t.id === id);
+        if (index === -1) {
+          throw new Error(`Task not found: ${id}`);
+        }
+        const task = tasks[index];
+        task.assignee = agentId;
+        task.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        tasks[index] = task;
+        await this.save(tasks);
+        this.emit("task:assigned", task);
+        return task;
+      }
+      async completeTask(id) {
+        const tasks = await this.load();
+        const index = tasks.findIndex((t) => t.id === id);
+        if (index === -1) {
+          throw new Error(`Task not found: ${id}`);
+        }
+        const task = tasks[index];
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        task.status = "done";
+        task.completedAt = now;
+        task.updatedAt = now;
+        tasks[index] = task;
+        await this.save(tasks);
+        this.emit("task:completed", task);
+        return task;
+      }
+      extractMaxTaskNumber(tasks) {
+        let max = 0;
+        for (const task of tasks) {
+          const match = task.id.match(/^T-(\d+)$/);
+          if (match) {
+            const num = parseInt(match[1], 10);
+            if (num > max) {
+              max = num;
+            }
+          }
+        }
+        return max;
+      }
+    };
+  }
+});
+
+// src/utils/logger.ts
+import pino from "pino";
+import { openSync, closeSync, writeSync, mkdirSync } from "fs";
+import { dirname } from "path";
+function createLogger(name, logFile) {
+  const stream = logFile ? new SyncFileStream(logFile) : null;
+  return pino(
+    {
+      name,
+      level: "trace"
+    },
+    stream ?? { write: () => {
+    } }
+    // No-op stream if no log file
+  );
+}
+var SyncFileStream;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    SyncFileStream = class {
+      constructor(destination) {
+        this.destination = destination;
+        try {
+          mkdirSync(dirname(destination), { recursive: true });
+          this.fd = openSync(destination, "a");
+        } catch {
+        }
+      }
+      fd = null;
+      write(chunk) {
+        if (this.fd !== null) {
+          try {
+            writeSync(this.fd, chunk);
+          } catch {
+          }
+        }
+      }
+      end() {
+        if (this.fd !== null) {
+          closeSync(this.fd);
+          this.fd = null;
+        }
+      }
+    };
+  }
+});
+
+// src/agent/lifecycle.ts
+import { execa } from "execa";
+import treeKill from "tree-kill";
+import { EventEmitter as EventEmitter2 } from "eventemitter3";
+function killProcessTree(pid, signal) {
+  return new Promise((resolve, reject) => {
+    treeKill(pid, signal, (err) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+var logger, AgentProcess;
+var init_lifecycle = __esm({
+  "src/agent/lifecycle.ts"() {
+    "use strict";
+    init_logger();
+    logger = createLogger("agent-process");
+    AgentProcess = class extends EventEmitter2 {
+      constructor(config) {
+        super();
+        this.config = config;
+        this.state = {
+          config,
+          status: "idle",
+          pid: null,
+          sessionId: null,
+          currentTask: null,
+          startedAt: null,
+          lastActivityAt: null,
+          totalCostUsd: 0,
+          turnCount: 0,
+          totalInputTokens: 0,
+          totalOutputTokens: 0,
+          totalCacheReadTokens: 0,
+          totalCacheCreationTokens: 0,
+          error: null,
+          resultError: null,
+          rateLimited: false,
+          rateLimitResetAt: null
+        };
+      }
+      subprocess = null;
+      state;
+      streamBuffer = "";
+      get id() {
+        return this.config.id;
+      }
+      get currentState() {
+        return { ...this.state };
+      }
+      /**
+       * Set the current task this agent is working on (task ID + title).
+       */
+      setCurrentTask(taskInfo) {
+        this.state.currentTask = taskInfo;
+      }
+      /**
+       * Spawn a claude CLI process with the given prompt.
+       */
+      async spawn(prompt) {
+        if (this.subprocess) {
+          throw new Error(`Agent ${this.id} already has a running process`);
+        }
+        const args = this.buildArgs();
+        this.setStatus("starting");
+        const cmd = this.config.claudeCommand ?? "claude";
+        logger.info(
+          { agentId: this.id, cmd, argCount: args.length, promptLength: prompt.length },
+          "Spawning agent process"
+        );
+        this.subprocess = execa(cmd, args, {
+          input: prompt,
+          cwd: this.config.workingDirectory,
+          env: this.config.claudeEnv ? { ...process.env, ...this.config.claudeEnv } : void 0,
+          stdout: "pipe",
+          stderr: "pipe",
+          reject: false
+        });
+        this.state.pid = this.subprocess.pid ?? null;
+        this.state.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.state.error = null;
+        this.state.resultError = null;
+        this.state.rateLimited = false;
+        this.state.rateLimitResetAt = null;
+        logger.info({ agentId: this.id, pid: this.state.pid }, "Agent process started");
+        this.setStatus("running");
+        this.emitOutput("system", { message: `Process started (PID: ${this.state.pid ?? "unknown"})`, cmd, argCount: args.length });
+        this.processStream().catch((err) => {
+          this.state.error = err instanceof Error ? err.message : String(err);
+          this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        });
+        this.processStderr().catch(() => {
+        });
+      }
+      /**
+       * Resume a previous session with a new prompt.
+       */
+      async resume(prompt) {
+        if (!this.state.sessionId) {
+          throw new Error(`Agent ${this.id} has no session to resume`);
+        }
+        if (this.subprocess) {
+          throw new Error(`Agent ${this.id} already has a running process`);
+        }
+        const args = this.buildArgs();
+        args.push("--resume", this.state.sessionId);
+        this.setStatus("starting");
+        const cmd = this.config.claudeCommand ?? "claude";
+        logger.info({ agentId: this.id, cmd, sessionId: this.state.sessionId }, "Resuming agent process");
+        this.subprocess = execa(cmd, args, {
+          input: prompt,
+          cwd: this.config.workingDirectory,
+          env: this.config.claudeEnv ? { ...process.env, ...this.config.claudeEnv } : void 0,
+          stdout: "pipe",
+          stderr: "pipe",
+          reject: false
+        });
+        this.state.pid = this.subprocess.pid ?? null;
+        this.state.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+        this.state.error = null;
+        this.state.resultError = null;
+        this.state.rateLimited = false;
+        this.state.rateLimitResetAt = null;
+        logger.info({ agentId: this.id, pid: this.state.pid }, "Agent process resumed");
+        this.setStatus("running");
+        this.emitOutput("system", { message: `Process resumed (PID: ${this.state.pid ?? "unknown"})` });
+        this.processStream().catch((err) => {
+          this.state.error = err instanceof Error ? err.message : String(err);
+          this.emit("error", err instanceof Error ? err : new Error(String(err)));
+        });
+        this.processStderr().catch(() => {
+        });
+      }
+      /**
+       * Graceful stop: SIGTERM, wait, then force kill.
+       */
+      async stop(timeoutMs = 1e4) {
+        if (!this.subprocess || !this.state.pid) {
+          return;
+        }
+        this.setStatus("stopping");
+        try {
+          this.subprocess.kill("SIGTERM");
+          const timeoutPromise = new Promise(
+            (resolve) => setTimeout(() => resolve("timeout"), timeoutMs)
+          );
+          const exitPromise = this.subprocess.then(() => "exited");
+          const result = await Promise.race([exitPromise, timeoutPromise]);
+          if (result === "timeout" && this.state.pid) {
+            await killProcessTree(this.state.pid, "SIGKILL");
+          }
+        } catch {
+          if (this.state.pid) {
+            try {
+              await killProcessTree(this.state.pid, "SIGKILL");
+            } catch {
+            }
+          }
+        } finally {
+          this.subprocess = null;
+          this.setStatus("stopped");
+        }
+      }
+      /**
+       * Force kill immediately.
+       */
+      async kill() {
+        if (!this.subprocess || !this.state.pid) {
+          return;
+        }
+        try {
+          await killProcessTree(this.state.pid, "SIGKILL");
+        } catch {
+        } finally {
+          this.subprocess = null;
+          this.setStatus("stopped");
+        }
+      }
+      /**
+       * Build CLI arguments for the claude command.
+       * The prompt is piped via stdin, not passed as a positional argument.
+       */
+      buildArgs() {
+        const args = [
+          "--print",
+          "--output-format",
+          "stream-json",
+          "--verbose",
+          "--model",
+          this.config.model ?? "sonnet"
+        ];
+        if (this.config.permissionMode && this.config.permissionMode !== "default") {
+          args.push("--permission-mode", this.config.permissionMode);
+        }
+        if (this.config.systemPrompt) {
+          args.push("--system-prompt", this.config.systemPrompt);
+        }
+        if (this.config.allowedTools && this.config.allowedTools.length > 0) {
+          args.push("--allowedTools", this.config.allowedTools.join(","));
+        }
+        if (this.config.maxBudgetUsd !== void 0) {
+          args.push("--max-budget-usd", String(this.config.maxBudgetUsd));
+        }
+        if (this.config.claudeArgs && this.config.claudeArgs.length > 0) {
+          args.push(...this.config.claudeArgs);
+        }
+        return args;
+      }
+      /**
+       * Parse NDJSON stream from claude stdout.
+       * Reads stdout line by line and emits typed events.
+       */
+      async processStream() {
+        if (!this.subprocess || !this.subprocess.stdout) {
+          return;
+        }
+        const stdout = this.subprocess.stdout;
+        for await (const chunk of stdout) {
+          const text = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+          this.streamBuffer += text;
+          let newlineIndex;
+          while ((newlineIndex = this.streamBuffer.indexOf("\n")) !== -1) {
+            const line = this.streamBuffer.slice(0, newlineIndex).trim();
+            this.streamBuffer = this.streamBuffer.slice(newlineIndex + 1);
+            if (!line) {
+              continue;
+            }
+            try {
+              const parsed = JSON.parse(line);
+              const eventType = parsed.type ?? "unknown";
+              const now = (/* @__PURE__ */ new Date()).toISOString();
+              const streamEvent = {
+                type: eventType,
+                agentId: this.id,
+                timestamp: now,
+                data: parsed
+              };
+              if (eventType === "system" && typeof parsed.session_id === "string") {
+                this.state.sessionId = parsed.session_id;
+              }
+              if (eventType === "result") {
+                if (typeof parsed.cost_usd === "number") {
+                  this.state.totalCostUsd = parsed.cost_usd;
+                }
+                if (typeof parsed.num_turns === "number") {
+                  this.state.turnCount = parsed.num_turns;
+                }
+                const usage = parsed.usage;
+                if (usage && typeof usage === "object") {
+                  if (typeof usage.input_tokens === "number") {
+                    this.state.totalInputTokens = usage.input_tokens;
+                  }
+                  if (typeof usage.output_tokens === "number") {
+                    this.state.totalOutputTokens = usage.output_tokens;
+                  }
+                  if (typeof usage.cache_read_input_tokens === "number") {
+                    this.state.totalCacheReadTokens = usage.cache_read_input_tokens;
+                  }
+                  if (typeof usage.cache_creation_input_tokens === "number") {
+                    this.state.totalCacheCreationTokens = usage.cache_creation_input_tokens;
+                  }
+                }
+                if (parsed.is_error === true) {
+                  const resultText = typeof parsed.result === "string" ? parsed.result : "";
+                  this.state.resultError = resultText || "Unknown API error";
+                  if (resultText.includes("429") || resultText.includes("Usage limit reached") || resultText.includes("rate limit")) {
+                    this.state.rateLimited = true;
+                    const resetMatch = resultText.match(/will reset at ([0-9T :.-]+)/);
+                    if (resetMatch) {
+                      this.state.rateLimitResetAt = resetMatch[1].trim();
+                    }
+                    logger.warn(
+                      { agentId: this.id, resetAt: this.state.rateLimitResetAt },
+                      "Agent hit API rate limit (429)"
+                    );
+                  }
+                }
+              }
+              this.state.lastActivityAt = now;
+              this.emit("output", streamEvent);
+            } catch {
+              this.emitOutput("system", { message: `[stdout] ${line}` });
+            }
+          }
+        }
+        const result = await this.subprocess;
+        const exitCode = result?.exitCode ?? null;
+        this.subprocess = null;
+        if (this.state.resultError) {
+          this.state.error = this.state.resultError;
+          this.emitOutput("error", {
+            error: this.state.resultError,
+            rateLimited: this.state.rateLimited,
+            rateLimitResetAt: this.state.rateLimitResetAt
+          });
+          this.setStatus("error");
+        } else if (exitCode === 0 || exitCode === null) {
+          this.setStatus("stopped");
+        } else {
+          this.state.error = `Process exited with code ${exitCode}`;
+          this.emitOutput("error", { error: `Process exited with code ${exitCode}`, stderr: result?.stderr?.slice(0, 500) });
+          this.setStatus("error");
+        }
+        this.emit("stopped", exitCode);
+      }
+      /**
+       * Read stderr and emit lines as error events so they're visible.
+       */
+      async processStderr() {
+        if (!this.subprocess || !this.subprocess.stderr) {
+          return;
+        }
+        let stderrBuffer = "";
+        const stderr = this.subprocess.stderr;
+        for await (const chunk of stderr) {
+          const text = typeof chunk === "string" ? chunk : chunk.toString("utf-8");
+          stderrBuffer += text;
+          let newlineIndex;
+          while ((newlineIndex = stderrBuffer.indexOf("\n")) !== -1) {
+            const line = stderrBuffer.slice(0, newlineIndex).trim();
+            stderrBuffer = stderrBuffer.slice(newlineIndex + 1);
+            if (line) {
+              logger.warn({ agentId: this.id, stderr: line }, "Agent stderr output");
+              this.emitOutput("error", { error: line, source: "stderr" });
+            }
+          }
+        }
+        const remaining = stderrBuffer.trim();
+        if (remaining) {
+          logger.warn({ agentId: this.id, stderr: remaining }, "Agent stderr output");
+          this.emitOutput("error", { error: remaining, source: "stderr" });
+        }
+      }
+      /**
+       * Emit a synthetic output event.
+       */
+      emitOutput(type, data) {
+        this.emit("output", {
+          type,
+          agentId: this.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          data
+        });
+      }
+      /**
+       * Update internal state and emit status change events.
+       */
+      setStatus(status) {
+        const oldStatus = this.state.status;
+        if (oldStatus === status) {
+          return;
+        }
+        this.state.status = status;
+        this.emit("status-changed", oldStatus, status);
+      }
+    };
+  }
+});
+
+// src/agent/pool.ts
+var pool_exports = {};
+__export(pool_exports, {
+  AgentPool: () => AgentPool
+});
+import { EventEmitter as EventEmitter3 } from "eventemitter3";
+var AgentPool;
+var init_pool = __esm({
+  "src/agent/pool.ts"() {
+    "use strict";
+    init_lifecycle();
+    AgentPool = class extends EventEmitter3 {
+      agents = /* @__PURE__ */ new Map();
+      /**
+       * Spawn a new agent process with the given config and initial prompt.
+       */
+      async spawnAgent(config, prompt) {
+        if (this.agents.has(config.id)) {
+          throw new Error(`Agent with id "${config.id}" already exists in the pool`);
+        }
+        const agent = new AgentProcess(config);
+        this.agents.set(config.id, agent);
+        this.attachListeners(agent);
+        await agent.spawn(prompt);
+        this.emit("agent:spawned", agent.id, agent);
+        return agent;
+      }
+      /**
+       * Stop a specific agent by ID with an optional timeout.
+       */
+      async stopAgent(id, timeoutMs) {
+        const agent = this.agents.get(id);
+        if (!agent) {
+          throw new Error(`Agent "${id}" not found in pool`);
+        }
+        await agent.stop(timeoutMs);
+      }
+      /**
+       * Stop all agents concurrently. Uses Promise.allSettled for graceful handling.
+       */
+      async stopAll(timeoutMs) {
+        const stopPromises = Array.from(this.agents.values()).map(
+          (agent) => agent.stop(timeoutMs)
+        );
+        await Promise.allSettled(stopPromises);
+      }
+      /**
+       * Remove a stopped agent from the pool so it can be re-spawned.
+       */
+      removeAgent(id) {
+        const agent = this.agents.get(id);
+        if (!agent) return;
+        const status = agent.currentState.status;
+        if (status !== "stopped" && status !== "error") {
+          throw new Error(`Cannot remove agent "${id}" with status "${status}" \u2014 must be stopped or error`);
+        }
+        this.agents.delete(id);
+      }
+      /**
+       * Get an agent process by ID.
+       */
+      getAgent(id) {
+        return this.agents.get(id);
+      }
+      /**
+       * Get all agents with a specific role.
+       */
+      getAgentsByRole(role) {
+        return Array.from(this.agents.values()).filter(
+          (agent) => agent.currentState.config.role === role
+        );
+      }
+      /**
+       * Get all agents with a specific status.
+       */
+      getAgentsByStatus(status) {
+        return Array.from(this.agents.values()).filter(
+          (agent) => agent.currentState.status === status
+        );
+      }
+      /**
+       * Get all agents in the pool.
+       */
+      getAllAgents() {
+        return Array.from(this.agents.values());
+      }
+      /**
+       * Get aggregate statistics across all agents.
+       */
+      getStats() {
+        let running = 0;
+        let idle = 0;
+        let stopped = 0;
+        let totalCostUsd = 0;
+        for (const agent of this.agents.values()) {
+          const state = agent.currentState;
+          switch (state.status) {
+            case "running":
+            case "starting":
+              running++;
+              break;
+            case "idle":
+              idle++;
+              break;
+            case "stopped":
+            case "stopping":
+            case "error":
+              stopped++;
+              break;
+          }
+          totalCostUsd += state.totalCostUsd;
+        }
+        return {
+          total: this.agents.size,
+          running,
+          idle,
+          stopped,
+          totalCostUsd
+        };
+      }
+      /**
+       * Attach event forwarding listeners from an agent process to the pool.
+       */
+      attachListeners(agent) {
+        agent.on("output", (event) => {
+          this.emit("agent:output", event);
+        });
+        agent.on("status-changed", (oldStatus, newStatus) => {
+          this.emit("agent:status-changed", agent.id, oldStatus, newStatus);
+        });
+        agent.on("error", (error) => {
+          this.emit("agent:error", agent.id, error);
+        });
+        agent.on("stopped", (exitCode) => {
+          this.emit("agent:stopped", agent.id, exitCode);
+        });
+      }
+    };
+  }
+});
+
+// src/agent/roles.ts
+function buildTechStackSection(ts) {
+  if (!ts) return "";
+  const lines = ["# Tech Stack"];
+  if (ts.frontend) lines.push(`- **Frontend**: ${ts.frontend}`);
+  if (ts.uiLibrary) lines.push(`- **UI Library**: ${ts.uiLibrary}`);
+  if (ts.backend) lines.push(`- **Backend**: ${ts.backend}`);
+  if (ts.database) lines.push(`- **Database**: ${ts.database}`);
+  if (ts.other) lines.push(`- **Other**: ${ts.other}`);
+  if (lines.length === 1) return "";
+  lines.push("", "Use these technologies in your work. Follow their conventions and best practices.");
+  return lines.join("\n");
+}
+function getDefaultSystemPrompt(params) {
+  const {
+    role,
+    agentId,
+    projectName,
+    todoFilePath,
+    inboxPath,
+    outboxPath,
+    workingDirectory,
+    techStack
+  } = params;
+  const techStackSection = buildTechStackSection(techStack);
+  return `
+# Agent Identity
+
+You are **${agentId}**, a ${role} agent working on the **${projectName}** project.
+
+${ROLE_DESCRIPTIONS[role]}
+
+# Working Environment
+
+- **Working Directory**: ${workingDirectory}
+- **Todo File**: ${todoFilePath}
+- **Inbox Directory**: ${inboxPath}
+- **Outbox Directory**: ${outboxPath}
+
+You should regularly check the todo file for task updates and your inbox for new messages.
+When you need to communicate with other agents, write message files to your outbox.
+
+${techStackSection ? techStackSection + "\n\n" : ""}${TODO_FORMAT_INSTRUCTIONS}
+
+${MESSAGE_FORMAT_INSTRUCTIONS}
+
+${ROLE_SPECIFIC_INSTRUCTIONS[role]}
+
+${PROCESS_SAFETY_RULES}
+
+## Architecture Compliance
+
+If an \`ARCHITECTURE.md\` file exists in the working directory, you MUST read it before starting any task. It is the source of truth for project structure, component boundaries, data models, API contracts, and technical decisions.
+
+- **Follow the architecture.** Do not contradict decisions documented in ARCHITECTURE.md.
+- **Check before creating.** Before adding new files, directories, or modules, verify the architecture allows it and place them where it specifies.
+- **Flag conflicts.** If a task asks you to do something that conflicts with ARCHITECTURE.md, do NOT silently proceed. Send a message to the orchestrator or architect describing the conflict and wait for guidance.
+- **Keep it updated.** If you are the architect or technical-writer and your work changes the architecture, update ARCHITECTURE.md to reflect the new state.
+
+## Asking the User Questions
+
+To ask the user a question, send a message with \`to: "user"\` and \`type: "question"\` to your outbox. Only ask when you genuinely cannot proceed without user input.
+
+# General Guidelines
+
+- Identify yourself as "${agentId}" in messages
+- Check your inbox at the start of each task cycle
+- Update the todo file when you start or complete work
+- Send task-blocked messages immediately when you hit a blocker
+- Focus on your role; do not overstep into other agents' responsibilities
+`.trim();
+}
+var ROLE_DESCRIPTIONS, TODO_FORMAT_INSTRUCTIONS, MESSAGE_FORMAT_INSTRUCTIONS, PROCESS_SAFETY_RULES, ROLE_SPECIFIC_INSTRUCTIONS;
+var init_roles = __esm({
+  "src/agent/roles.ts"() {
+    "use strict";
+    ROLE_DESCRIPTIONS = {
+      orchestrator: "The orchestrator is the top-level coordinator. It breaks down high-level goals into tasks, assigns work to other agents, monitors progress, resolves conflicts, and ensures the overall project stays on track. It communicates directives and reviews results from all other agents.",
+      "project-manager": "The project manager tracks priorities, manages dependencies between tasks, updates timelines, and ensures work is progressing according to plan. It identifies blockers, re-prioritizes when needed, and keeps the task board organized and up to date.",
+      architect: "The architect designs the system architecture, makes key technical decisions, defines API contracts, reviews design proposals, and ensures the codebase maintains structural integrity. It provides guidance on patterns, technology choices, and code organization.",
+      developer: "The developer implements features, writes production code, fixes bugs, writes tests, and ensures code quality. It follows the architecture guidelines, writes clean and well-tested code, and reports progress on assigned tasks.",
+      designer: "The designer handles UI/UX design decisions, creates component structures, defines styling and theming systems, ensures accessibility standards, and maintains visual consistency across the application.",
+      "qa-engineer": "The QA engineer ensures software quality through comprehensive testing strategies. It writes and maintains test suites (unit, integration, e2e), identifies edge cases, validates requirements coverage, and reports bugs with clear reproduction steps.",
+      devops: "The DevOps engineer handles infrastructure, CI/CD pipelines, deployment configurations, containerization (Docker), environment setup, monitoring, and build tooling. It ensures the project can be reliably built, tested, and deployed.",
+      "technical-writer": "The technical writer creates and maintains project documentation including README files, API documentation, architecture decision records, user guides, setup instructions, and inline code documentation. It ensures docs stay accurate and accessible.",
+      "code-reviewer": "The code reviewer examines completed work for correctness, security, performance, and adherence to project standards. It provides constructive feedback, identifies potential issues, and verifies that changes align with the architecture."
+    };
+    TODO_FORMAT_INSTRUCTIONS = `
+## Todo File Format
+
+The shared todo file uses markdown: sections for Pending, In Progress, Done, Blocked.
+
+Each task line: \`- [ ] T-XXX: Title [priority:high] [assignee:agent-id]\` with a description on the indented line below. Mark done tasks with \`[x]\`. Use \`[blocked-by:T-XXX]\` for dependencies.
+`.trim();
+    MESSAGE_FORMAT_INSTRUCTIONS = `
+## Messaging System
+
+**Inbox**: Check your inbox directory for JSON message files. Read all pending messages regularly.
+**Outbox**: To send a message, write a JSON file to your outbox directory.
+
+Message format: \`{ "message": { "id": "unique-id", "type": "<type>", "from": "<your-id>", "to": "<recipient-id>", "subject": "...", "body": "...", "priority": "normal|urgent", "timestamp": "ISO date" }, "status": "pending" }\`
+
+Types: task-assignment, task-update, task-complete, task-blocked, question, answer, review-request, review-result, system, directive
+`.trim();
+    PROCESS_SAFETY_RULES = `
+## Process Safety Rules
+
+You run in a shared multi-agent environment. Resource-intensive processes starve other agents and destabilize the system. The following are **strictly forbidden**:
+
+**No Docker**: \`docker build\`, \`docker run\`, \`docker compose up\`, \`docker pull/push/exec\`, \`podman build/run\`. You MAY write Dockerfiles and compose configs.
+
+**No servers**: \`npm run dev\`, \`npm start\`, \`next dev\`, \`vite\`, \`flask run\`, \`uvicorn\`, \`rails server\`, \`nodemon\`, or any process that listens on a port.
+
+**Instead**: Write code and config files. Run only targeted tests (single file). Use lightweight commands (lint, type-check single files). If you need a build or server, message the user.
+`.trim();
+    ROLE_SPECIFIC_INSTRUCTIONS = {
+      orchestrator: `
+## Orchestrator-Specific Instructions
+
+You are the central coordinator for this project. Your responsibilities:
+
+1. **Goal Decomposition**: Break down high-level project goals into concrete, actionable tasks.
+   Write these tasks to the shared todo file with clear descriptions and priorities.
+
+2. **Task Assignment**: Assign tasks to the most appropriate agents based on their roles:
+   - Architecture and design decisions -> architect
+   - Implementation and coding -> developer
+   - UI/UX, styling, components -> designer
+   - Testing, QA, test suites -> qa-engineer
+   - CI/CD, Docker, deployment, infrastructure -> devops
+   - Documentation, README, API docs -> technical-writer
+   - Code review, security review -> code-reviewer
+   - Scheduling and tracking -> project-manager
+
+3. **Progress Monitoring**: Regularly check the todo file and inbox for updates. Track which
+   tasks are in progress, completed, or blocked.
+
+4. **Coordination**: When tasks have dependencies, ensure they are executed in the right order.
+   Resolve conflicts between agents. Re-assign work if an agent is overloaded. When QA
+   returns a task, ensure the project-manager reassigns it to a developer promptly \u2014 blocked
+   tasks stall all their dependents and can halt the entire project.
+
+5. **Quality Control**: Review completed work by examining task completion messages.
+   Request revisions if needed by sending review-request messages.
+
+6. **Decision Making**: Make final calls on technical disputes, prioritization conflicts,
+   and scope questions. Send directives when needed.
+
+Do NOT implement code yourself. Your job is to coordinate, not to code.
+`.trim(),
+      "project-manager": `
+## Project Manager-Specific Instructions
+
+You manage the project timeline, priorities, and dependencies. Your responsibilities:
+
+1. **Priority Management**: Keep tasks properly prioritized. Escalate critical items.
+   Re-order work based on changing requirements or blockers.
+
+2. **Dependency Tracking**: Identify and document task dependencies using blocked-by tags.
+   Alert the orchestrator when circular dependencies or bottlenecks are detected.
+
+3. **Timeline Updates**: Track progress rates and estimate remaining work. Update task
+   descriptions with timeline notes when appropriate.
+
+4. **Blocker Resolution**: When a task is blocked, investigate the cause by checking
+   dependent tasks and sending questions to the relevant agents.
+
+5. **Status Reporting**: Periodically summarize project status for the orchestrator,
+   including completed tasks, active work, blockers, and risks.
+
+6. **Todo Organization**: Keep the todo file clean and well-organized. Move completed
+   tasks to the Done section. Archive old items. Ensure consistent formatting.
+
+7. **Task Reassignment & QA Returns**: You have the authority to reassign tasks between
+   agents. This is critical for unblocking the pipeline. When QA reports a blocker on a
+   task (missing files, broken implementation, failing tests), you MUST:
+   a. Move the task from Blocked back to In Progress in the todo file.
+   b. Change the assignee from the qa-engineer to an available developer.
+   c. Add a note: \`> [returned] Returned from QA: <reason>\`
+   d. Set the priority to high (QA returns are rework and block downstream tasks).
+   e. Send a task-assignment message to the developer with the QA findings.
+   f. Send a task-update message to the orchestrator about the reassignment.
+
+   Do NOT leave QA-blocked tasks sitting. Every blocked task potentially stalls all its
+   dependents. Act on QA returns immediately \u2014 they are your highest-priority pipeline work.
+
+Focus on process and organization. Do NOT make technical decisions or write code.
+`.trim(),
+      architect: `
+## Architect-Specific Instructions
+
+You design the system architecture and make technical decisions. Your responsibilities:
+
+1. **System Design**: Create and maintain the technical architecture. Document key
+   design decisions, API contracts, data models, and component boundaries.
+
+2. **Technology Choices**: Evaluate and select appropriate technologies, libraries,
+   and patterns. Justify decisions with clear reasoning.
+
+3. **Code Organization**: Define the project structure, module boundaries, naming
+   conventions, and file organization patterns.
+
+4. **Design Reviews**: When developers send review-request messages, evaluate the
+   approach against the architecture. Provide specific, actionable feedback.
+
+5. **Pattern Guidance**: Establish coding patterns, error handling strategies,
+   and best practices. Document these for the development team.
+
+6. **Technical Debt**: Identify areas of technical debt and propose refactoring
+   plans when appropriate.
+
+7. **ARCHITECTURE.md Ownership**: You own ARCHITECTURE.md. Keep it current whenever you
+   make design decisions. All other agents rely on it as the source of truth \u2014 if it is
+   outdated or missing, they will make incorrect assumptions.
+
+You may write architectural documentation, design specs, and configuration files,
+but delegate implementation work to developers.
+`.trim(),
+      developer: `
+## Developer-Specific Instructions
+
+You implement features, write code, and fix bugs. Your responsibilities:
+
+1. **Implementation**: Read ARCHITECTURE.md before writing any code. Follow its structure,
+   patterns, and conventions. Implement features assigned to you in the todo file.
+
+2. **Testing**: Write unit tests, integration tests, and any other tests needed to
+   verify your work. Aim for good test coverage on critical paths.
+
+3. **Bug Fixes**: When assigned bugs, investigate the root cause, implement a fix,
+   and verify with tests.
+
+4. **Code Quality**: Follow established patterns and conventions. Write clear comments
+   where logic is complex. Keep functions focused and composable.
+
+5. **Progress Updates**: When you start, complete, or get blocked on a task, update
+   the todo file and send appropriate messages to the orchestrator.
+
+6. **Review & QA Response**: When you receive review-result or task-assignment messages
+   with QA feedback, treat them as high priority. QA returns mean a task was sent back
+   because implementation was missing or broken \u2014 read the \`[BLOCKER]\` and \`[returned]\`
+   notes in the todo file, fix the root cause, then mark the task done so QA can re-verify.
+
+7. **Process Boundaries**: Your job is to write code and tests, NOT to build, compile, or
+   run the project. Do not start servers or run full test suites. If you need to verify a specific
+   piece of logic, run a single targeted test file. Write the code; let the CI pipeline
+   and the user handle builds and deployments.
+
+Focus on writing excellent code. Ask the architect (via messages) if you are unsure
+about design decisions. Report blockers promptly.
+`.trim(),
+      designer: `
+## Designer-Specific Instructions
+
+You handle UI/UX design and visual implementation. Your responsibilities:
+
+1. **Component Design**: Design and implement UI components with clear, reusable
+   structures. Define component APIs (props, events, slots).
+
+2. **Styling System**: Create and maintain the design system: colors, typography,
+   spacing, breakpoints, and theme configuration.
+
+3. **Layout Architecture**: Design page layouts, navigation structures, and
+   responsive behavior. Ensure consistency across views.
+
+4. **Accessibility**: Ensure all UI components meet accessibility standards (WCAG).
+   Include proper ARIA attributes, keyboard navigation, and screen reader support.
+
+5. **Visual Consistency**: Maintain visual coherence across the application.
+   Review UI-related code changes for design consistency.
+
+6. **Design Documentation**: Document design tokens, component usage patterns,
+   and visual guidelines for the development team.
+
+You write UI code (components, styles, layouts). Coordinate with developers on
+integration and with the architect on component architecture.
+`.trim(),
+      "qa-engineer": `
+## QA Engineer-Specific Instructions
+
+You ensure software quality through testing and validation. Your responsibilities:
+
+1. **Test Strategy**: Design comprehensive testing strategies covering unit tests,
+   integration tests, and end-to-end tests. Identify critical paths that need coverage.
+
+2. **Test Implementation**: Write automated tests using the project's testing framework.
+   Cover happy paths, edge cases, error conditions, and boundary values.
+
+3. **Bug Reporting & QA Returns**: When you find bugs or missing implementation, you must
+   act immediately \u2014 do not just mark a task blocked and wait. Document the issue clearly
+   (reproduction steps, expected vs actual behavior, missing files), then:
+   a. Add a \`> [BLOCKER]\` note to the task in the todo file with specifics.
+   b. Send a task-blocked message to the **project-manager** (not just the orchestrator)
+      so they can reassign the task back to a developer.
+   c. Add a \`> [pipeline] Returned from QA to develop - <reason>\` note.
+   The project manager will handle reassignment. Do not keep working on a task that has
+   missing or fundamentally broken implementation \u2014 return it.
+
+4. **Requirements Validation**: Verify that implementations match the task descriptions
+   and acceptance criteria. Flag gaps between requirements and implementation.
+
+5. **Regression Testing**: Ensure new changes don't break existing functionality.
+   Maintain test suites that catch regressions early.
+
+6. **Test Documentation**: Document test coverage, testing patterns, and any manual
+   test procedures that cannot be automated.
+
+7. **Process Boundaries**: Write tests, but be cautious about executing them. Run only
+   targeted, specific test files \u2014 never a full test suite (e.g. \`npm test\` or \`pytest\`
+   with no arguments). A single test file that takes more than 60 seconds likely indicates
+   an integration test that depends on external services; skip it and flag it for manual
+   execution. Do not start servers, databases, or other services as part of testing.
+
+Focus on finding issues before they reach production. Coordinate with developers on
+bug fixes and with the architect on testability of the design.
+`.trim(),
+      devops: `
+## DevOps-Specific Instructions
+
+You handle infrastructure, deployment, and build tooling. Your responsibilities:
+
+1. **CI/CD Pipeline**: Set up and maintain continuous integration and deployment pipelines.
+   Configure build, test, lint, and deploy stages.
+
+2. **Containerization**: Create and maintain Dockerfiles, docker-compose configurations,
+   and container orchestration setups as needed.
+
+3. **Environment Configuration**: Set up development, staging, and production environment
+   configurations. Manage environment variables, secrets handling, and config files.
+
+4. **Build Tooling**: Configure and optimize build tools, bundlers, and compilation
+   pipelines. Ensure fast, reliable builds.
+
+5. **Monitoring & Logging**: Set up application monitoring, error tracking, health checks,
+   and structured logging where applicable.
+
+6. **Infrastructure as Code**: Define infrastructure using code (Terraform, CloudFormation,
+   etc.) when applicable. Document deployment procedures.
+
+7. **Process Boundaries**: You write configuration, you do NOT execute it. Do not run
+   \`docker build\`, \`docker run\`, \`docker compose up\`, or any Docker commands. Do not
+   run build pipelines, start servers, or execute deployment scripts. Write the Dockerfiles,
+   CI configs, and shell scripts \u2014 the actual execution happens in CI/CD or by the user.
+
+Write configuration files, scripts, and infrastructure code. Do NOT execute Docker
+commands, build pipelines, or deployment scripts in this environment. Coordinate with
+developers on build requirements and with the architect on deployment architecture.
+`.trim(),
+      "technical-writer": `
+## Technical Writer-Specific Instructions
+
+You create and maintain project documentation. Your responsibilities:
+
+1. **README & Setup Guides**: Write clear README files with project overview, setup
+   instructions, prerequisites, and quickstart guides.
+
+2. **API Documentation**: Document public APIs, endpoints, request/response formats,
+   authentication, and error codes. Keep API docs in sync with implementation.
+
+3. **Architecture Documentation**: Work with the architect to document system design,
+   data flow diagrams, component relationships, and design decisions (ADRs).
+
+4. **User Guides**: Write end-user documentation, tutorials, and how-to guides that
+   explain features and workflows in accessible language.
+
+5. **Code Documentation**: Review code for missing or outdated inline documentation.
+   Add JSDoc/docstrings to public interfaces, complex functions, and non-obvious logic.
+
+6. **Changelog & Release Notes**: Maintain changelogs and write release notes that
+   clearly communicate changes, fixes, and breaking changes.
+
+Write documentation files (markdown, JSDoc, etc.). Coordinate with all team members
+to ensure docs accurately reflect the current state of the project.
+`.trim(),
+      "code-reviewer": `
+## Code Reviewer-Specific Instructions
+
+You review completed work for quality and correctness. Your responsibilities:
+
+1. **Code Review**: Examine implementation code for correctness, readability, and
+   adherence to project conventions. Check for logic errors, off-by-one errors,
+   and edge case handling.
+
+2. **Security Review**: Identify potential security vulnerabilities: injection attacks,
+   authentication/authorization issues, data exposure, and insecure defaults.
+
+3. **Performance Review**: Flag performance anti-patterns: N+1 queries, unnecessary
+   re-renders, memory leaks, missing indexes, and inefficient algorithms.
+
+4. **Standards Compliance**: Verify code follows ARCHITECTURE.md, naming conventions,
+   file organization patterns, and coding standards. Flag deviations.
+
+5. **Feedback Delivery**: Provide specific, constructive feedback. Distinguish between
+   blocking issues and suggestions. Include code examples for recommended changes.
+
+6. **Verification**: After developers address review feedback, verify the changes
+   resolve the identified issues without introducing new problems.
+
+Do NOT implement changes yourself. Send review-result messages with specific feedback.
+Coordinate with the architect on design-level concerns and developers on implementation.
+`.trim()
+    };
+  }
+});
+
+// src/agent/config.ts
+var config_exports = {};
+__export(config_exports, {
+  loadAgentConfigs: () => loadAgentConfigs
+});
+import { readFileSync, existsSync } from "fs";
+import path from "path";
+function loadAgentConfigs(projectConfig) {
+  const configs = [];
+  const { settings } = projectConfig;
+  for (const roleConfig of projectConfig.agents) {
+    const count = roleConfig.count ?? 1;
+    for (let i = 1; i <= count; i++) {
+      const agentId = count > 1 ? `${roleConfig.role}-${i}` : roleConfig.role;
+      const systemPrompt = resolveSystemPrompt({
+        roleConfig,
+        agentId,
+        role: roleConfig.role,
+        projectConfig
+      });
+      const mergedArgs = [
+        ...settings.claudeArgs ?? [],
+        ...roleConfig.claudeArgs ?? []
+      ];
+      const mergedEnv = {
+        ...settings.claudeEnv ?? {},
+        ...roleConfig.claudeEnv ?? {}
+      };
+      const config = {
+        id: agentId,
+        role: roleConfig.role,
+        name: formatAgentName(roleConfig.role, count > 1 ? i : void 0),
+        model: roleConfig.model ?? settings.defaultModel,
+        systemPrompt,
+        allowedTools: roleConfig.allowedTools,
+        maxBudgetUsd: roleConfig.maxBudgetUsd,
+        workingDirectory: settings.workingDirectory,
+        permissionMode: roleConfig.permissionMode ?? "default",
+        claudeCommand: settings.claudeCommand,
+        claudeArgs: mergedArgs.length > 0 ? mergedArgs : void 0,
+        claudeEnv: Object.keys(mergedEnv).length > 0 ? mergedEnv : void 0,
+        maxTurns: roleConfig.maxTurns
+      };
+      configs.push(config);
+    }
+  }
+  return configs;
+}
+function resolveSystemPrompt(params) {
+  const { roleConfig, agentId, role, projectConfig } = params;
+  const { settings } = projectConfig;
+  if (roleConfig.systemPromptOverride) {
+    return roleConfig.systemPromptOverride;
+  }
+  if (roleConfig.systemPromptFile) {
+    const promptPath = path.isAbsolute(roleConfig.systemPromptFile) ? roleConfig.systemPromptFile : path.resolve(settings.workingDirectory, roleConfig.systemPromptFile);
+    return readFileSync(promptPath, "utf-8");
+  }
+  const localAgentsDir = path.resolve(settings.workingDirectory, ".agents");
+  const localPromptPath = path.join(localAgentsDir, `${role}.md`);
+  if (existsSync(localPromptPath)) {
+    try {
+      const content = readFileSync(localPromptPath, "utf-8").trim();
+      if (content) {
+        const todoFilePath2 = path.resolve(settings.workingDirectory, settings.todoFile);
+        const messagesDir2 = path.resolve(settings.workingDirectory, settings.messagesDirectory);
+        return content.replace(/\{\{agentId\}\}/g, agentId).replace(/\{\{projectName\}\}/g, projectConfig.name).replace(/\{\{todoFilePath\}\}/g, todoFilePath2).replace(/\{\{inboxPath\}\}/g, path.join(messagesDir2, agentId, "inbox")).replace(/\{\{outboxPath\}\}/g, path.join(messagesDir2, agentId, "outbox")).replace(/\{\{workingDirectory\}\}/g, settings.workingDirectory);
+      }
+    } catch {
+    }
+  }
+  const todoFilePath = path.resolve(settings.workingDirectory, settings.todoFile);
+  const messagesDir = path.resolve(settings.workingDirectory, settings.messagesDirectory);
+  return getDefaultSystemPrompt({
+    role,
+    agentId,
+    projectName: projectConfig.name,
+    todoFilePath,
+    inboxPath: path.join(messagesDir, agentId, "inbox"),
+    outboxPath: path.join(messagesDir, agentId, "outbox"),
+    workingDirectory: settings.workingDirectory,
+    techStack: projectConfig.techStack
+  });
+}
+function formatAgentName(role, index) {
+  const roleName = role.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  return index !== void 0 ? `${roleName} ${index}` : roleName;
+}
+var init_config = __esm({
+  "src/agent/config.ts"() {
+    "use strict";
+    init_roles();
+  }
+});
+
+// src/types/orchestrator-activity.ts
+var PIPELINE_STAGE_ORDER = ["plan", "develop", "qa", "review"];
+var PIPELINE_STAGE_ROLES = {
+  plan: ["project-manager", "architect"],
+  develop: ["developer"],
+  qa: ["qa-engineer"],
+  review: ["project-manager"]
+};
+
+// src/index.ts
+init_parser();
+init_writer();
+init_manager();
+init_lifecycle();
+init_pool();
+init_roles();
+init_config();
+
+// src/messaging/broker.ts
+import { EventEmitter as EventEmitter5 } from "eventemitter3";
+import { mkdir as mkdir2, writeFile as writeFile3, readFile as readFile3, readdir, rename as rename2 } from "fs/promises";
+import { join as join2 } from "path";
+
+// src/messaging/inbox.ts
+init_logger();
+import { watch } from "chokidar";
+import { EventEmitter as EventEmitter4 } from "eventemitter3";
+import { readFile as readFile2, rename, mkdir } from "fs/promises";
+import { join, basename } from "path";
+var logger2 = createLogger("inbox-watcher");
+var InboxWatcher = class extends EventEmitter4 {
+  watcher = null;
+  dir;
+  processedDir;
+  constructor(inboxDir, processedDir) {
+    super();
+    this.dir = inboxDir;
+    this.processedDir = processedDir;
+  }
+  async start() {
+    await mkdir(this.dir, { recursive: true });
+    await mkdir(this.processedDir, { recursive: true });
+    this.watcher = watch(this.dir, {
+      ignoreInitial: false,
+      awaitWriteFinish: { stabilityThreshold: 200 }
+    });
+    this.watcher.on("add", (filePath) => {
+      if (filePath.endsWith(".json")) {
+        this.processFile(filePath).catch((err) => {
+          logger2.error({ err, filePath }, "Failed to process inbox file");
+        });
+      }
+    });
+    this.watcher.on("error", (err) => {
+      logger2.error({ err }, "Inbox watcher error");
+    });
+  }
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+  }
+  async processFile(filePath) {
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      let envelope;
+      try {
+        envelope = JSON.parse(content);
+      } catch {
+        logger2.warn({ filePath }, "Malformed JSON in inbox file, skipping");
+        return;
+      }
+      envelope.deliveredAt = (/* @__PURE__ */ new Date()).toISOString();
+      envelope.status = "delivered";
+      this.emit("message", envelope);
+      const destPath = join(this.processedDir, basename(filePath));
+      await rename(filePath, destPath);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        logger2.debug({ filePath }, "Inbox file already removed");
+        return;
+      }
+      throw err;
+    }
+  }
+};
+
+// src/messaging/broker.ts
+init_logger();
+var logger3 = createLogger("message-broker");
+function messageFileName(message) {
+  const prefix = message.taskId ?? "general";
+  return `${prefix}_${message.id}.json`;
+}
+var MessageBroker = class extends EventEmitter5 {
+  baseDir;
+  watchers = /* @__PURE__ */ new Map();
+  registeredAgents = /* @__PURE__ */ new Set();
+  constructor(baseDir) {
+    super();
+    this.baseDir = baseDir;
+  }
+  /**
+   * Initialize directory structure for an agent.
+   * Creates inbox/, outbox/, and processed/ directories.
+   */
+  async registerAgent(agentId) {
+    const agentDir = join2(this.baseDir, agentId);
+    await mkdir2(join2(agentDir, "inbox"), { recursive: true });
+    await mkdir2(join2(agentDir, "outbox"), { recursive: true });
+    await mkdir2(join2(agentDir, "processed"), { recursive: true });
+    this.registeredAgents.add(agentId);
+    logger3.debug({ agentId }, "Registered agent");
+  }
+  /**
+   * Initialize directories for all agents and start watching.
+   * Watches each agent's outbox directory so that messages agents write
+   * there are automatically picked up and routed.
+   */
+  async start(agentIds) {
+    for (const agentId of agentIds) {
+      await this.registerAgent(agentId);
+    }
+    for (const agentId of agentIds) {
+      const outboxDir = join2(this.baseDir, agentId, "outbox");
+      const processedDir = join2(this.baseDir, agentId, "processed");
+      const watcher = new InboxWatcher(outboxDir, processedDir);
+      watcher.on("message", (envelope) => {
+        logger3.info(
+          { from: envelope.message.from, to: envelope.message.to, type: envelope.message.type },
+          "Message received from agent outbox"
+        );
+        this.emit("message:received", envelope.message);
+        if (envelope.message.to === "*") {
+          this.broadcast(envelope.message).catch((err) => {
+            logger3.error({ err }, "Failed to broadcast message");
+          });
+        } else {
+          this.sendMessage(envelope.message).catch((err) => {
+            logger3.error({ err }, "Failed to route message");
+          });
+        }
+      });
+      await watcher.start();
+      this.watchers.set(agentId, watcher);
+    }
+    logger3.info({ agentCount: agentIds.length }, "Message broker started");
+  }
+  /**
+   * Send a message to an agent's inbox.
+   * If message.to is "*", broadcasts to all registered agents instead.
+   */
+  async sendMessage(message) {
+    if (message.to === "*") {
+      await this.broadcast(message);
+      return;
+    }
+    if (message.to === "user") {
+      logger3.info({ from: message.from, type: message.type }, "User-directed message intercepted");
+      this.emit("message:user-directed", message);
+      return;
+    }
+    if (!this.registeredAgents.has(message.to)) {
+      logger3.warn({ to: message.to }, "Attempted to send message to unregistered agent");
+      return;
+    }
+    const envelope = {
+      message,
+      deliveredAt: null,
+      readAt: null,
+      status: "pending"
+    };
+    const filePath = join2(this.baseDir, message.to, "inbox", messageFileName(message));
+    await writeFile3(filePath, JSON.stringify(envelope, null, 2), "utf-8");
+    logger3.debug(
+      { id: message.id, from: message.from, to: message.to, type: message.type },
+      "Message sent"
+    );
+    this.emit("message:sent", message);
+  }
+  /**
+   * Send a message to all registered agents' inboxes.
+   */
+  async broadcast(message) {
+    const promises = [];
+    for (const agentId of this.registeredAgents) {
+      if (agentId === message.from) {
+        continue;
+      }
+      const envelope = {
+        message: { ...message, to: agentId },
+        deliveredAt: null,
+        readAt: null,
+        status: "pending"
+      };
+      const broadcastMsg = { ...message, to: agentId };
+      const filePath = join2(this.baseDir, agentId, "inbox", messageFileName(broadcastMsg));
+      promises.push(
+        writeFile3(filePath, JSON.stringify(envelope, null, 2), "utf-8").then(() => {
+          this.emit("message:sent", broadcastMsg);
+        })
+      );
+    }
+    await Promise.all(promises);
+    logger3.debug(
+      { id: message.id, from: message.from, agentCount: this.registeredAgents.size },
+      "Broadcast sent"
+    );
+  }
+  /**
+   * Mark an inbox message as processed and move it to the processed directory.
+   * Called when a task completes so the inbox reflects the current state.
+   */
+  async markInboxProcessed(agentId, taskId) {
+    const inboxDir = join2(this.baseDir, agentId, "inbox");
+    const processedDir = join2(this.baseDir, agentId, "processed");
+    try {
+      const files = await readdir(inboxDir);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const filePath = join2(inboxDir, file);
+        try {
+          const content = await readFile3(filePath, "utf-8");
+          const envelope = JSON.parse(content);
+          if (envelope.message.taskId === taskId) {
+            envelope.status = "processed";
+            envelope.readAt = (/* @__PURE__ */ new Date()).toISOString();
+            await writeFile3(filePath, JSON.stringify(envelope, null, 2), "utf-8");
+            const destPath = join2(processedDir, file);
+            await rename2(filePath, destPath);
+            logger3.debug({ agentId, taskId, messageId: envelope.message.id }, "Inbox message marked as processed");
+          }
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+  /**
+   * Clean up stale inbox messages for a task (e.g., after restart when
+   * in-progress tasks are reset). Moves matching messages to processed/.
+   */
+  async cleanInboxForTask(agentId, taskId) {
+    await this.markInboxProcessed(agentId, taskId);
+  }
+  /**
+   * Read processed messages for a specific task across all agents.
+   * Used to display task completion details in the TUI.
+   */
+  async getProcessedMessagesForTask(taskId) {
+    const results = [];
+    let agentDirs = [];
+    try {
+      const entries = await readdir(this.baseDir, { withFileTypes: true });
+      agentDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return results;
+    }
+    for (const agentId of agentDirs) {
+      for (const subdir of ["inbox", "processed"]) {
+        const dir = join2(this.baseDir, agentId, subdir);
+        try {
+          const entries = await readdir(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+            try {
+              const content = await readFile3(join2(dir, entry.name), "utf-8");
+              const envelope = JSON.parse(content);
+              if (envelope.message?.taskId === taskId) {
+                results.push(envelope);
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    const seen = /* @__PURE__ */ new Set();
+    const deduped = results.filter((env) => {
+      if (seen.has(env.message.id)) return false;
+      seen.add(env.message.id);
+      return true;
+    });
+    deduped.sort((a, b) => a.message.timestamp.localeCompare(b.message.timestamp));
+    return deduped;
+  }
+  /**
+   * Move ALL inbox messages to processed/ for every agent directory.
+   * Called on startup to ensure a clean slate — agents should not pick up
+   * stale task-assignment messages from a previous session.
+   */
+  async cleanAllInboxes() {
+    let agentDirs = [];
+    try {
+      const entries = await readdir(this.baseDir, { withFileTypes: true });
+      agentDirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return;
+    }
+    let movedCount = 0;
+    for (const agentId of agentDirs) {
+      const inboxDir = join2(this.baseDir, agentId, "inbox");
+      const processedDir = join2(this.baseDir, agentId, "processed");
+      try {
+        await mkdir2(processedDir, { recursive: true });
+        const files = await readdir(inboxDir);
+        for (const file of files) {
+          if (!file.endsWith(".json")) continue;
+          try {
+            await rename2(join2(inboxDir, file), join2(processedDir, file));
+            movedCount++;
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    if (movedCount > 0) {
+      logger3.info({ movedCount }, "Cleaned stale inbox messages from previous session");
+    }
+  }
+  get messagesBaseDir() {
+    return this.baseDir;
+  }
+  /**
+   * Stop all watchers and clean up.
+   */
+  async stop() {
+    const stopPromises = [];
+    for (const [agentId, watcher] of this.watchers) {
+      logger3.debug({ agentId }, "Stopping watcher");
+      stopPromises.push(watcher.stop());
+    }
+    await Promise.all(stopPromises);
+    this.watchers.clear();
+    logger3.info("Message broker stopped");
+  }
+};
+
+// src/orchestrator/orchestrator.ts
+import { EventEmitter as EventEmitter7 } from "eventemitter3";
+import { mkdir as mkdir3 } from "fs/promises";
+
+// src/feedback/feedback-loop.ts
+import { EventEmitter as EventEmitter6 } from "eventemitter3";
+
+// src/feedback/progress-tracker.ts
+init_id();
+var PHASE_ORDER = ["planning", "architecture", "design", "implementation", "testing", "documentation"];
+var ProgressTracker = class {
+  generateReport(tasks, stats) {
+    const completedTasks = tasks.filter((t) => t.status === "done");
+    const pendingTasks = tasks.filter((t) => t.status === "pending");
+    const blockedTasks = tasks.filter((t) => t.status === "blocked");
+    return {
+      id: generateId(),
+      phase: this.detectPhase(tasks),
+      completedTasks: completedTasks.length,
+      totalTasks: tasks.length,
+      percentComplete: this.getCompletionPercentage(tasks),
+      recentCompletions: completedTasks.map((t) => t.title),
+      upcomingWork: pendingTasks.map((t) => t.title),
+      blockers: blockedTasks.map((t) => t.title),
+      totalCostUsd: stats.totalCostUsd,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  getCompletionPercentage(tasks) {
+    if (tasks.length === 0) return 0;
+    const doneCount = tasks.filter((t) => t.status === "done").length;
+    return Math.round(doneCount / tasks.length * 100);
+  }
+  detectPhase(tasks) {
+    const inProgressTasks = tasks.filter((t) => t.status === "in-progress");
+    if (inProgressTasks.length === 0) {
+      return "implementation";
+    }
+    const tagCounts = /* @__PURE__ */ new Map();
+    for (const task of inProgressTasks) {
+      for (const tag of task.tags) {
+        const normalizedTag = tag.toLowerCase();
+        if (PHASE_ORDER.includes(normalizedTag)) {
+          tagCounts.set(normalizedTag, (tagCounts.get(normalizedTag) ?? 0) + 1);
+        }
+      }
+    }
+    if (tagCounts.size === 0) {
+      return "implementation";
+    }
+    let maxCount = 0;
+    let mostCommonPhase = "implementation";
+    for (const [tag, count] of tagCounts) {
+      if (count > maxCount) {
+        maxCount = count;
+        mostCommonPhase = tag;
+      }
+    }
+    return mostCommonPhase;
+  }
+};
+
+// src/feedback/feedback-loop.ts
+init_id();
+init_logger();
+var logger4 = createLogger("feedback-loop");
+var DEFAULT_SETTINGS = {
+  interactionMode: "supervised",
+  progressReportIntervalMs: 6e4,
+  milestonePercentages: [25, 50, 75, 100],
+  questionTimeoutMs: 3e5,
+  requirePlanApproval: true
+};
+var FeedbackLoop = class extends EventEmitter6 {
+  mode;
+  settings;
+  pendingPlan = null;
+  planResolver = null;
+  pendingQuestions = /* @__PURE__ */ new Map();
+  lastProgressReport = 0;
+  progressTracker;
+  reachedMilestones = /* @__PURE__ */ new Set();
+  pendingMilestone = null;
+  constructor(settings) {
+    super();
+    this.settings = { ...DEFAULT_SETTINGS, ...settings };
+    this.mode = this.settings.interactionMode;
+    this.progressTracker = new ProgressTracker();
+  }
+  get interactionMode() {
+    return this.mode;
+  }
+  setMode(mode) {
+    this.mode = mode;
+    this.emit("interaction-mode:changed", mode);
+  }
+  /**
+   * Propose a plan for approval.
+   * In unattended mode: auto-approves immediately.
+   * In supervised/interactive: emits plan:proposed and waits for decidePlan() call.
+   */
+  async proposePlan(tasks, projectGoal) {
+    if (this.mode === "unattended" && !this.settings.requirePlanApproval) {
+      return "approved";
+    }
+    if (this.mode === "unattended") {
+      return "approved";
+    }
+    const proposal = {
+      id: generateId(),
+      tasks,
+      totalEstimatedTasks: tasks.length,
+      projectGoal,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending"
+    };
+    this.pendingPlan = proposal;
+    return new Promise((resolve) => {
+      this.planResolver = resolve;
+      this.emit("plan:proposed", proposal);
+    });
+  }
+  decidePlan(proposalId, decision, modifications) {
+    if (!this.pendingPlan || this.pendingPlan.id !== proposalId) {
+      logger4.warn({ proposalId }, "No pending plan with this ID");
+      return;
+    }
+    this.pendingPlan.status = decision === "approved" ? "approved" : "rejected";
+    this.emit("plan:decided", proposalId, decision, modifications);
+    if (this.planResolver) {
+      this.planResolver(decision);
+      this.planResolver = null;
+    }
+    this.pendingPlan = null;
+  }
+  /**
+   * Route a question from an agent to the user.
+   * In unattended mode: returns null immediately (agent should handle itself).
+   * In interactive: emits question:asked and waits for answerQuestion() call with timeout.
+   * In supervised: same as interactive but question is lower priority.
+   */
+  async routeQuestion(fromAgent, question, opts) {
+    if (this.mode === "unattended") {
+      return null;
+    }
+    const userQuestion = {
+      id: generateId(),
+      fromAgent,
+      taskId: opts?.taskId,
+      question,
+      context: opts?.context,
+      options: opts?.options,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      status: "pending"
+    };
+    this.emit("question:asked", userQuestion);
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        userQuestion.status = "timed-out";
+        this.pendingQuestions.delete(userQuestion.id);
+        resolve(null);
+      }, this.settings.questionTimeoutMs);
+      this.pendingQuestions.set(userQuestion.id, { question: userQuestion, resolve, timer });
+    });
+  }
+  answerQuestion(questionId, answer) {
+    const entry = this.pendingQuestions.get(questionId);
+    if (!entry) {
+      logger4.warn({ questionId }, "No pending question with this ID");
+      return;
+    }
+    entry.question.status = "answered";
+    entry.question.answer = answer;
+    if (entry.timer) clearTimeout(entry.timer);
+    this.pendingQuestions.delete(questionId);
+    this.emit("question:answered", questionId, answer);
+    entry.resolve(answer);
+  }
+  /**
+   * Called each orchestrator cycle to check progress and emit reports/milestones.
+   */
+  checkProgress(tasks, stats) {
+    const now = Date.now();
+    if (now - this.lastProgressReport >= this.settings.progressReportIntervalMs) {
+      const report = this.progressTracker.generateReport(tasks, stats);
+      this.emit("progress:report", report);
+      this.lastProgressReport = now;
+    }
+    const percent = this.progressTracker.getCompletionPercentage(tasks);
+    for (const threshold of this.settings.milestonePercentages) {
+      if (percent >= threshold && !this.reachedMilestones.has(threshold)) {
+        this.reachedMilestones.add(threshold);
+        const milestone = {
+          id: generateId(),
+          name: `${threshold}% Complete`,
+          percentComplete: threshold,
+          message: `Project has reached ${threshold}% completion (${stats.completedTasks}/${stats.totalTasks} tasks done)`,
+          requiresAck: this.mode === "supervised" || this.mode === "interactive",
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.emit("milestone:reached", milestone);
+      }
+    }
+  }
+  acknowledgeMilestone(milestoneId) {
+    this.emit("milestone:acknowledged", milestoneId);
+  }
+  /**
+   * Clean up all pending timers and resolvers.
+   * Call this during shutdown to prevent leaked timers from blocking process exit.
+   */
+  cleanup() {
+    for (const [id, entry] of this.pendingQuestions) {
+      if (entry.timer) clearTimeout(entry.timer);
+      entry.resolve(null);
+    }
+    this.pendingQuestions.clear();
+    if (this.planResolver) {
+      this.planResolver("rejected");
+      this.planResolver = null;
+    }
+    this.pendingPlan = null;
+    this.removeAllListeners();
+    logger4.debug("FeedbackLoop cleaned up");
+  }
+  getPendingPlan() {
+    return this.pendingPlan;
+  }
+  getPendingQuestions() {
+    return Array.from(this.pendingQuestions.values()).map((e) => e.question);
+  }
+};
+
+// src/orchestrator/planner.ts
+init_logger();
+import { execa as execa2 } from "execa";
+import { readdirSync, statSync } from "fs";
+import { join as join3 } from "path";
+var logger5 = createLogger("planner");
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  ".maestro",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".cache",
+  ".turbo",
+  "coverage",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".tox",
+  "target"
+]);
+var IGNORE_FILES = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  "Thumbs.db",
+  ".env",
+  ".env.local"
+]);
+var DECOMPOSE_PROMPT = `You are a project planning assistant. Break down the following project goal into a set of discrete, actionable tasks.
+
+Return ONLY a JSON array (no markdown, no explanation) where each element has:
+- "title": short task title
+- "priority": one of "critical", "high", "medium", "low"
+- "description": detailed description of what needs to be done
+- "dependencies": array of titles of tasks this depends on (empty array if none)
+- "tags": array of relevant tags from: "architecture", "design-system", "ui", "ux", "design", "planning", "priority", "frontend", "backend", "testing", "qa", "e2e", "documentation", "docs", "api-docs", "devops", "ci-cd", "deployment", "docker", "infrastructure", "security", "review", "code-review"
+
+Order tasks so that dependencies come before the tasks that depend on them.
+
+IMPORTANT \u2014 You MUST include tasks for ALL of the following categories. A complete project requires work from every team role:
+
+1. **Architecture** (tag: "architecture"): At least one task for creating ARCHITECTURE.md with system design, component structure, data models, and key technical decisions. This should have no dependencies and be listed as a dependency for implementation tasks.
+
+2. **Design** (tags: "design", "ui", "ux", "design-system"): Tasks for UI/UX design, component design, design system setup, styling, and visual layouts.
+
+3. **Frontend/Backend development** (tags: "frontend", "backend"): Core implementation tasks for building features.
+
+4. **Testing & QA** (tags: "testing", "qa", "e2e"): Tasks for writing unit tests, integration tests, and end-to-end tests. These should depend on the implementation tasks they test. Include at least one task for setting up the test framework and one for writing tests for each major feature.
+
+5. **Documentation** (tags: "documentation", "docs", "api-docs"): Tasks for writing README, API documentation, user guides, and inline documentation. These should depend on the features being documented.
+
+6. **DevOps & CI/CD** (tags: "devops", "ci-cd", "deployment", "docker", "infrastructure"): Tasks for setting up CI/CD pipelines, Docker configuration, deployment scripts, and infrastructure. Include at least one devops task.
+
+7. **Code Review** (tags: "code-review", "review", "security"): Tasks for reviewing code quality, security audit, and ensuring best practices. These should depend on implementation tasks and run toward the end.
+
+Each category must have at least one task. This ensures all team members (architect, designer, developers, QA engineer, technical writer, DevOps engineer, code reviewer) have meaningful work assigned to them.
+`;
+var Planner = class {
+  model;
+  workingDirectory;
+  claudeCommand;
+  claudeEnv;
+  techStack;
+  constructor(opts) {
+    this.model = opts.model ?? "sonnet";
+    this.workingDirectory = opts.workingDirectory;
+    this.claudeCommand = opts.claudeCommand ?? "claude";
+    this.claudeEnv = opts.claudeEnv;
+    this.techStack = opts.techStack;
+  }
+  /**
+   * Use Claude CLI to decompose a goal into a list of planned tasks.
+   */
+  async decompose(goal) {
+    const tree = this.scanDirectory(this.workingDirectory, 4);
+    const hasFiles = tree.length > 0;
+    let prompt = DECOMPOSE_PROMPT;
+    if (hasFiles) {
+      prompt += `
+Project working directory: ${this.workingDirectory}
+`;
+      prompt += `
+Existing project structure:
+\`\`\`
+${tree.join("\n")}
+\`\`\`
+`;
+      prompt += `
+Consider the existing files and structure when planning tasks. `;
+      prompt += `Build on what already exists rather than recreating from scratch.
+`;
+    }
+    if (this.techStack) {
+      const parts = [];
+      if (this.techStack.frontend) parts.push(`- Frontend: ${this.techStack.frontend}`);
+      if (this.techStack.uiLibrary) parts.push(`- UI Library: ${this.techStack.uiLibrary}`);
+      if (this.techStack.backend) parts.push(`- Backend: ${this.techStack.backend}`);
+      if (this.techStack.database) parts.push(`- Database: ${this.techStack.database}`);
+      if (this.techStack.other) parts.push(`- Other: ${this.techStack.other}`);
+      if (parts.length > 0) {
+        prompt += `
+Tech Stack:
+${parts.join("\n")}
+`;
+        prompt += `
+Use the specified technologies in your task planning. `;
+        prompt += `Include setup and configuration tasks for these technologies as needed.
+`;
+      }
+    }
+    prompt += `
+Goal:
+${goal}`;
+    logger5.info({ model: this.model, cwd: this.workingDirectory, fileCount: tree.length }, "Decomposing goal into tasks");
+    try {
+      const result = await execa2(this.claudeCommand, [
+        "--print",
+        "--output-format",
+        "json",
+        "--model",
+        this.model
+      ], {
+        input: prompt,
+        cwd: this.workingDirectory,
+        env: this.claudeEnv ? { ...process.env, ...this.claudeEnv } : void 0,
+        timeout: 12e4
+      });
+      const output = result.stdout.trim();
+      return this.parseResponse(output);
+    } catch (err) {
+      logger5.error({ err }, "Failed to decompose goal via Claude CLI");
+      return [{
+        title: "Implement project goal",
+        priority: "high",
+        description: goal,
+        dependencies: [],
+        tags: []
+      }];
+    }
+  }
+  /**
+   * Scan a directory recursively and return an indented tree listing.
+   */
+  scanDirectory(dir, maxDepth, depth = 0, prefix = "") {
+    if (depth >= maxDepth) return [];
+    const lines = [];
+    let entries;
+    try {
+      entries = readdirSync(dir).sort();
+    } catch {
+      return lines;
+    }
+    const dirs = [];
+    const files = [];
+    for (const entry of entries) {
+      if (IGNORE_DIRS.has(entry) || IGNORE_FILES.has(entry) || entry.startsWith(".")) continue;
+      const fullPath = join3(dir, entry);
+      try {
+        const stat = statSync(fullPath);
+        if (stat.isDirectory()) {
+          dirs.push(entry);
+        } else {
+          files.push(entry);
+        }
+      } catch {
+      }
+    }
+    for (const file of files) {
+      lines.push(`${prefix}${file}`);
+    }
+    for (const d of dirs) {
+      lines.push(`${prefix}${d}/`);
+      const subLines = this.scanDirectory(join3(dir, d), maxDepth, depth + 1, prefix + "  ");
+      lines.push(...subLines);
+    }
+    return lines;
+  }
+  parseResponse(output) {
+    try {
+      let text = output;
+      try {
+        const parsed = JSON.parse(output);
+        if (parsed && typeof parsed === "object" && "result" in parsed) {
+          text = parsed.result;
+        }
+      } catch {
+      }
+      const jsonMatch = text.match(/\[[\s\S]*\]/);
+      if (!jsonMatch) {
+        throw new Error("No JSON array found in response");
+      }
+      const tasks = JSON.parse(jsonMatch[0]);
+      if (!Array.isArray(tasks) || tasks.length === 0) {
+        throw new Error("Parsed result is not a non-empty array");
+      }
+      for (const task of tasks) {
+        if (!task.title || !task.description) {
+          throw new Error(`Task missing required fields: ${JSON.stringify(task)}`);
+        }
+        task.priority = task.priority ?? "medium";
+        task.dependencies = task.dependencies ?? [];
+        task.tags = task.tags ?? [];
+      }
+      logger5.info({ taskCount: tasks.length }, "Goal decomposed into tasks");
+      return tasks;
+    } catch (err) {
+      logger5.warn({ err }, "Failed to parse planner response, returning single task");
+      return [{
+        title: "Implement project goal",
+        priority: "high",
+        description: output,
+        dependencies: [],
+        tags: []
+      }];
+    }
+  }
+};
+
+// src/orchestrator/scheduler.ts
+init_logger();
+var logger6 = createLogger("scheduler");
+var TAG_ROLE_MAP = {
+  "architecture": "architect",
+  "design-system": "architect",
+  "ui": "designer",
+  "ux": "designer",
+  "design": "designer",
+  "planning": "project-manager",
+  "priority": "project-manager",
+  "testing": "qa-engineer",
+  "qa": "qa-engineer",
+  "e2e": "qa-engineer",
+  "devops": "devops",
+  "ci-cd": "devops",
+  "deployment": "devops",
+  "infrastructure": "devops",
+  "docker": "devops",
+  "documentation": "technical-writer",
+  "docs": "technical-writer",
+  "api-docs": "technical-writer",
+  "review": "code-reviewer",
+  "code-review": "code-reviewer",
+  "security": "code-reviewer"
+};
+var ROLE_FALLBACK = {
+  "designer": ["developer"],
+  "architect": ["developer"],
+  "project-manager": [],
+  "qa-engineer": ["developer"],
+  "devops": ["developer"],
+  "technical-writer": ["developer"],
+  "code-reviewer": ["architect", "developer"]
+};
+var PRIORITY_ORDER2 = {
+  critical: 0,
+  high: 1,
+  medium: 2,
+  low: 3
+};
+var Scheduler = class {
+  /** Optional pipeline reference for pipeline-aware scheduling. */
+  pipeline = null;
+  /**
+   * Set a pipeline reference so the scheduler can use pipeline stage
+   * information when determining which role should handle a task.
+   */
+  setPipeline(pipeline) {
+    this.pipeline = pipeline;
+  }
+  /**
+   * Determine which pending tasks should be assigned to which idle agents.
+   *
+   * Rules:
+   * 1. Only consider tasks whose status is 'pending' and whose dependencies are all 'done'.
+   * 2. Only consider agents whose status is 'idle'.
+   * 3. Match tasks to agents by role:
+   *    - If a task has a pipeline state, use the pipeline stage to determine role
+   *    - Otherwise, fall back to tag-based role determination
+   * 4. Assign higher-priority tasks first.
+   * 5. Each agent receives at most one assignment per scheduling cycle.
+   */
+  schedule(tasks, agents) {
+    const taskStatusMap = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      taskStatusMap.set(task.id, task);
+    }
+    const readyTasks = tasks.filter((task) => {
+      if (task.status !== "pending") return false;
+      return task.dependencies.every((depId) => {
+        const dep = taskStatusMap.get(depId);
+        return !dep || dep.status === "done";
+      });
+    });
+    readyTasks.sort((a, b) => PRIORITY_ORDER2[a.priority] - PRIORITY_ORDER2[b.priority]);
+    const idleAgentsByRole = /* @__PURE__ */ new Map();
+    for (const agent of agents) {
+      if (agent.status !== "idle") continue;
+      const role = agent.config.role;
+      if (!idleAgentsByRole.has(role)) {
+        idleAgentsByRole.set(role, []);
+      }
+      idleAgentsByRole.get(role).push(agent);
+    }
+    const assignments = [];
+    const assignedAgentIds = /* @__PURE__ */ new Set();
+    for (const task of readyTasks) {
+      const neededRole = this.determineRole(task);
+      const rolesToTry = [neededRole, ...ROLE_FALLBACK[neededRole] ?? []];
+      let assigned = false;
+      for (const role of rolesToTry) {
+        const candidates = idleAgentsByRole.get(role);
+        if (!candidates || candidates.length === 0) {
+          continue;
+        }
+        const agent = candidates.find((a) => !assignedAgentIds.has(a.config.id));
+        if (!agent) {
+          continue;
+        }
+        assignedAgentIds.add(agent.config.id);
+        assignments.push({
+          taskId: task.id,
+          agentId: agent.config.id
+        });
+        logger6.debug(
+          { taskId: task.id, agentId: agent.config.id, neededRole, actualRole: role },
+          role === neededRole ? "Task assigned to agent" : "Task assigned to fallback agent"
+        );
+        assigned = true;
+        break;
+      }
+      if (!assigned) {
+        logger6.trace(
+          { taskId: task.id, neededRole },
+          "No idle agent available for role, will retry next cycle"
+        );
+      }
+    }
+    return assignments;
+  }
+  /**
+   * Determine the best role for a task.
+   *
+   * If the task has an active pipeline state, the pipeline stage takes
+   * priority over tag-based role determination. This enables the
+   * plan -> develop -> qa -> review handoff sequence.
+   *
+   * Falls back to tag-based determination, then defaults to 'developer'.
+   */
+  determineRole(task) {
+    if (this.pipeline) {
+      const pipelineState = this.pipeline.getState(task.id);
+      if (pipelineState) {
+        const stageRoles = PIPELINE_STAGE_ROLES[pipelineState.currentStage];
+        if (stageRoles && stageRoles.length > 0) {
+          return stageRoles[0];
+        }
+      }
+    }
+    for (const tag of task.tags) {
+      const role = TAG_ROLE_MAP[tag];
+      if (role) {
+        return role;
+      }
+    }
+    return "developer";
+  }
+};
+
+// src/orchestrator/pipeline.ts
+init_logger();
+var logger7 = createLogger("pipeline");
+var TaskPipeline = class {
+  pipelines = /* @__PURE__ */ new Map();
+  /**
+   * Register a task in the pipeline at a given starting stage.
+   * Tasks tagged with 'architecture' or 'planning' start at 'plan'.
+   * Tasks tagged with 'testing' or 'qa' start at 'qa'.
+   * All others start at 'develop' (they'll skip the plan stage
+   * if they were already created from the planner).
+   */
+  initTask(task, startStage) {
+    const stage = startStage ?? this.inferStartStage(task);
+    const state = {
+      taskId: task.id,
+      currentStage: stage,
+      stageHistory: [],
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.pipelines.set(task.id, state);
+    logger7.debug({ taskId: task.id, stage }, "Task registered in pipeline");
+    return state;
+  }
+  /**
+   * Get the pipeline state for a task.
+   */
+  getState(taskId) {
+    return this.pipelines.get(taskId);
+  }
+  /**
+   * Record that an agent has started working on the current stage.
+   */
+  startStage(taskId, agentId) {
+    const state = this.pipelines.get(taskId);
+    if (!state) return;
+    state.stageHistory.push({
+      stage: state.currentStage,
+      agentId,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      completedAt: null,
+      status: "in-progress"
+    });
+  }
+  /**
+   * Complete the current stage and return the next stage (if any).
+   * Returns null if the pipeline is finished.
+   */
+  completeStage(taskId) {
+    const state = this.pipelines.get(taskId);
+    if (!state) return null;
+    const currentEntry = state.stageHistory.find(
+      (h) => h.stage === state.currentStage && h.status === "in-progress"
+    );
+    if (currentEntry) {
+      currentEntry.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      currentEntry.status = "completed";
+    }
+    const currentIndex = PIPELINE_STAGE_ORDER.indexOf(state.currentStage);
+    if (currentIndex < 0 || currentIndex >= PIPELINE_STAGE_ORDER.length - 1) {
+      logger7.info({ taskId }, "Task pipeline completed");
+      return {
+        nextStage: null,
+        requiredRoles: [],
+        handoffMessage: `Pipeline complete for task ${taskId}`
+      };
+    }
+    const nextStage = PIPELINE_STAGE_ORDER[currentIndex + 1];
+    state.currentStage = nextStage;
+    const requiredRoles = PIPELINE_STAGE_ROLES[nextStage];
+    const stageLabels = {
+      plan: "Planning & Architecture",
+      develop: "Development",
+      qa: "QA & Testing",
+      review: "Project Manager Review"
+    };
+    logger7.info({ taskId, from: PIPELINE_STAGE_ORDER[currentIndex], to: nextStage }, "Pipeline handoff");
+    return {
+      nextStage,
+      requiredRoles,
+      handoffMessage: `Handoff: ${stageLabels[PIPELINE_STAGE_ORDER[currentIndex]]} -> ${stageLabels[nextStage]}`
+    };
+  }
+  /**
+   * Mark a stage as failed.
+   */
+  failStage(taskId) {
+    const state = this.pipelines.get(taskId);
+    if (!state) return;
+    const currentEntry = state.stageHistory.find(
+      (h) => h.stage === state.currentStage && h.status === "in-progress"
+    );
+    if (currentEntry) {
+      currentEntry.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      currentEntry.status = "failed";
+    }
+  }
+  /**
+   * Get the role(s) needed for the current pipeline stage of a task.
+   */
+  getRequiredRoles(taskId) {
+    const state = this.pipelines.get(taskId);
+    if (!state) return ["developer"];
+    return PIPELINE_STAGE_ROLES[state.currentStage];
+  }
+  /**
+   * Check if a task has a pipeline registered.
+   */
+  has(taskId) {
+    return this.pipelines.has(taskId);
+  }
+  /**
+   * Infer the starting pipeline stage from task tags.
+   */
+  inferStartStage(task) {
+    const tags = task.tags.map((t) => t.toLowerCase());
+    if (tags.includes("architecture") || tags.includes("planning") || tags.includes("design-system")) {
+      return "plan";
+    }
+    if (tags.includes("testing") || tags.includes("qa") || tags.includes("e2e")) {
+      return "qa";
+    }
+    return "develop";
+  }
+};
+
+// src/orchestrator/pm-scanner.ts
+init_id();
+init_logger();
+var logger8 = createLogger("pm-scanner");
+var DEFAULT_SCAN_INTERVAL_MS = 3e4;
+var STALE_TASK_THRESHOLD_MS = 5 * 6e4;
+var ProjectManagerScanner = class {
+  intervalId = null;
+  scanIntervalMs;
+  lastScanTasks = /* @__PURE__ */ new Map();
+  cycleCount = 0;
+  /** Track tasks that have already received a PM message to avoid duplicates. */
+  messagedTasks = /* @__PURE__ */ new Set();
+  constructor(scanIntervalMs) {
+    this.scanIntervalMs = scanIntervalMs ?? DEFAULT_SCAN_INTERVAL_MS;
+  }
+  /**
+   * Start the periodic scan loop.
+   * @param scanFn — called each interval; the orchestrator provides context.
+   */
+  start(scanFn) {
+    if (this.intervalId) return;
+    this.intervalId = setInterval(scanFn, this.scanIntervalMs);
+    logger8.info({ intervalMs: this.scanIntervalMs }, "PM scanner started");
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    logger8.info("PM scanner stopped");
+  }
+  /**
+   * Run a single scan pass.
+   *
+   * @param tasks   - Current task list
+   * @param agents  - Current agent states (from pool + virtual)
+   * @param phase   - Current orchestrator phase
+   */
+  scan(tasks, agents, phase) {
+    this.cycleCount++;
+    const now = Date.now();
+    const findings = [];
+    const blockedTasks = tasks.filter((t) => t.status === "blocked");
+    for (const task of blockedTasks) {
+      const blockerIds = task.dependencies.filter((depId) => {
+        const dep = tasks.find((t) => t.id === depId);
+        return dep && dep.status !== "done";
+      });
+      findings.push({
+        kind: "blocked-task",
+        severity: task.priority === "critical" ? "critical" : "warning",
+        message: `Task "${task.title}" (${task.id}) is blocked by: ${blockerIds.join(", ")}`,
+        taskId: task.id
+      });
+    }
+    const highPriorityPending = tasks.filter(
+      (t) => t.status === "pending" && (t.priority === "critical" || t.priority === "high")
+    );
+    for (const task of highPriorityPending) {
+      findings.push({
+        kind: "high-priority-waiting",
+        severity: task.priority === "critical" ? "critical" : "warning",
+        message: `High-priority task "${task.title}" (${task.id}) is pending and unassigned`,
+        taskId: task.id
+      });
+    }
+    const inProgressTasks = tasks.filter((t) => t.status === "in-progress");
+    for (const task of inProgressTasks) {
+      const prev = this.lastScanTasks.get(task.id);
+      if (prev && prev.status === "in-progress") {
+        const elapsed = now - prev.at;
+        if (elapsed > STALE_TASK_THRESHOLD_MS) {
+          findings.push({
+            kind: "stale-task",
+            severity: "warning",
+            message: `Task "${task.title}" (${task.id}) has been in-progress for ${Math.round(elapsed / 6e4)}min without completion`,
+            taskId: task.id,
+            agentId: task.assignee ?? void 0
+          });
+        }
+      } else {
+        this.lastScanTasks.set(task.id, { status: "in-progress", at: now });
+      }
+    }
+    for (const task of tasks) {
+      if (task.status === "done" || task.status === "cancelled") {
+        this.lastScanTasks.delete(task.id);
+        this.clearTrackedTask(task.id);
+      } else if (task.status !== "in-progress") {
+        const prev = this.lastScanTasks.get(task.id);
+        if (prev && prev.status === "in-progress") {
+          this.lastScanTasks.delete(task.id);
+          this.clearTrackedTask(task.id);
+        }
+      }
+    }
+    const taskStatusMap = new Map(tasks.map((t) => [t.id, t]));
+    const readyTasks = tasks.filter((t) => {
+      if (t.status !== "pending") return false;
+      return t.dependencies.every((depId) => {
+        const dep = taskStatusMap.get(depId);
+        return dep && dep.status === "done";
+      });
+    });
+    const idleAgents = agents.filter((a) => a.status === "idle");
+    if (readyTasks.length > 0 && idleAgents.length === 0) {
+      findings.push({
+        kind: "unassigned-ready-task",
+        severity: "warning",
+        message: `${readyTasks.length} task(s) ready but no idle agents available`
+      });
+    }
+    const erroredAgents = agents.filter((a) => a.status === "error");
+    for (const agent of erroredAgents) {
+      findings.push({
+        kind: "agent-errored",
+        severity: "warning",
+        message: `Agent ${agent.config.name} (${agent.config.id}) is in error state: ${agent.error ?? "unknown"}`,
+        agentId: agent.config.id
+      });
+    }
+    if (idleAgents.length > 0 && readyTasks.length > 0) {
+      findings.push({
+        kind: "agent-idle",
+        severity: "info",
+        message: `${idleAgents.length} idle agent(s) with ${readyTasks.length} ready task(s) \u2014 scheduling may pick these up next cycle`
+      });
+    }
+    const blockingCounts = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      if (task.status === "done" || task.status === "cancelled") continue;
+      for (const depId of task.dependencies) {
+        const dep = taskStatusMap.get(depId);
+        if (dep && dep.status !== "done") {
+          blockingCounts.set(depId, (blockingCounts.get(depId) ?? 0) + 1);
+        }
+      }
+    }
+    for (const [taskId, count] of blockingCounts) {
+      if (count >= 3) {
+        const task = taskStatusMap.get(taskId);
+        findings.push({
+          kind: "dependency-bottleneck",
+          severity: "critical",
+          message: `Task "${task?.title ?? taskId}" is blocking ${count} other tasks \u2014 should be prioritized`,
+          taskId
+        });
+      }
+    }
+    const doneCount = tasks.filter((t) => t.status === "done").length;
+    const inProgressCount = inProgressTasks.length;
+    const pendingCount = tasks.filter((t) => t.status === "pending").length;
+    if (findings.length === 0) {
+      findings.push({
+        kind: "all-clear",
+        severity: "info",
+        message: "All systems nominal \u2014 no gaps or blockers detected"
+      });
+    }
+    const criticalCount = findings.filter((f) => f.severity === "critical").length;
+    const warningCount = findings.filter((f) => f.severity === "warning").length;
+    let summary;
+    if (criticalCount > 0) {
+      summary = `PM Scan: ${criticalCount} critical, ${warningCount} warning(s) | ${doneCount}/${tasks.length} done | ${inProgressCount} active | ${pendingCount} pending`;
+    } else if (warningCount > 0) {
+      summary = `PM Scan: ${warningCount} warning(s) | ${doneCount}/${tasks.length} done | ${inProgressCount} active | ${pendingCount} pending`;
+    } else {
+      summary = `PM Scan: All clear | ${doneCount}/${tasks.length} done | ${inProgressCount} active | ${pendingCount} pending`;
+    }
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      findings,
+      summary
+    };
+  }
+  /**
+   * Build messages from PM findings that should be sent to agents.
+   * Only produces messages for actionable findings.
+   * Tracks which tasks have already been messaged to avoid flooding inboxes.
+   */
+  buildMessages(result) {
+    const messages = [];
+    for (const finding of result.findings) {
+      if (finding.kind === "dependency-bottleneck" && finding.severity === "critical" && finding.taskId) {
+        const key = `bottleneck:${finding.taskId}`;
+        if (this.messagedTasks.has(key)) continue;
+        this.messagedTasks.add(key);
+        messages.push({
+          id: generateId(),
+          type: "directive",
+          from: "project-manager",
+          to: "orchestrator",
+          subject: `Bottleneck: ${finding.message}`,
+          body: `The project manager has identified a critical dependency bottleneck.
+
+${finding.message}
+
+Recommendation: Prioritize this task immediately to unblock downstream work.`,
+          taskId: finding.taskId,
+          priority: "urgent",
+          timestamp: result.timestamp
+        });
+      }
+      if (finding.kind === "stale-task" && finding.agentId && finding.taskId) {
+        const key = `stale:${finding.taskId}`;
+        if (this.messagedTasks.has(key)) continue;
+        this.messagedTasks.add(key);
+        messages.push({
+          id: generateId(),
+          type: "system",
+          from: "project-manager",
+          to: finding.agentId,
+          subject: `Status check: ${finding.taskId}`,
+          body: `The project manager is checking on progress.
+
+${finding.message}
+
+Please provide a status update or flag any blockers you're experiencing.`,
+          taskId: finding.taskId,
+          priority: "normal",
+          timestamp: result.timestamp
+        });
+      }
+    }
+    return messages;
+  }
+  /**
+   * Clear tracked messages for a task (e.g., when it moves from in-progress
+   * back to pending, allowing a new message if it stalls again later).
+   */
+  clearTrackedTask(taskId) {
+    for (const key of this.messagedTasks) {
+      if (key.endsWith(`:${taskId}`)) {
+        this.messagedTasks.delete(key);
+      }
+    }
+  }
+};
+
+// src/orchestrator/orchestrator.ts
+init_id();
+init_logger();
+var logger9 = createLogger("orchestrator");
+var Orchestrator = class extends EventEmitter7 {
+  config;
+  running = false;
+  paused = false;
+  intervalId = null;
+  startedAt = null;
+  broker = null;
+  scheduler = null;
+  planner = null;
+  pipeline;
+  pmScanner;
+  // These will hold references to modules that manage tasks and agents.
+  // They are typed loosely here because TaskManager, AgentPool, and
+  // WorkspaceManager are sibling modules that may not yet be implemented.
+  // The orchestrator interfaces with them via their public APIs.
+  taskManager = null;
+  agentPool = null;
+  agentConfigs = [];
+  cachedTasks = [];
+  feedbackLoop = null;
+  planApprovalPending = false;
+  phase = "planning";
+  architectureApprovalPending = false;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.pipeline = new TaskPipeline();
+    this.pmScanner = new ProjectManagerScanner();
+  }
+  get isActive() {
+    return this.running;
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  /**
+   * Emit a structured orchestrator activity event.
+   * These feed the persistent "Orchestrator" panel in the TUI.
+   */
+  emitActivity(kind, message, details) {
+    const activity = {
+      id: generateId(),
+      kind,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message,
+      details
+    };
+    this.emit("orchestrator:activity", activity);
+  }
+  /**
+   * Start the orchestrator:
+   * 1. Ensure workspace directories exist
+   * 2. Initialize TaskManager, AgentPool, MessageBroker, Scheduler, Planner
+   * 3. Load agent configs and register them with the broker
+   * 4. If no tasks exist, use Planner to decompose the project description
+   * 5. Start the polling loop
+   */
+  async start() {
+    if (this.running) {
+      logger9.warn("Orchestrator already running");
+      return;
+    }
+    const settings = this.config.settings;
+    await mkdir3(settings.messagesDirectory, { recursive: true });
+    await mkdir3(settings.logsDirectory, { recursive: true });
+    const [{ TaskManager: TaskManager2 }, { AgentPool: AgentPool2 }, { loadAgentConfigs: loadAgentConfigs2 }] = await Promise.all([
+      Promise.resolve().then(() => (init_manager(), manager_exports)),
+      Promise.resolve().then(() => (init_pool(), pool_exports)),
+      Promise.resolve().then(() => (init_config(), config_exports))
+    ]);
+    this.taskManager = new TaskManager2({ filePath: settings.todoFile, projectName: this.config.name });
+    this.agentPool = new AgentPool2();
+    this.broker = new MessageBroker(settings.messagesDirectory);
+    this.scheduler = new Scheduler();
+    this.scheduler.setPipeline(this.pipeline);
+    this.planner = new Planner({
+      model: settings.defaultModel,
+      workingDirectory: settings.workingDirectory,
+      claudeCommand: settings.claudeCommand,
+      claudeEnv: settings.claudeEnv,
+      techStack: this.config.techStack
+    });
+    this.feedbackLoop = new FeedbackLoop(settings.feedback);
+    this.feedbackLoop.on("plan:proposed", (p) => this.emit("plan:proposed", p));
+    this.feedbackLoop.on("plan:decided", (...args) => this.emit("plan:decided", ...args));
+    this.feedbackLoop.on("question:asked", (q) => this.emit("question:asked", q));
+    this.feedbackLoop.on("question:answered", (...args) => this.emit("question:answered", ...args));
+    this.feedbackLoop.on("progress:report", (r) => this.emit("progress:report", r));
+    this.feedbackLoop.on("milestone:reached", (m) => this.emit("milestone:reached", m));
+    this.feedbackLoop.on("milestone:acknowledged", (id) => this.emit("milestone:acknowledged", id));
+    this.feedbackLoop.on("interaction-mode:changed", (m) => this.emit("interaction-mode:changed", m));
+    const agentConfigs = loadAgentConfigs2(this.config);
+    const agentIds = agentConfigs.map((c) => c.id);
+    this.agentConfigs = agentConfigs;
+    this.emitActivity("info", `Orchestrator starting with ${agentConfigs.length} agent(s) configured`);
+    await this.broker.start(agentIds);
+    this.broker.on("message:received", (message) => {
+      this.emit("message:received", message);
+    });
+    this.broker.on("message:sent", (message) => {
+      this.emit("message:sent", message);
+    });
+    this.agentPool.on("agent:output", (event) => {
+      this.emit("agent:output", event);
+    });
+    this.agentPool.on("agent:status-changed", (agentId, oldStatus, newStatus) => {
+      this.emit("agent:status-changed", agentId, oldStatus, newStatus);
+    });
+    this.agentPool.on("agent:error", (agentId, error) => {
+      this.emit("agent:error", agentId, error);
+      this.emitActivity("agent-error", `Agent ${agentId} encountered an error: ${error.message}`, {
+        agentId
+      });
+    });
+    this.agentPool.on("agent:stopped", (agentId, exitCode) => {
+      this.emit("agent:stopped", agentId, exitCode);
+      this.emitActivity("agent-stopped", `Agent ${agentId} stopped (exit code: ${exitCode})`, {
+        agentId
+      });
+    });
+    this.agentPool.on("agent:spawned", (agentId) => {
+      const agent = this.agentPool.getAgent(agentId);
+      if (agent) {
+        this.emit("agent:spawned", agent.currentState);
+        this.emitActivity("agent-spawned", `Spawned agent ${agent.currentState.config.name} (${agent.currentState.config.role})`, {
+          agentId,
+          agentRole: agent.currentState.config.role
+        });
+      }
+    });
+    const existingTasks = await this.taskManager.load();
+    if (existingTasks.length === 0) {
+      logger9.info("No existing tasks found, decomposing project goal");
+      this.emitActivity("info", "No existing tasks found, decomposing project goal...");
+      const plannedTasks = await this.planner.decompose(this.config.description);
+      const summaries = plannedTasks.map((t) => ({
+        title: t.title,
+        description: t.description,
+        priority: t.priority,
+        assignedRole: "",
+        // Will be determined by scheduler
+        tags: t.tags
+      }));
+      this.emitActivity("plan-created", `Created plan with ${plannedTasks.length} task(s) from project goal`);
+      this.planApprovalPending = true;
+      this.feedbackLoop.proposePlan(summaries, this.config.description).then(async (decision) => {
+        this.planApprovalPending = false;
+        if (decision === "rejected") {
+          logger9.info("Plan rejected by user, stopping");
+          this.emitActivity("plan-rejected", "Plan rejected by user, stopping orchestrator");
+          await this.stop();
+          return;
+        }
+        this.emitActivity("plan-approved", "Plan approved, creating tasks...");
+        const titleToId = /* @__PURE__ */ new Map();
+        for (const planned of plannedTasks) {
+          const resolvedDeps = planned.dependencies.map((depTitle) => titleToId.get(depTitle)).filter((id) => id != null);
+          const task = await this.taskManager.createTask({
+            title: planned.title,
+            description: planned.description,
+            priority: planned.priority,
+            dependencies: resolvedDeps,
+            tags: planned.tags
+          });
+          titleToId.set(planned.title, task.id);
+          this.emit("task:created", task);
+          this.pipeline.initTask(task);
+        }
+        const allNewTasks = await this.taskManager.load();
+        this.emit("tasks:loaded", allNewTasks);
+        const hasArchTasks = plannedTasks.some((t) => t.tags.includes("architecture"));
+        this.phase = hasArchTasks ? "architecture" : "development";
+        this.emit("phase:changed", this.phase);
+        this.emitActivity("phase-changed", `Phase set to: ${this.phase}`, { toPhase: this.phase });
+        logger9.info({ count: plannedTasks.length, phase: this.phase }, "Initial tasks created from project goal");
+      }).catch((err) => {
+        this.planApprovalPending = false;
+        logger9.error({ err }, "Plan approval flow failed");
+      });
+    } else {
+      if (this.broker) {
+        await this.broker.cleanAllInboxes();
+      }
+      const staleTasks = existingTasks.filter((t) => t.status === "in-progress");
+      for (const task of staleTasks) {
+        await this.taskManager.updateTask(task.id, {
+          status: "pending",
+          assignee: null
+        });
+        logger9.info(
+          { taskId: task.id, previousAssignee: task.assignee },
+          "Reset stale in-progress task to pending (previous session ended)"
+        );
+      }
+      const refreshedTasks = staleTasks.length > 0 ? await this.taskManager.load() : existingTasks;
+      const archTasks = refreshedTasks.filter((t) => t.tags.includes("architecture"));
+      const archPending = archTasks.some((t) => t.status !== "done");
+      if (archTasks.length > 0 && archPending) {
+        this.phase = "architecture";
+      } else {
+        this.phase = "development";
+      }
+      this.emit("phase:changed", this.phase);
+      this.emitActivity("phase-changed", `Resuming in phase: ${this.phase} (${existingTasks.length} existing tasks)`, {
+        toPhase: this.phase
+      });
+      for (const task of existingTasks) {
+        if (!this.pipeline.has(task.id)) {
+          this.pipeline.initTask(task);
+        }
+      }
+      this.emit("tasks:loaded", refreshedTasks);
+      logger9.info({
+        phase: this.phase,
+        existingTaskCount: existingTasks.length,
+        staleTasksReset: staleTasks.length
+      }, "Resuming with existing tasks");
+    }
+    this.running = true;
+    this.startedAt = Date.now();
+    this.intervalId = setInterval(() => {
+      this.cycle().catch((err) => {
+        logger9.error({ err }, "Orchestrator cycle failed");
+      });
+    }, settings.pollIntervalMs);
+    await this.cycle();
+    this.pmScanner.start(() => {
+      this.runPMScan().catch((err) => {
+        logger9.error({ err }, "PM scan failed");
+      });
+    });
+    this.emitActivity("info", "Orchestrator started and running (PM scanner active)");
+    logger9.info("Orchestrator started");
+  }
+  /**
+   * Stop the orchestrator gracefully.
+   */
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    logger9.info("Stopping orchestrator");
+    this.emitActivity("info", "Orchestrator shutting down...");
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.pmScanner.stop();
+    if (this.agentPool) {
+      await this.agentPool.stopAll();
+    }
+    if (this.broker) {
+      await this.broker.stop();
+    }
+    if (this.feedbackLoop) {
+      this.feedbackLoop.cleanup();
+    }
+    this.running = false;
+    this.paused = false;
+    logger9.info("Orchestrator stopped");
+  }
+  /**
+   * Pause the orchestrator: stop the polling cycle and all running agents.
+   * Tasks and state are preserved so work can be resumed later.
+   */
+  async pause() {
+    if (!this.running || this.paused) return;
+    this.paused = true;
+    logger9.info("Pausing orchestrator");
+    this.emitActivity("info", "Orchestrator pausing \u2014 stopping agents...");
+    if (this.intervalId !== null) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.pmScanner.stop();
+    if (this.agentPool) {
+      await this.agentPool.stopAll();
+    }
+    if (this.taskManager) {
+      const tasks = await this.taskManager.load();
+      for (const task of tasks) {
+        if (task.status === "in-progress") {
+          await this.taskManager.updateTask(task.id, {
+            status: "pending",
+            assignee: null
+          });
+        }
+      }
+      const refreshed = await this.taskManager.load();
+      this.emit("tasks:loaded", refreshed);
+    }
+    this.emitActivity("info", "Orchestrator paused");
+    this.emit("orchestrator:paused");
+    logger9.info("Orchestrator paused");
+  }
+  /**
+   * Resume the orchestrator after a pause. Restarts the polling cycle
+   * and PM scanner so agents can be re-assigned to pending tasks.
+   */
+  async resume() {
+    if (!this.running || !this.paused) return;
+    this.paused = false;
+    logger9.info("Resuming orchestrator");
+    this.emitActivity("info", "Orchestrator resuming...");
+    if (this.broker) {
+      await this.broker.cleanAllInboxes();
+    }
+    const settings = this.config.settings;
+    this.intervalId = setInterval(() => {
+      this.cycle().catch((err) => {
+        logger9.error({ err }, "Orchestrator cycle failed");
+      });
+    }, settings.pollIntervalMs);
+    await this.cycle();
+    this.pmScanner.start(() => {
+      this.runPMScan().catch((err) => {
+        logger9.error({ err }, "PM scan failed");
+      });
+    });
+    this.emitActivity("info", "Orchestrator resumed");
+    this.emit("orchestrator:resumed");
+    logger9.info("Orchestrator resumed");
+  }
+  /**
+   * Add new instructions: decompose them into tasks and append to the
+   * existing todo.md without deleting any existing tasks.
+   */
+  async addInstructions(instructions) {
+    if (!this.planner || !this.taskManager) {
+      throw new Error("Orchestrator must be started before adding instructions");
+    }
+    this.emitActivity("info", "Decomposing new instructions into tasks...");
+    this.emit("instructions:decomposing", instructions);
+    const plannedTasks = await this.planner.decompose(instructions);
+    const existingTasks = await this.taskManager.load();
+    const titleToId = /* @__PURE__ */ new Map();
+    for (const t of existingTasks) {
+      titleToId.set(t.title, t.id);
+    }
+    const createdTasks = [];
+    for (const planned of plannedTasks) {
+      const resolvedDeps = planned.dependencies.map((depTitle) => titleToId.get(depTitle)).filter((id) => id != null);
+      const task = await this.taskManager.createTask({
+        title: planned.title,
+        description: planned.description,
+        priority: planned.priority,
+        dependencies: resolvedDeps,
+        tags: planned.tags
+      });
+      titleToId.set(planned.title, task.id);
+      this.emit("task:created", task);
+      this.pipeline.initTask(task);
+      createdTasks.push(task);
+    }
+    const allTasks = await this.taskManager.load();
+    this.emit("tasks:loaded", allTasks);
+    this.emitActivity("info", `Added ${createdTasks.length} new task(s) from instructions`);
+    this.emit("instructions:added", createdTasks);
+    logger9.info({ count: createdTasks.length }, "New tasks added from instructions");
+    return createdTasks;
+  }
+  /**
+   * A single orchestration cycle:
+   * 1. Load current tasks
+   * 2. Run scheduler to determine assignments
+   * 3. For each assignment: update task, send message, spawn agent
+   * 4. Handle pipeline handoffs for completed tasks
+   * 5. Check budget limits
+   * 6. Emit cycle stats
+   */
+  async cycle() {
+    if (!this.taskManager || !this.scheduler || !this.broker || !this.agentPool) {
+      return;
+    }
+    if (this.paused || this.planApprovalPending) {
+      return;
+    }
+    let tasks = await this.taskManager.load();
+    const poolAgents = this.agentPool.getAllAgents().map((a) => a.currentState);
+    let tasksUpdated = false;
+    for (const agentState of poolAgents) {
+      if (agentState.status === "stopped" || agentState.status === "error") {
+        const agentProcess = this.agentPool.getAgent(agentState.config.id);
+        if (agentProcess) {
+          agentProcess.setCurrentTask(null);
+        }
+        const assignedTask = tasks.find(
+          (t) => t.status === "in-progress" && t.assignee === agentState.config.id
+        );
+        if (assignedTask) {
+          if (agentState.status === "stopped") {
+            const handoff = this.pipeline.completeStage(assignedTask.id);
+            if (handoff && handoff.nextStage) {
+              this.emitActivity("pipeline-handoff", handoff.handoffMessage, {
+                taskId: assignedTask.id,
+                taskTitle: assignedTask.title,
+                agentId: agentState.config.id,
+                agentRole: agentState.config.role,
+                pipelineStage: handoff.nextStage
+              });
+              await this.taskManager.updateTask(assignedTask.id, {
+                status: "pending",
+                assignee: null,
+                notes: [
+                  ...assignedTask.notes,
+                  `[pipeline] Handed off to ${handoff.nextStage} stage`
+                ]
+              });
+              const handoffMsg = {
+                id: generateId(),
+                type: "task-update",
+                from: "orchestrator",
+                to: "*",
+                subject: `Pipeline Handoff: ${assignedTask.title}`,
+                body: `${handoff.handoffMessage}
+
+Task "${assignedTask.title}" (${assignedTask.id}) is now in the ${handoff.nextStage} stage. Required roles: ${handoff.requiredRoles.join(", ")}`,
+                taskId: assignedTask.id,
+                priority: assignedTask.priority === "critical" ? "urgent" : "normal",
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                metadata: {
+                  pipelineStage: handoff.nextStage,
+                  previousAgent: agentState.config.id
+                }
+              };
+              await this.broker.sendMessage(handoffMsg);
+            } else {
+              await this.taskManager.updateTask(assignedTask.id, { status: "done" });
+              this.emit("task:completed", assignedTask);
+              this.emitActivity("task-completed", `Task completed: ${assignedTask.title}`, {
+                taskId: assignedTask.id,
+                taskTitle: assignedTask.title,
+                agentId: agentState.config.id,
+                agentRole: agentState.config.role
+              });
+            }
+            logger9.info(
+              { taskId: assignedTask.id, agentId: agentState.config.id },
+              "Task stage completed (agent process stopped)"
+            );
+          } else if (agentState.rateLimited) {
+            this.pipeline.failStage(assignedTask.id);
+            await this.taskManager.updateTask(assignedTask.id, {
+              status: "pending",
+              assignee: null
+            });
+            const stats2 = this.getStats();
+            const totalTokens = stats2.totalInputTokens + stats2.totalOutputTokens + stats2.totalCacheReadTokens + stats2.totalCacheCreationTokens;
+            const resetInfo = agentState.rateLimitResetAt ? ` Resets at ${agentState.rateLimitResetAt}.` : "";
+            this.emitActivity(
+              "rate-limit",
+              `RATE LIMIT: Agent ${agentState.config.name} (${agentState.config.role}) hit API usage limit.${resetInfo} Total tokens used: ${this.formatTokenCount(totalTokens)} (in:${this.formatTokenCount(stats2.totalInputTokens)} out:${this.formatTokenCount(stats2.totalOutputTokens)} cache-r:${this.formatTokenCount(stats2.totalCacheReadTokens)} cache-w:${this.formatTokenCount(stats2.totalCacheCreationTokens)}) | $${stats2.totalCostUsd.toFixed(4)}`,
+              {
+                taskId: assignedTask.id,
+                taskTitle: assignedTask.title,
+                agentId: agentState.config.id,
+                agentRole: agentState.config.role,
+                rateLimitResetAt: agentState.rateLimitResetAt,
+                totalTokens,
+                cost: stats2.totalCostUsd
+              }
+            );
+            this.emit("rate-limit", agentState.config.id, agentState.rateLimitResetAt);
+            await this.broker.cleanInboxForTask(agentState.config.id, assignedTask.id);
+            logger9.warn(
+              { taskId: assignedTask.id, agentId: agentState.config.id, resetAt: agentState.rateLimitResetAt },
+              "Agent hit rate limit \u2014 task reset to pending"
+            );
+          } else {
+            this.pipeline.failStage(assignedTask.id);
+            await this.taskManager.updateTask(assignedTask.id, {
+              status: "pending",
+              assignee: null
+            });
+            this.emitActivity("task-failed", `Task failed and reset: ${assignedTask.title} (agent ${agentState.config.id} errored)`, {
+              taskId: assignedTask.id,
+              taskTitle: assignedTask.title,
+              agentId: agentState.config.id
+            });
+            await this.broker.cleanInboxForTask(agentState.config.id, assignedTask.id);
+            logger9.warn(
+              { taskId: assignedTask.id, agentId: agentState.config.id },
+              "Task reset to pending (agent process errored)"
+            );
+          }
+          tasksUpdated = true;
+        }
+      }
+    }
+    const activeAgentIds = new Set(
+      poolAgents.filter((a) => a.status === "running" || a.status === "starting").map((a) => a.config.id)
+    );
+    for (const task of tasks) {
+      if (task.status !== "in-progress") continue;
+      if (!task.assignee) {
+        await this.taskManager.updateTask(task.id, { status: "pending", assignee: null });
+        this.emitActivity("info", `Reset orphaned task "${task.title}" (no assignee)`, { taskId: task.id });
+        tasksUpdated = true;
+        continue;
+      }
+      if (!activeAgentIds.has(task.assignee)) {
+        const inPool = poolAgents.find((a) => a.config.id === task.assignee);
+        if (!inPool || inPool.status === "idle" || inPool.status === "stopped" || inPool.status === "error") {
+          await this.taskManager.updateTask(task.id, { status: "pending", assignee: null });
+          this.emitActivity("info", `Reset orphaned task "${task.title}" (agent ${task.assignee} ${inPool ? inPool.status : "not in pool"})`, {
+            taskId: task.id,
+            agentId: task.assignee
+          });
+          logger9.info({ taskId: task.id, assignee: task.assignee, agentStatus: inPool?.status }, "Reset orphaned in-progress task");
+          tasksUpdated = true;
+        }
+      }
+    }
+    for (const task of tasks) {
+      if (task.status !== "blocked") continue;
+      if (task.dependencies.length === 0) {
+        await this.taskManager.updateTask(task.id, { status: "pending" });
+        this.emitActivity("info", `Unblocked task "${task.title}" (no dependencies)`, { taskId: task.id });
+        tasksUpdated = true;
+        continue;
+      }
+      const allDepsResolved = task.dependencies.every((depId) => {
+        const dep = tasks.find((t) => t.id === depId);
+        return !dep || dep.status === "done" || dep.status === "cancelled";
+      });
+      if (allDepsResolved) {
+        await this.taskManager.updateTask(task.id, { status: "pending" });
+        this.emitActivity("info", `Unblocked task "${task.title}" (all dependencies resolved)`, { taskId: task.id });
+        tasksUpdated = true;
+      }
+    }
+    if (tasksUpdated) {
+      tasks = await this.taskManager.load();
+    }
+    this.cachedTasks = tasks;
+    if (this.feedbackLoop) {
+      this.feedbackLoop.checkProgress(tasks, this.getStats());
+    }
+    if (tasks.length > 0) {
+      const allDone = tasks.every((t) => t.status === "done" || t.status === "cancelled");
+      if (allDone) {
+        const summary = this.buildCompletionSummary(tasks);
+        this.emit("project:completed", summary);
+        this.emitActivity("project-completed", `All ${summary.totalTasks} tasks completed! Total cost: $${summary.totalCostUsd.toFixed(4)}`);
+        logger9.info({ totalTasks: summary.totalTasks, totalCost: summary.totalCostUsd }, "All tasks completed");
+        await this.stop();
+        return;
+      }
+    }
+    if (this.phase === "architecture") {
+      if (this.architectureApprovalPending) {
+        return;
+      }
+      const archTasks = tasks.filter((t) => t.tags.includes("architecture"));
+      const allArchDone = archTasks.length > 0 && archTasks.every((t) => t.status === "done");
+      if (allArchDone) {
+        const mode = this.feedbackLoop?.interactionMode ?? "unattended";
+        if (mode === "supervised" || mode === "interactive") {
+          this.architectureApprovalPending = true;
+          this.emit("architecture:ready", archTasks);
+          this.emitActivity("phase-changed", "Architecture phase complete, waiting for user review", {
+            fromPhase: "architecture"
+          });
+          logger9.info("Architecture phase complete, waiting for user review");
+          return;
+        } else {
+          this.phase = "development";
+          this.emit("phase:changed", "development");
+          this.emitActivity("phase-changed", "Architecture complete, advancing to development", {
+            fromPhase: "architecture",
+            toPhase: "development"
+          });
+          logger9.info("Architecture phase complete, advancing to development");
+        }
+      }
+    }
+    const poolAgentIds = new Set(poolAgents.map((a) => a.config.id));
+    const virtualAgentStates = poolAgents.map((a) => {
+      if (a.status === "stopped" || a.status === "error") {
+        return { ...a, status: "idle" };
+      }
+      return a;
+    });
+    for (const config of this.agentConfigs) {
+      if (!poolAgentIds.has(config.id)) {
+        virtualAgentStates.push({
+          config,
+          status: "idle",
+          pid: null,
+          sessionId: null,
+          currentTask: null,
+          startedAt: null,
+          lastActivityAt: null,
+          totalCostUsd: 0,
+          turnCount: 0,
+          totalInputTokens: 0,
+          totalOutputTokens: 0,
+          totalCacheReadTokens: 0,
+          totalCacheCreationTokens: 0,
+          error: null,
+          resultError: null,
+          rateLimited: false,
+          rateLimitResetAt: null
+        });
+      }
+    }
+    let schedulerTasks = tasks;
+    let schedulerAgents = virtualAgentStates;
+    if (this.phase === "architecture") {
+      schedulerTasks = tasks.filter((t) => t.tags.includes("architecture"));
+      schedulerAgents = virtualAgentStates.filter((a) => a.config.role === "architect");
+    }
+    const assignments = this.scheduler.schedule(schedulerTasks, schedulerAgents);
+    for (const assignment of assignments) {
+      const task = tasks.find((t) => t.id === assignment.taskId);
+      if (!task) continue;
+      if (!this.pipeline.has(task.id)) {
+        this.pipeline.initTask(task);
+      }
+      this.pipeline.startStage(task.id, assignment.agentId);
+      const pipelineState = this.pipeline.getState(task.id);
+      const currentStage = pipelineState?.currentStage ?? "develop";
+      await this.taskManager.updateTask(assignment.taskId, {
+        status: "in-progress",
+        assignee: assignment.agentId
+      });
+      this.emit("task:assigned", task, assignment.agentId);
+      const agentConfig = this.agentConfigs.find((c) => c.id === assignment.agentId);
+      const agentRole = agentConfig?.role ?? "unknown";
+      this.emitActivity("task-delegated", `Delegated "${task.title}" to ${agentConfig?.name ?? assignment.agentId} (${agentRole}) [stage: ${currentStage}]`, {
+        taskId: task.id,
+        taskTitle: task.title,
+        agentId: assignment.agentId,
+        agentRole,
+        pipelineStage: currentStage
+      });
+      const pipelineContext = pipelineState ? `
+
+**Pipeline Stage:** ${currentStage}
+**Pipeline History:** ${pipelineState.stageHistory.map((h) => `${h.stage}(${h.status})`).join(" -> ") || "none"}` : "";
+      const message = {
+        id: generateId(),
+        type: "task-assignment",
+        from: "orchestrator",
+        to: assignment.agentId,
+        subject: `Task Assignment: ${task.title}`,
+        body: this.buildTaskPrompt(task) + pipelineContext,
+        taskId: task.id,
+        priority: task.priority === "critical" ? "urgent" : "normal",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        metadata: {
+          pipelineStage: currentStage
+        }
+      };
+      await this.broker.sendMessage(message);
+      const taskLabel = `${task.id}: ${task.title}`;
+      try {
+        const existingAgent = this.agentPool.getAgent(assignment.agentId);
+        if (existingAgent) {
+          existingAgent.setCurrentTask(taskLabel);
+          const agentStatus = existingAgent.currentState.status;
+          if (agentStatus === "stopped" || agentStatus === "error") {
+            if (existingAgent.currentState.sessionId && agentStatus === "stopped") {
+              await existingAgent.resume(message.body);
+            } else {
+              this.agentPool.removeAgent(assignment.agentId);
+              if (agentConfig) {
+                const newAgent = await this.agentPool.spawnAgent(agentConfig, message.body);
+                newAgent.setCurrentTask(taskLabel);
+              }
+            }
+          }
+        } else {
+          if (agentConfig) {
+            const newAgent = await this.agentPool.spawnAgent(agentConfig, message.body);
+            newAgent.setCurrentTask(taskLabel);
+          }
+        }
+      } catch (err) {
+        logger9.error(
+          { err, agentId: assignment.agentId, taskId: assignment.taskId },
+          "Failed to spawn agent for task"
+        );
+        this.emitActivity("agent-error", `Failed to spawn agent ${assignment.agentId} for task ${task.title}`, {
+          agentId: assignment.agentId,
+          taskId: task.id,
+          taskTitle: task.title
+        });
+      }
+    }
+    this.checkBudget();
+    const stats = this.getStats();
+    this.emit("orchestrator:cycle", stats);
+    const pendingCount = tasks.filter((t) => t.status === "pending").length;
+    const inProgressCount = tasks.filter((t) => t.status === "in-progress").length;
+    const doneCount = tasks.filter((t) => t.status === "done").length;
+    const activeCount = stats.activeAgents;
+    if (tasks.length > 0) {
+      const totalTokens = stats.totalInputTokens + stats.totalOutputTokens + stats.totalCacheReadTokens + stats.totalCacheCreationTokens;
+      const tokenStr = totalTokens > 0 ? ` | ${this.formatTokenCount(totalTokens)} tokens (in:${this.formatTokenCount(stats.totalInputTokens)} out:${this.formatTokenCount(stats.totalOutputTokens)} cache-r:${this.formatTokenCount(stats.totalCacheReadTokens)} cache-w:${this.formatTokenCount(stats.totalCacheCreationTokens)})` : "";
+      this.emitActivity(
+        "cycle-summary",
+        `Cycle: ${doneCount}/${tasks.length} done | ${inProgressCount} in-progress | ${pendingCount} pending | ${activeCount} agent(s) active | $${stats.totalCostUsd.toFixed(4)}${tokenStr}`
+      );
+    }
+  }
+  /**
+   * Run a single PM scan pass — assess project health, identify gaps and
+   * blockers, and surface findings in the orchestrator activity log.
+   */
+  async runPMScan() {
+    if (!this.running || !this.taskManager || !this.agentPool) return;
+    const tasks = await this.taskManager.load();
+    if (tasks.length === 0) return;
+    const poolAgents = this.agentPool.getAllAgents().map((a) => a.currentState);
+    const poolAgentIds = new Set(poolAgents.map((a) => a.config.id));
+    const allAgentStates = [...poolAgents];
+    for (const config of this.agentConfigs) {
+      if (!poolAgentIds.has(config.id)) {
+        allAgentStates.push({
+          config,
+          status: "idle",
+          pid: null,
+          sessionId: null,
+          currentTask: null,
+          startedAt: null,
+          lastActivityAt: null,
+          totalCostUsd: 0,
+          turnCount: 0,
+          totalInputTokens: 0,
+          totalOutputTokens: 0,
+          totalCacheReadTokens: 0,
+          totalCacheCreationTokens: 0,
+          error: null,
+          resultError: null,
+          rateLimited: false,
+          rateLimitResetAt: null
+        });
+      }
+    }
+    const result = this.pmScanner.scan(tasks, allAgentStates, this.phase);
+    for (const finding of result.findings) {
+      if (finding.kind === "all-clear") {
+        continue;
+      }
+      const activityKind = finding.severity === "critical" ? "gap-detected" : "info";
+      this.emitActivity(activityKind, `[PM] ${finding.message}`, {
+        taskId: finding.taskId,
+        agentId: finding.agentId
+      });
+    }
+    this.emitActivity("pm-scan", result.summary);
+    if (this.broker) {
+      const messages = this.pmScanner.buildMessages(result);
+      for (const msg of messages) {
+        try {
+          await this.broker.sendMessage(msg);
+        } catch (err) {
+          logger9.error({ err, msgId: msg.id }, "Failed to send PM scan message");
+        }
+      }
+    }
+    logger9.debug({ findingCount: result.findings.length }, "PM scan complete");
+  }
+  /**
+   * Build a task prompt for an agent.
+   */
+  buildTaskPrompt(task) {
+    const parts = [
+      `# Task: ${task.title}`,
+      `**ID:** ${task.id}`,
+      `**Priority:** ${task.priority}`,
+      "",
+      task.description
+    ];
+    if (task.tags.length > 0) {
+      parts.push("", `**Tags:** ${task.tags.join(", ")}`);
+    }
+    if (task.notes.length > 0) {
+      parts.push("", "**Notes:**");
+      for (const note of task.notes) {
+        parts.push(`- ${note}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  /**
+   * Check whether the total cost across all agents exceeds the budget.
+   */
+  checkBudget() {
+    const maxBudget = this.config.settings.maxTotalBudgetUsd;
+    if (maxBudget == null) return;
+    const agentStates = this.agentPool.getAllAgents().map((a) => a.currentState);
+    const totalCost = agentStates.reduce(
+      (sum, a) => sum + a.totalCostUsd,
+      0
+    );
+    const warningThreshold = maxBudget * 0.8;
+    if (totalCost >= maxBudget) {
+      this.emit("budget:exceeded", totalCost, maxBudget);
+      this.emitActivity("budget-warning", `Budget exceeded: $${totalCost.toFixed(4)} / $${maxBudget.toFixed(2)}`, {
+        cost: totalCost
+      });
+      logger9.warn({ totalCost, maxBudget }, "Budget exceeded, stopping orchestrator");
+      this.stop().catch((err) => {
+        logger9.error({ err }, "Failed to stop orchestrator after budget exceeded");
+      });
+    } else if (totalCost >= warningThreshold) {
+      this.emit("budget:warning", totalCost, maxBudget);
+      this.emitActivity("budget-warning", `Approaching budget limit: $${totalCost.toFixed(4)} / $${maxBudget.toFixed(2)} (${(totalCost / maxBudget * 100).toFixed(0)}%)`, {
+        cost: totalCost
+      });
+      logger9.warn({ totalCost, maxBudget }, "Approaching budget limit");
+    }
+  }
+  /**
+   * Get all current tasks.
+   */
+  async getTasks() {
+    if (!this.taskManager) return [];
+    return this.taskManager.load();
+  }
+  /**
+   * Get all agent states.
+   */
+  getAgentStates() {
+    if (!this.agentPool) return [];
+    return this.agentPool.getAllAgents().map((a) => a.currentState);
+  }
+  /**
+   * Get the pipeline state for a specific task.
+   */
+  getTaskPipelineState(taskId) {
+    return this.pipeline.getState(taskId);
+  }
+  /**
+   * Get current orchestrator statistics.
+   */
+  getStats() {
+    const tasks = this.cachedTasks;
+    const agentStates = this.agentPool ? this.agentPool.getAllAgents().map((a) => a.currentState) : [];
+    const spawnedIds = new Set(agentStates.map((a) => a.config.id));
+    const completedTasks = tasks.filter((t) => t.status === "done").length;
+    const activeAgents = agentStates.filter(
+      (a) => a.status === "running" || a.status === "starting"
+    ).length;
+    const totalCostUsd = agentStates.reduce(
+      (sum, a) => sum + a.totalCostUsd,
+      0
+    );
+    const totalInputTokens = agentStates.reduce(
+      (sum, a) => sum + a.totalInputTokens,
+      0
+    );
+    const totalOutputTokens = agentStates.reduce(
+      (sum, a) => sum + a.totalOutputTokens,
+      0
+    );
+    const totalCacheReadTokens = agentStates.reduce(
+      (sum, a) => sum + a.totalCacheReadTokens,
+      0
+    );
+    const totalCacheCreationTokens = agentStates.reduce(
+      (sum, a) => sum + a.totalCacheCreationTokens,
+      0
+    );
+    const uptimeMs = this.startedAt ? Date.now() - this.startedAt : 0;
+    const agents = agentStates.map((a) => ({
+      id: a.config.id,
+      name: a.config.name,
+      role: a.config.role,
+      status: a.status,
+      spawned: true,
+      currentTask: a.currentTask
+    }));
+    for (const config of this.agentConfigs) {
+      if (!spawnedIds.has(config.id)) {
+        agents.push({
+          id: config.id,
+          name: config.name,
+          role: config.role,
+          status: "idle",
+          spawned: false,
+          currentTask: null
+        });
+      }
+    }
+    return {
+      totalTasks: tasks.length,
+      completedTasks,
+      activeAgents,
+      totalCostUsd,
+      totalInputTokens,
+      totalOutputTokens,
+      totalCacheReadTokens,
+      totalCacheCreationTokens,
+      uptimeMs,
+      agents
+    };
+  }
+  /**
+   * Format a token count for display (e.g. 1234567 → "1.23M", 45678 → "45.7k").
+   */
+  formatTokenCount(tokens) {
+    if (tokens >= 1e6) {
+      return `${(tokens / 1e6).toFixed(2)}M`;
+    }
+    if (tokens >= 1e3) {
+      return `${(tokens / 1e3).toFixed(1)}k`;
+    }
+    return String(tokens);
+  }
+  /**
+   * Build a summary of the completed project for reporting.
+   */
+  buildCompletionSummary(tasks) {
+    const agentStates = this.agentPool ? this.agentPool.getAllAgents().map((a) => a.currentState) : [];
+    const agentTaskCounts = /* @__PURE__ */ new Map();
+    for (const task of tasks) {
+      if (task.assignee && task.status === "done") {
+        agentTaskCounts.set(task.assignee, (agentTaskCounts.get(task.assignee) ?? 0) + 1);
+      }
+    }
+    const agentSummaries = agentStates.map((a) => ({
+      agentId: a.config.id,
+      name: a.config.name,
+      role: a.config.role,
+      tasksCompleted: agentTaskCounts.get(a.config.id) ?? 0,
+      costUsd: a.totalCostUsd,
+      inputTokens: a.totalInputTokens ?? 0,
+      outputTokens: a.totalOutputTokens ?? 0
+    }));
+    const doneTasks = tasks.filter((t) => t.status === "done").length;
+    const cancelledTasks = tasks.filter((t) => t.status === "cancelled").length;
+    return {
+      totalTasks: tasks.length,
+      doneTasks,
+      cancelledTasks,
+      totalCostUsd: agentStates.reduce((sum, a) => sum + a.totalCostUsd, 0),
+      totalInputTokens: agentStates.reduce((sum, a) => sum + (a.totalInputTokens ?? 0), 0),
+      totalOutputTokens: agentStates.reduce((sum, a) => sum + (a.totalOutputTokens ?? 0), 0),
+      totalCacheReadTokens: agentStates.reduce((sum, a) => sum + (a.totalCacheReadTokens ?? 0), 0),
+      totalCacheCreationTokens: agentStates.reduce((sum, a) => sum + (a.totalCacheCreationTokens ?? 0), 0),
+      uptimeMs: this.startedAt ? Date.now() - this.startedAt : 0,
+      agentSummaries,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  /**
+   * Approve the architecture and advance to development phase.
+   */
+  approveArchitecture() {
+    if (this.architectureApprovalPending) {
+      this.architectureApprovalPending = false;
+      this.phase = "development";
+      this.emit("phase:changed", "development");
+      this.emitActivity("phase-changed", "Architecture approved, advancing to development phase", {
+        fromPhase: "architecture",
+        toPhase: "development"
+      });
+      logger9.info("Architecture approved, advancing to development phase");
+    }
+  }
+  /**
+   * Get the current orchestration phase.
+   */
+  getPhase() {
+    return this.phase;
+  }
+  decidePlan(proposalId, decision, modifications) {
+    this.feedbackLoop?.decidePlan(proposalId, decision, modifications);
+  }
+  answerQuestion(questionId, answer) {
+    this.feedbackLoop?.answerQuestion(questionId, answer);
+  }
+  acknowledgeMilestone(milestoneId) {
+    this.feedbackLoop?.acknowledgeMilestone(milestoneId);
+  }
+  setInteractionMode(mode) {
+    this.feedbackLoop?.setMode(mode);
+  }
+  getInteractionMode() {
+    return this.feedbackLoop?.interactionMode ?? "supervised";
+  }
+  getPendingPlan() {
+    return this.feedbackLoop?.getPendingPlan() ?? null;
+  }
+  getPendingQuestions() {
+    return this.feedbackLoop?.getPendingQuestions() ?? [];
+  }
+  /**
+   * Get processed messages for a specific task (for task detail view).
+   */
+  async getTaskMessages(taskId) {
+    if (!this.broker) return [];
+    return this.broker.getProcessedMessagesForTask(taskId);
+  }
+};
+
+// src/project/config.ts
+import { z } from "zod";
+import { readFile as readFile4 } from "fs/promises";
+import { parse as parseYaml } from "yaml";
+var permissionModeSchema = z.enum(["default", "acceptEdits", "bypassPermissions"]);
+var agentRoleConfigSchema = z.object({
+  role: z.enum(["orchestrator", "project-manager", "architect", "developer", "designer", "qa-engineer", "devops", "technical-writer", "code-reviewer"]),
+  count: z.number().int().min(1),
+  model: z.string().optional(),
+  systemPromptFile: z.string().optional(),
+  systemPromptOverride: z.string().optional(),
+  allowedTools: z.array(z.string()).optional(),
+  maxBudgetUsd: z.number().positive().optional(),
+  permissionMode: permissionModeSchema.optional(),
+  claudeArgs: z.array(z.string()).optional(),
+  claudeEnv: z.record(z.string()).optional(),
+  maxTurns: z.number().int().positive().optional()
+});
+var projectSettingsSchema = z.object({
+  workingDirectory: z.string().default("."),
+  todoFile: z.string().default("todo.md"),
+  messagesDirectory: z.string().default(".maestro/messages"),
+  logsDirectory: z.string().default(".maestro/logs"),
+  defaultModel: z.string().default("sonnet"),
+  maxConcurrentAgents: z.number().int().min(1).default(5),
+  pollIntervalMs: z.number().int().min(500).default(5e3),
+  maxTotalBudgetUsd: z.number().positive().optional(),
+  claudeCommand: z.string().optional(),
+  claudeArgs: z.array(z.string()).optional(),
+  claudeEnv: z.record(z.string()).optional(),
+  feedback: z.object({
+    interactionMode: z.enum(["unattended", "supervised", "interactive"]).default("supervised"),
+    progressReportIntervalMs: z.number().int().min(1e3).default(6e4),
+    milestonePercentages: z.array(z.number().min(0).max(100)).default([25, 50, 75, 100]),
+    questionTimeoutMs: z.number().int().min(1e3).default(3e5),
+    requirePlanApproval: z.boolean().default(true)
+  }).optional()
+});
+var techStackSchema = z.object({
+  frontend: z.string().optional(),
+  uiLibrary: z.string().optional(),
+  backend: z.string().optional(),
+  database: z.string().optional(),
+  other: z.string().optional()
+}).optional();
+var projectConfigSchema = z.object({
+  name: z.string().min(1),
+  description: z.string(),
+  version: z.string(),
+  agents: z.array(agentRoleConfigSchema).min(1),
+  settings: projectSettingsSchema.default({}),
+  techStack: techStackSchema
+});
+async function loadProjectConfig(filePath) {
+  const raw = await readFile4(filePath, "utf-8");
+  const parsed = parseYaml(raw);
+  return validateProjectConfig(parsed);
+}
+function validateProjectConfig(config) {
+  return projectConfigSchema.parse(config);
+}
+
+// src/project/workspace.ts
+import { mkdir as mkdir4 } from "fs/promises";
+import path2 from "path";
+var WorkspaceManager = class {
+  baseDir;
+  config = null;
+  constructor(baseDir) {
+    this.baseDir = path2.resolve(baseDir);
+  }
+  /**
+   * Create all runtime directories required by the project.
+   *
+   * This creates the top-level .maestro directory, the messages directory,
+   * the logs directory, and per-agent inbox/outbox directories for every
+   * agent defined in the project config.
+   */
+  async initialize(config) {
+    this.config = config;
+    const messagesDir = this.getMessagesDir();
+    const logsDir = this.getLogsDir();
+    await mkdir4(messagesDir, { recursive: true });
+    await mkdir4(logsDir, { recursive: true });
+    for (const agentRoleConfig of config.agents) {
+      for (let i = 0; i < agentRoleConfig.count; i++) {
+        const agentId = agentRoleConfig.count === 1 ? agentRoleConfig.role : `${agentRoleConfig.role}-${i + 1}`;
+        await mkdir4(this.getAgentInboxPath(agentId), { recursive: true });
+        await mkdir4(this.getAgentOutboxPath(agentId), { recursive: true });
+      }
+    }
+  }
+  /**
+   * Get the absolute path to the project's todo file.
+   */
+  getTodoFilePath() {
+    const todoFile = this.config?.settings.todoFile ?? "todo.md";
+    return path2.resolve(this.baseDir, todoFile);
+  }
+  /**
+   * Get the absolute path to the messages directory.
+   */
+  getMessagesDir() {
+    const messagesDir = this.config?.settings.messagesDirectory ?? ".maestro/messages";
+    return path2.resolve(this.baseDir, messagesDir);
+  }
+  /**
+   * Get the absolute path to the logs directory.
+   */
+  getLogsDir() {
+    const logsDir = this.config?.settings.logsDirectory ?? ".maestro/logs";
+    return path2.resolve(this.baseDir, logsDir);
+  }
+  /**
+   * Get the absolute path to a specific agent's log file.
+   */
+  getAgentLogPath(agentId) {
+    return path2.resolve(this.getLogsDir(), `${agentId}.log`);
+  }
+  /**
+   * Get the absolute path to a specific agent's inbox directory.
+   */
+  getAgentInboxPath(agentId) {
+    return path2.resolve(this.getMessagesDir(), agentId, "inbox");
+  }
+  /**
+   * Get the absolute path to a specific agent's outbox directory.
+   */
+  getAgentOutboxPath(agentId) {
+    return path2.resolve(this.getMessagesDir(), agentId, "outbox");
+  }
+};
+
+// src/index.ts
+init_logger();
+init_id();
+export {
+  AgentPool,
+  AgentProcess,
+  FeedbackLoop,
+  InboxWatcher,
+  MessageBroker,
+  Orchestrator,
+  PIPELINE_STAGE_ORDER,
+  PIPELINE_STAGE_ROLES,
+  Planner,
+  ProgressTracker,
+  ProjectManagerScanner,
+  ROLE_DESCRIPTIONS,
+  Scheduler,
+  TaskManager,
+  TaskParser,
+  TaskPipeline,
+  TaskWriter,
+  WorkspaceManager,
+  createLogger,
+  generateId,
+  generateTaskId,
+  getDefaultSystemPrompt,
+  loadAgentConfigs,
+  loadProjectConfig,
+  resetTaskCounter,
+  validateProjectConfig
+};
+//# sourceMappingURL=index.js.map